mirror of
https://github.com/lightningdevkit/rust-lightning.git
synced 2025-02-24 15:02:20 +01:00
Update ChannelManager's FeeEstimator from Arc to Deref.
This commit is contained in:
Valentine Wallace
parent
f328094b49
commit
f5b5bf2acb
9 changed files with 163 additions and 112 deletions
|
|
@ -75,7 +75,7 @@ impl Writer for VecWriter {
|
|||
|
||||
pub struct TestChannelMonitor {
|
||||
pub logger: Arc<dyn Logger>,
|
||||
pub simple_monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<chaininterface::BroadcasterInterface>>>,
|
||||
pub simple_monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<BroadcasterInterface>, Arc<FeeEstimator>>>,
|
||||
pub update_ret: Mutex<Result<(), channelmonitor::ChannelMonitorUpdateErr>>,
|
||||
// If we reload a node with an old copy of ChannelMonitors, the ChannelManager deserialization
|
||||
// logic will automatically force-close our channels for us (as we don't have an up-to-date
|
||||
|
|
@ -86,7 +86,7 @@ pub struct TestChannelMonitor {
|
|||
pub should_update_manager: atomic::AtomicBool,
|
||||
}
|
||||
impl TestChannelMonitor {
|
||||
pub fn new(chain_monitor: Arc<dyn chaininterface::ChainWatchInterface>, broadcaster: Arc<dyn chaininterface::BroadcasterInterface>, logger: Arc<dyn Logger>, feeest: Arc<dyn chaininterface::FeeEstimator>) -> Self {
|
||||
pub fn new(chain_monitor: Arc<dyn chaininterface::ChainWatchInterface>, broadcaster: Arc<dyn chaininterface::BroadcasterInterface>, logger: Arc<dyn Logger>, feeest: Arc<FeeEstimator>) -> Self {
|
||||
Self {
|
||||
simple_monitor: Arc::new(channelmonitor::SimpleManyChannelMonitor::new(chain_monitor, broadcaster, logger.clone(), feeest)),
|
||||
logger,
|
||||
|
|
@ -233,7 +233,7 @@ pub fn do_test(data: &[u8]) {
|
|||
channel_monitors: &mut monitor_refs,
|
||||
};
|
||||
|
||||
(<(Sha256d, ChannelManager<EnforcingChannelKeys, Arc<TestChannelMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor)
|
||||
(<(Sha256d, ChannelManager<EnforcingChannelKeys, Arc<TestChannelMonitor>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>)>::read(&mut Cursor::new(&$ser.0), read_args).expect("Failed to read manager").1, monitor)
|
||||
} }
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -136,9 +136,9 @@ impl<'a> Hash for Peer<'a> {
|
|||
}
|
||||
|
||||
struct MoneyLossDetector<'a> {
|
||||
manager: Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>, Arc<TestBroadcaster>, Arc<KeyProvider>>>,
|
||||
monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>,
|
||||
handler: PeerManager<Peer<'a>, Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>, Arc<TestBroadcaster>, Arc<KeyProvider>>>>,
|
||||
manager: Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>>,
|
||||
monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>,
|
||||
handler: PeerManager<Peer<'a>, Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>>>,
|
||||
|
||||
peers: &'a RefCell<[bool; 256]>,
|
||||
funding_txn: Vec<Transaction>,
|
||||
|
|
@ -150,9 +150,9 @@ struct MoneyLossDetector<'a> {
|
|||
}
|
||||
impl<'a> MoneyLossDetector<'a> {
|
||||
pub fn new(peers: &'a RefCell<[bool; 256]>,
|
||||
manager: Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>, Arc<TestBroadcaster>, Arc<KeyProvider>>>,
|
||||
monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>,
|
||||
handler: PeerManager<Peer<'a>, Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>>>, Arc<TestBroadcaster>, Arc<KeyProvider>>>>) -> Self {
|
||||
manager: Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>>,
|
||||
monitor: Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>,
|
||||
handler: PeerManager<Peer<'a>, Arc<ChannelManager<EnforcingChannelKeys, Arc<channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, Arc<TestBroadcaster>, Arc<FuzzEstimator>>>, Arc<TestBroadcaster>, Arc<KeyProvider>, Arc<FuzzEstimator>>>>) -> Self {
|
||||
MoneyLossDetector {
|
||||
manager,
|
||||
monitor,
|
||||
|
|
|
|||
|
|
@ -438,8 +438,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
}
|
||||
|
||||
// Constructors:
|
||||
pub fn new_outbound<K: Deref>(fee_estimator: &FeeEstimator, keys_provider: &K, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel<ChanSigner>, APIError>
|
||||
where K::Target: KeysInterface<ChanKeySigner = ChanSigner>
|
||||
pub fn new_outbound<K: Deref, F: Deref>(fee_estimator: &F, keys_provider: &K, their_node_id: PublicKey, channel_value_satoshis: u64, push_msat: u64, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel<ChanSigner>, APIError>
|
||||
where K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
let chan_keys = keys_provider.get_channel_keys(false, channel_value_satoshis);
|
||||
|
||||
|
|
@ -541,7 +542,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
})
|
||||
}
|
||||
|
||||
fn check_remote_fee(fee_estimator: &FeeEstimator, feerate_per_kw: u32) -> Result<(), ChannelError> {
|
||||
fn check_remote_fee<F: Deref>(fee_estimator: &F, feerate_per_kw: u32) -> Result<(), ChannelError>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if (feerate_per_kw as u64) < fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background) {
|
||||
return Err(ChannelError::Close("Peer's feerate much too low"));
|
||||
}
|
||||
|
|
@ -553,8 +556,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
|
||||
/// Creates a new channel from a remote sides' request for one.
|
||||
/// Assumes chain_hash has already been checked and corresponds with what we expect!
|
||||
pub fn new_from_req<K: Deref>(fee_estimator: &FeeEstimator, keys_provider: &K, their_node_id: PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel<ChanSigner>, ChannelError>
|
||||
where K::Target: KeysInterface<ChanKeySigner = ChanSigner>
|
||||
pub fn new_from_req<K: Deref, F: Deref>(fee_estimator: &F, keys_provider: &K, their_node_id: PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel, user_id: u64, logger: Arc<Logger>, config: &UserConfig) -> Result<Channel<ChanSigner>, ChannelError>
|
||||
where K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
let mut chan_keys = keys_provider.get_channel_keys(true, msg.funding_satoshis);
|
||||
let their_pubkeys = ChannelPublicKeys {
|
||||
|
|
@ -1777,7 +1781,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
pub fn commitment_signed(&mut self, msg: &msgs::CommitmentSigned, fee_estimator: &FeeEstimator) -> Result<(msgs::RevokeAndACK, Option<msgs::CommitmentSigned>, Option<msgs::ClosingSigned>, ChannelMonitorUpdate), (Option<ChannelMonitorUpdate>, ChannelError)> {
|
||||
pub fn commitment_signed<F: Deref>(&mut self, msg: &msgs::CommitmentSigned, fee_estimator: &F) -> Result<(msgs::RevokeAndACK, Option<msgs::CommitmentSigned>, Option<msgs::ClosingSigned>, ChannelMonitorUpdate), (Option<ChannelMonitorUpdate>, ChannelError)> where F::Target: FeeEstimator {
|
||||
if (self.channel_state & (ChannelState::ChannelFunded as u32)) != (ChannelState::ChannelFunded as u32) {
|
||||
return Err((None, ChannelError::Close("Got commitment signed message when channel was not in an operational state")));
|
||||
}
|
||||
|
|
@ -2065,7 +2069,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
/// waiting on this revoke_and_ack. The generation of this new commitment_signed may also fail,
|
||||
/// generating an appropriate error *after* the channel state has been updated based on the
|
||||
/// revoke_and_ack message.
|
||||
pub fn revoke_and_ack(&mut self, msg: &msgs::RevokeAndACK, fee_estimator: &FeeEstimator) -> Result<(Option<msgs::CommitmentUpdate>, Vec<(PendingHTLCInfo, u64)>, Vec<(HTLCSource, PaymentHash, HTLCFailReason)>, Option<msgs::ClosingSigned>, ChannelMonitorUpdate), ChannelError> {
|
||||
pub fn revoke_and_ack<F: Deref>(&mut self, msg: &msgs::RevokeAndACK, fee_estimator: &F) -> Result<(Option<msgs::CommitmentUpdate>, Vec<(PendingHTLCInfo, u64)>, Vec<(HTLCSource, PaymentHash, HTLCFailReason)>, Option<msgs::ClosingSigned>, ChannelMonitorUpdate), ChannelError>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if (self.channel_state & (ChannelState::ChannelFunded as u32)) != (ChannelState::ChannelFunded as u32) {
|
||||
return Err(ChannelError::Close("Got revoke/ACK message when channel was not in an operational state"));
|
||||
}
|
||||
|
|
@ -2463,7 +2469,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
(raa, commitment_update, order, forwards, failures, needs_broadcast_safe, funding_locked)
|
||||
}
|
||||
|
||||
pub fn update_fee(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::UpdateFee) -> Result<(), ChannelError> {
|
||||
pub fn update_fee<F: Deref>(&mut self, fee_estimator: &F, msg: &msgs::UpdateFee) -> Result<(), ChannelError>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if self.channel_outbound {
|
||||
return Err(ChannelError::Close("Non-funding remote tried to update channel fee"));
|
||||
}
|
||||
|
|
@ -2684,7 +2692,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
}
|
||||
}
|
||||
|
||||
fn maybe_propose_first_closing_signed(&mut self, fee_estimator: &FeeEstimator) -> Option<msgs::ClosingSigned> {
|
||||
fn maybe_propose_first_closing_signed<F: Deref>(&mut self, fee_estimator: &F) -> Option<msgs::ClosingSigned>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if !self.channel_outbound || !self.pending_inbound_htlcs.is_empty() || !self.pending_outbound_htlcs.is_empty() ||
|
||||
self.channel_state & (BOTH_SIDES_SHUTDOWN_MASK | ChannelState::AwaitingRemoteRevoke as u32) != BOTH_SIDES_SHUTDOWN_MASK ||
|
||||
self.last_sent_closing_fee.is_some() || self.pending_update_fee.is_some() {
|
||||
|
|
@ -2712,7 +2722,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
})
|
||||
}
|
||||
|
||||
pub fn shutdown(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::Shutdown) -> Result<(Option<msgs::Shutdown>, Option<msgs::ClosingSigned>, Vec<(HTLCSource, PaymentHash)>), ChannelError> {
|
||||
pub fn shutdown<F: Deref>(&mut self, fee_estimator: &F, msg: &msgs::Shutdown) -> Result<(Option<msgs::Shutdown>, Option<msgs::ClosingSigned>, Vec<(HTLCSource, PaymentHash)>), ChannelError>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if self.channel_state & (ChannelState::PeerDisconnected as u32) == ChannelState::PeerDisconnected as u32 {
|
||||
return Err(ChannelError::Close("Peer sent shutdown when we needed a channel_reestablish"));
|
||||
}
|
||||
|
|
@ -2808,7 +2820,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
tx.input[0].witness.push(self.get_funding_redeemscript().into_bytes());
|
||||
}
|
||||
|
||||
pub fn closing_signed(&mut self, fee_estimator: &FeeEstimator, msg: &msgs::ClosingSigned) -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError> {
|
||||
pub fn closing_signed<F: Deref>(&mut self, fee_estimator: &F, msg: &msgs::ClosingSigned) -> Result<(Option<msgs::ClosingSigned>, Option<Transaction>), ChannelError>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if self.channel_state & BOTH_SIDES_SHUTDOWN_MASK != BOTH_SIDES_SHUTDOWN_MASK {
|
||||
return Err(ChannelError::Close("Remote end sent us a closing_signed before both sides provided a shutdown"));
|
||||
}
|
||||
|
|
@ -3026,7 +3040,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
|
||||
/// Gets the fee we'd want to charge for adding an HTLC output to this Channel
|
||||
/// Allowed in any state (including after shutdown)
|
||||
pub fn get_our_fee_base_msat(&self, fee_estimator: &FeeEstimator) -> u32 {
|
||||
pub fn get_our_fee_base_msat<F: Deref>(&self, fee_estimator: &F) -> u32
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
// For lack of a better metric, we calculate what it would cost to consolidate the new HTLC
|
||||
// output value back into a transaction with the regular channel output:
|
||||
|
||||
|
|
@ -3230,7 +3246,9 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
|
|||
// Methods to get unprompted messages to send to the remote end (or where we already returned
|
||||
// something in the handler for the message that prompted this message):
|
||||
|
||||
pub fn get_open_channel(&self, chain_hash: Sha256dHash, fee_estimator: &FeeEstimator) -> msgs::OpenChannel {
|
||||
pub fn get_open_channel<F: Deref>(&self, chain_hash: Sha256dHash, fee_estimator: &F) -> msgs::OpenChannel
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if !self.channel_outbound {
|
||||
panic!("Tried to open a channel for an inbound channel?");
|
||||
}
|
||||
|
|
@ -4338,12 +4356,12 @@ mod tests {
|
|||
|
||||
assert_eq!(PublicKey::from_secret_key(&secp_ctx, chan_keys.funding_key()).serialize()[..],
|
||||
hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]);
|
||||
let keys_provider: Arc<KeysInterface<ChanKeySigner = InMemoryChannelKeys>> = Arc::new(Keys { chan_keys });
|
||||
let keys_provider = Keys { chan_keys };
|
||||
|
||||
let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
|
||||
let mut config = UserConfig::default();
|
||||
config.channel_options.announced_channel = false;
|
||||
let mut chan = Channel::<InMemoryChannelKeys>::new_outbound(&feeest, &keys_provider, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
|
||||
let mut chan = Channel::<InMemoryChannelKeys>::new_outbound(&&feeest, &&keys_provider, their_node_id, 10000000, 100000, 42, Arc::clone(&logger), &config).unwrap(); // Nothing uses their network key in this test
|
||||
chan.their_to_self_delay = 144;
|
||||
chan.our_dust_limit_satoshis = 546;
|
||||
|
||||
|
|
|
|||
|
|
@ -295,7 +295,7 @@ const ERR: () = "You need at least 32 bit pointers (well, usize, but we'll assum
|
|||
/// issues such as overly long function definitions. Note that the ChannelManager can take any
|
||||
/// type that implements KeysInterface for its keys manager, but this type alias chooses the
|
||||
/// concrete type of the KeysManager.
|
||||
pub type SimpleArcChannelManager<M, T> = Arc<ChannelManager<InMemoryChannelKeys, Arc<M>, Arc<T>, Arc<KeysManager>>>;
|
||||
pub type SimpleArcChannelManager<M, T, F> = Arc<ChannelManager<InMemoryChannelKeys, Arc<M>, Arc<T>, Arc<KeysManager>, Arc<F>>>;
|
||||
|
||||
/// SimpleRefChannelManager is a type alias for a ChannelManager reference, and is the reference
|
||||
/// counterpart to the SimpleArcChannelManager type alias. Use this type by default when you don't
|
||||
|
|
@ -305,7 +305,7 @@ pub type SimpleArcChannelManager<M, T> = Arc<ChannelManager<InMemoryChannelKeys,
|
|||
/// helps with issues such as long function definitions. Note that the ChannelManager can take any
|
||||
/// type that implements KeysInterface for its keys manager, but this type alias chooses the
|
||||
/// concrete type of the KeysManager.
|
||||
pub type SimpleRefChannelManager<'a, 'b, 'c, M, T> = ChannelManager<InMemoryChannelKeys, &'a M, &'b T, &'c KeysManager>;
|
||||
pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, M, T, F> = ChannelManager<InMemoryChannelKeys, &'a M, &'b T, &'c KeysManager, &'d F>;
|
||||
|
||||
/// Manager which keeps track of a number of channels and sends messages to the appropriate
|
||||
/// channel, also tracking HTLC preimages and forwarding onion packets appropriately.
|
||||
|
|
@ -343,14 +343,15 @@ pub type SimpleRefChannelManager<'a, 'b, 'c, M, T> = ChannelManager<InMemoryChan
|
|||
/// essentially you should default to using a SimpleRefChannelManager, and use a
|
||||
/// SimpleArcChannelManager when you require a ChannelManager with a static lifetime, such as when
|
||||
/// you're using lightning-net-tokio.
|
||||
pub struct ChannelManager<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref>
|
||||
pub struct ChannelManager<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
default_configuration: UserConfig,
|
||||
genesis_hash: Sha256dHash,
|
||||
fee_estimator: Arc<FeeEstimator>,
|
||||
fee_estimator: F,
|
||||
monitor: M,
|
||||
tx_broadcaster: T,
|
||||
|
||||
|
|
@ -617,10 +618,11 @@ macro_rules! maybe_break_monitor_err {
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref> ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
/// Constructs a new ChannelManager to hold several channels and route between them.
|
||||
///
|
||||
|
|
@ -640,13 +642,13 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
/// the ChannelManager as a listener to the BlockNotifier and call the BlockNotifier's
|
||||
/// `block_(dis)connected` methods, which will notify all registered listeners in one
|
||||
/// go.
|
||||
pub fn new(network: Network, feeest: Arc<FeeEstimator>, monitor: M, tx_broadcaster: T, logger: Arc<Logger>, keys_manager: K, config: UserConfig, current_blockchain_height: usize) -> Result<ChannelManager<ChanSigner, M, T, K>, secp256k1::Error> {
|
||||
pub fn new(network: Network, fee_est: F, monitor: M, tx_broadcaster: T, logger: Arc<Logger>, keys_manager: K, config: UserConfig, current_blockchain_height: usize) -> Result<ChannelManager<ChanSigner, M, T, K, F>, secp256k1::Error> {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
|
||||
let res = ChannelManager {
|
||||
default_configuration: config.clone(),
|
||||
genesis_hash: genesis_block(network).header.bitcoin_hash(),
|
||||
fee_estimator: feeest.clone(),
|
||||
fee_estimator: fee_est,
|
||||
monitor,
|
||||
tx_broadcaster,
|
||||
|
||||
|
|
@ -693,8 +695,8 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
return Err(APIError::APIMisuseError { err: "channel_value must be at least 1000 satoshis" });
|
||||
}
|
||||
|
||||
let channel = Channel::new_outbound(&*self.fee_estimator, &self.keys_manager, their_network_key, channel_value_satoshis, push_msat, user_id, Arc::clone(&self.logger), &self.default_configuration)?;
|
||||
let res = channel.get_open_channel(self.genesis_hash.clone(), &*self.fee_estimator);
|
||||
let channel = Channel::new_outbound(&self.fee_estimator, &self.keys_manager, their_network_key, channel_value_satoshis, push_msat, user_id, Arc::clone(&self.logger), &self.default_configuration)?;
|
||||
let res = channel.get_open_channel(self.genesis_hash.clone(), &self.fee_estimator);
|
||||
|
||||
let _ = self.total_consistency_lock.read().unwrap();
|
||||
let mut channel_state = self.channel_state.lock().unwrap();
|
||||
|
|
@ -715,7 +717,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
Ok(())
|
||||
}
|
||||
|
||||
fn list_channels_with_filter<F: FnMut(&(&[u8; 32], &Channel<ChanSigner>)) -> bool>(&self, f: F) -> Vec<ChannelDetails> {
|
||||
fn list_channels_with_filter<Fn: FnMut(&(&[u8; 32], &Channel<ChanSigner>)) -> bool>(&self, f: Fn) -> Vec<ChannelDetails> {
|
||||
let mut res = Vec::new();
|
||||
{
|
||||
let channel_state = self.channel_state.lock().unwrap();
|
||||
|
|
@ -1063,7 +1065,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
if *amt_to_forward < chan.get_their_htlc_minimum_msat() { // amount_below_minimum
|
||||
break Some(("HTLC amount was below the htlc_minimum_msat", 0x1000 | 11, Some(self.get_channel_update(chan).unwrap())));
|
||||
}
|
||||
let fee = amt_to_forward.checked_mul(chan.get_fee_proportional_millionths() as u64).and_then(|prop_fee| { (prop_fee / 1000000).checked_add(chan.get_our_fee_base_msat(&*self.fee_estimator) as u64) });
|
||||
let fee = amt_to_forward.checked_mul(chan.get_fee_proportional_millionths() as u64).and_then(|prop_fee| { (prop_fee / 1000000).checked_add(chan.get_our_fee_base_msat(&self.fee_estimator) as u64) });
|
||||
if fee.is_none() || msg.amount_msat < fee.unwrap() || (msg.amount_msat - fee.unwrap()) < *amt_to_forward { // fee_insufficient
|
||||
break Some(("Prior hop has deviated from specified fees parameters or origin node has obsolete ones", 0x1000 | 12, Some(self.get_channel_update(chan).unwrap())));
|
||||
}
|
||||
|
|
@ -1119,7 +1121,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
flags: (!were_node_one) as u16 | ((!chan.is_live() as u16) << 1),
|
||||
cltv_expiry_delta: CLTV_EXPIRY_DELTA,
|
||||
htlc_minimum_msat: chan.get_our_htlc_minimum_msat(),
|
||||
fee_base_msat: chan.get_our_fee_base_msat(&*self.fee_estimator),
|
||||
fee_base_msat: chan.get_our_fee_base_msat(&self.fee_estimator),
|
||||
fee_proportional_millionths: chan.get_fee_proportional_millionths(),
|
||||
excess_data: Vec::new(),
|
||||
};
|
||||
|
|
@ -1896,7 +1898,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
return Err(MsgHandleErrInternal::send_err_msg_no_close("Unknown genesis block hash", msg.temporary_channel_id.clone()));
|
||||
}
|
||||
|
||||
let channel = Channel::new_from_req(&*self.fee_estimator, &self.keys_manager, their_node_id.clone(), their_features, msg, 0, Arc::clone(&self.logger), &self.default_configuration)
|
||||
let channel = Channel::new_from_req(&self.fee_estimator, &self.keys_manager, their_node_id.clone(), their_features, msg, 0, Arc::clone(&self.logger), &self.default_configuration)
|
||||
.map_err(|e| MsgHandleErrInternal::from_chan_no_close(e, msg.temporary_channel_id))?;
|
||||
let mut channel_state_lock = self.channel_state.lock().unwrap();
|
||||
let channel_state = &mut *channel_state_lock;
|
||||
|
|
@ -2065,7 +2067,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
if chan_entry.get().get_their_node_id() != *their_node_id {
|
||||
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
|
||||
}
|
||||
let (shutdown, closing_signed, dropped_htlcs) = try_chan_entry!(self, chan_entry.get_mut().shutdown(&*self.fee_estimator, &msg), channel_state, chan_entry);
|
||||
let (shutdown, closing_signed, dropped_htlcs) = try_chan_entry!(self, chan_entry.get_mut().shutdown(&self.fee_estimator, &msg), channel_state, chan_entry);
|
||||
if let Some(msg) = shutdown {
|
||||
channel_state.pending_msg_events.push(events::MessageSendEvent::SendShutdown {
|
||||
node_id: their_node_id.clone(),
|
||||
|
|
@ -2111,7 +2113,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
if chan_entry.get().get_their_node_id() != *their_node_id {
|
||||
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
|
||||
}
|
||||
let (closing_signed, tx) = try_chan_entry!(self, chan_entry.get_mut().closing_signed(&*self.fee_estimator, &msg), channel_state, chan_entry);
|
||||
let (closing_signed, tx) = try_chan_entry!(self, chan_entry.get_mut().closing_signed(&self.fee_estimator, &msg), channel_state, chan_entry);
|
||||
if let Some(msg) = closing_signed {
|
||||
channel_state.pending_msg_events.push(events::MessageSendEvent::SendClosingSigned {
|
||||
node_id: their_node_id.clone(),
|
||||
|
|
@ -2266,7 +2268,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
|
||||
}
|
||||
let (revoke_and_ack, commitment_signed, closing_signed, monitor_update) =
|
||||
match chan.get_mut().commitment_signed(&msg, &*self.fee_estimator) {
|
||||
match chan.get_mut().commitment_signed(&msg, &self.fee_estimator) {
|
||||
Err((None, e)) => try_chan_entry!(self, Err(e), channel_state, chan),
|
||||
Err((Some(update), e)) => {
|
||||
assert!(chan.get().is_awaiting_monitor_update());
|
||||
|
|
@ -2352,7 +2354,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
}
|
||||
let was_frozen_for_monitor = chan.get().is_awaiting_monitor_update();
|
||||
let (commitment_update, pending_forwards, pending_failures, closing_signed, monitor_update) =
|
||||
try_chan_entry!(self, chan.get_mut().revoke_and_ack(&msg, &*self.fee_estimator), channel_state, chan);
|
||||
try_chan_entry!(self, chan.get_mut().revoke_and_ack(&msg, &self.fee_estimator), channel_state, chan);
|
||||
if let Err(e) = self.monitor.update_monitor(chan.get().get_funding_txo().unwrap(), monitor_update) {
|
||||
if was_frozen_for_monitor {
|
||||
assert!(commitment_update.is_none() && closing_signed.is_none() && pending_forwards.is_empty() && pending_failures.is_empty());
|
||||
|
|
@ -2394,7 +2396,7 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
if chan.get().get_their_node_id() != *their_node_id {
|
||||
return Err(MsgHandleErrInternal::send_err_msg_no_close("Got a message for a channel from the wrong node!", msg.channel_id));
|
||||
}
|
||||
try_chan_entry!(self, chan.get_mut().update_fee(&*self.fee_estimator, &msg), channel_state, chan);
|
||||
try_chan_entry!(self, chan.get_mut().update_fee(&self.fee_estimator, &msg), channel_state, chan);
|
||||
},
|
||||
hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close("Failed to find corresponding channel", msg.channel_id))
|
||||
}
|
||||
|
|
@ -2569,10 +2571,11 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> ChannelManager<ChanS
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> events::MessageSendEventsProvider for ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref> events::MessageSendEventsProvider for ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn get_and_clear_pending_msg_events(&self) -> Vec<events::MessageSendEvent> {
|
||||
// TODO: Event release to users and serialization is currently race-y: it's very easy for a
|
||||
|
|
@ -2598,10 +2601,11 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> events::MessageSendE
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> events::EventsProvider for ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref> events::EventsProvider for ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn get_and_clear_pending_events(&self) -> Vec<events::Event> {
|
||||
// TODO: Event release to users and serialization is currently race-y: it's very easy for a
|
||||
|
|
@ -2627,11 +2631,12 @@ impl<ChanSigner: ChannelKeys, M: Deref, T: Deref, K: Deref> events::EventsProvid
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K: Deref + Sync + Send>
|
||||
ChainListener for ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K: Deref + Sync + Send, F: Deref + Sync + Send>
|
||||
ChainListener for ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]) {
|
||||
let header_hash = header.bitcoin_hash();
|
||||
|
|
@ -2749,11 +2754,12 @@ impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K:
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K: Deref + Sync + Send>
|
||||
ChannelMessageHandler for ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send, T: Deref + Sync + Send, K: Deref + Sync + Send, F: Deref + Sync + Send>
|
||||
ChannelMessageHandler for ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn handle_open_channel(&self, their_node_id: &PublicKey, their_features: InitFeatures, msg: &msgs::OpenChannel) {
|
||||
let _ = self.total_consistency_lock.read().unwrap();
|
||||
|
|
@ -3224,10 +3230,11 @@ impl<R: ::std::io::Read> Readable<R> for HTLCForwardInfo {
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys + Writeable, M: Deref, T: Deref, K: Deref> Writeable for ChannelManager<ChanSigner, M, T, K>
|
||||
impl<ChanSigner: ChannelKeys + Writeable, M: Deref, T: Deref, K: Deref, F: Deref> Writeable for ChannelManager<ChanSigner, M, T, K, F>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
|
||||
let _ = self.total_consistency_lock.write().unwrap();
|
||||
|
|
@ -3299,10 +3306,11 @@ impl<ChanSigner: ChannelKeys + Writeable, M: Deref, T: Deref, K: Deref> Writeabl
|
|||
/// 5) Move the ChannelMonitors into your local ManyChannelMonitor.
|
||||
/// 6) Disconnect/connect blocks on the ChannelManager.
|
||||
/// 7) Register the new ChannelManager with your ChainWatchInterface.
|
||||
pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T: Deref, K: Deref>
|
||||
pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T: Deref, K: Deref, F: Deref>
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
|
||||
/// The keys provider which will give us relevant keys. Some keys will be loaded during
|
||||
|
|
@ -3312,7 +3320,7 @@ pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T:
|
|||
/// The fee_estimator for use in the ChannelManager in the future.
|
||||
///
|
||||
/// No calls to the FeeEstimator will be made during deserialization.
|
||||
pub fee_estimator: Arc<FeeEstimator>,
|
||||
pub fee_estimator: F,
|
||||
/// The ManyChannelMonitor for use in the ChannelManager in the future.
|
||||
///
|
||||
/// No calls to the ManyChannelMonitor will be made during deserialization. It is assumed that
|
||||
|
|
@ -3344,13 +3352,14 @@ pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T:
|
|||
pub channel_monitors: &'a mut HashMap<OutPoint, &'a mut ChannelMonitor<ChanSigner>>,
|
||||
}
|
||||
|
||||
impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref>
|
||||
ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K>)
|
||||
impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref, F: Deref>
|
||||
ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
|
||||
where M::Target: ManyChannelMonitor<ChanSigner>,
|
||||
T::Target: BroadcasterInterface,
|
||||
K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
|
||||
F::Target: FeeEstimator,
|
||||
{
|
||||
fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K>) -> Result<Self, DecodeError> {
|
||||
fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
|
||||
let _ver: u8 = Readable::read(reader)?;
|
||||
let min_ver: u8 = Readable::read(reader)?;
|
||||
if min_ver > SERIALIZATION_VERSION {
|
||||
|
|
|
|||
|
|
@ -212,7 +212,10 @@ pub trait ManyChannelMonitor<ChanSigner: ChannelKeys>: Send + Sync {
|
|||
///
|
||||
/// If you're using this for local monitoring of your own channels, you probably want to use
|
||||
/// `OutPoint` as the key, which will give you a ManyChannelMonitor implementation.
|
||||
pub struct SimpleManyChannelMonitor<Key, ChanSigner: ChannelKeys, T: Deref> where T::Target: BroadcasterInterface {
|
||||
pub struct SimpleManyChannelMonitor<Key, ChanSigner: ChannelKeys, T: Deref, F: Deref>
|
||||
where T::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
#[cfg(test)] // Used in ChannelManager tests to manipulate channels directly
|
||||
pub monitors: Mutex<HashMap<Key, ChannelMonitor<ChanSigner>>>,
|
||||
#[cfg(not(test))]
|
||||
|
|
@ -221,11 +224,13 @@ pub struct SimpleManyChannelMonitor<Key, ChanSigner: ChannelKeys, T: Deref> wher
|
|||
broadcaster: T,
|
||||
pending_events: Mutex<Vec<events::Event>>,
|
||||
logger: Arc<Logger>,
|
||||
fee_estimator: Arc<FeeEstimator>
|
||||
fee_estimator: F
|
||||
}
|
||||
|
||||
impl<'a, Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref + Sync + Send> ChainListener for SimpleManyChannelMonitor<Key, ChanSigner, T>
|
||||
where T::Target: BroadcasterInterface
|
||||
impl<'a, Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref + Sync + Send, F: Deref + Sync + Send>
|
||||
ChainListener for SimpleManyChannelMonitor<Key, ChanSigner, T, F>
|
||||
where T::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[u32]) {
|
||||
let block_hash = header.bitcoin_hash();
|
||||
|
|
@ -260,12 +265,13 @@ impl<'a, Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref +
|
|||
}
|
||||
}
|
||||
|
||||
impl<Key : Send + cmp::Eq + hash::Hash + 'static, ChanSigner: ChannelKeys, T: Deref> SimpleManyChannelMonitor<Key, ChanSigner, T>
|
||||
where T::Target: BroadcasterInterface
|
||||
impl<Key : Send + cmp::Eq + hash::Hash + 'static, ChanSigner: ChannelKeys, T: Deref, F: Deref> SimpleManyChannelMonitor<Key, ChanSigner, T, F>
|
||||
where T::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
/// Creates a new object which can be used to monitor several channels given the chain
|
||||
/// interface with which to register to receive notifications.
|
||||
pub fn new(chain_monitor: Arc<ChainWatchInterface>, broadcaster: T, logger: Arc<Logger>, feeest: Arc<FeeEstimator>) -> SimpleManyChannelMonitor<Key, ChanSigner, T> {
|
||||
pub fn new(chain_monitor: Arc<ChainWatchInterface>, broadcaster: T, logger: Arc<Logger>, feeest: F) -> SimpleManyChannelMonitor<Key, ChanSigner, T, F> {
|
||||
let res = SimpleManyChannelMonitor {
|
||||
monitors: Mutex::new(HashMap::new()),
|
||||
chain_monitor,
|
||||
|
|
@ -324,8 +330,9 @@ impl<Key : Send + cmp::Eq + hash::Hash + 'static, ChanSigner: ChannelKeys, T: De
|
|||
}
|
||||
}
|
||||
|
||||
impl<ChanSigner: ChannelKeys, T: Deref + Sync + Send> ManyChannelMonitor<ChanSigner> for SimpleManyChannelMonitor<OutPoint, ChanSigner, T>
|
||||
where T::Target: BroadcasterInterface
|
||||
impl<ChanSigner: ChannelKeys, T: Deref + Sync + Send, F: Deref + Sync + Send> ManyChannelMonitor<ChanSigner> for SimpleManyChannelMonitor<OutPoint, ChanSigner, T, F>
|
||||
where T::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
fn add_monitor(&self, funding_txo: OutPoint, monitor: ChannelMonitor<ChanSigner>) -> Result<(), ChannelMonitorUpdateErr> {
|
||||
match self.add_monitor_by_key(funding_txo, monitor) {
|
||||
|
|
@ -350,8 +357,9 @@ impl<ChanSigner: ChannelKeys, T: Deref + Sync + Send> ManyChannelMonitor<ChanSig
|
|||
}
|
||||
}
|
||||
|
||||
impl<Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref> events::EventsProvider for SimpleManyChannelMonitor<Key, ChanSigner, T>
|
||||
where T::Target: BroadcasterInterface
|
||||
impl<Key : Send + cmp::Eq + hash::Hash, ChanSigner: ChannelKeys, T: Deref, F: Deref> events::EventsProvider for SimpleManyChannelMonitor<Key, ChanSigner, T, F>
|
||||
where T::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
fn get_and_clear_pending_events(&self) -> Vec<events::Event> {
|
||||
let mut pending_events = self.pending_events.lock().unwrap();
|
||||
|
|
@ -1577,7 +1585,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
/// HTLC-Success/HTLC-Timeout transactions.
|
||||
/// Return updates for HTLC pending in the channel and failed automatically by the broadcast of
|
||||
/// revoked remote commitment tx
|
||||
fn check_spend_remote_transaction(&mut self, tx: &Transaction, height: u32, fee_estimator: &FeeEstimator) -> (Vec<Transaction>, (Sha256dHash, Vec<TxOut>), Vec<SpendableOutputDescriptor>) {
|
||||
fn check_spend_remote_transaction<F: Deref>(&mut self, tx: &Transaction, height: u32, fee_estimator: F) -> (Vec<Transaction>, (Sha256dHash, Vec<TxOut>), Vec<SpendableOutputDescriptor>)
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
// Most secp and related errors trying to create keys means we have no hope of constructing
|
||||
// a spend transaction...so we return no transactions to broadcast
|
||||
let mut txn_to_broadcast = Vec::new();
|
||||
|
|
@ -2152,7 +2162,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
}
|
||||
|
||||
/// Attempts to claim a remote HTLC-Success/HTLC-Timeout's outputs using the revocation key
|
||||
fn check_spend_remote_htlc(&mut self, tx: &Transaction, commitment_number: u64, height: u32, fee_estimator: &FeeEstimator) -> (Option<Transaction>, Option<SpendableOutputDescriptor>) {
|
||||
fn check_spend_remote_htlc<F: Deref>(&mut self, tx: &Transaction, commitment_number: u64, height: u32, fee_estimator: F) -> (Option<Transaction>, Option<SpendableOutputDescriptor>)
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
//TODO: send back new outputs to guarantee pending_claim_request consistency
|
||||
if tx.input.len() != 1 || tx.output.len() != 1 {
|
||||
return (None, None)
|
||||
|
|
@ -2522,8 +2534,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
/// Eventually this should be pub and, roughly, implement ChainListener, however this requires
|
||||
/// &mut self, as well as returns new spendable outputs and outpoints to watch for spending of
|
||||
/// on-chain.
|
||||
fn block_connected<B: Deref>(&mut self, txn_matched: &[&Transaction], height: u32, block_hash: &Sha256dHash, broadcaster: B, fee_estimator: &FeeEstimator)-> (Vec<(Sha256dHash, Vec<TxOut>)>, Vec<SpendableOutputDescriptor>)
|
||||
where B::Target: BroadcasterInterface
|
||||
fn block_connected<B: Deref, F: Deref>(&mut self, txn_matched: &[&Transaction], height: u32, block_hash: &Sha256dHash, broadcaster: B, fee_estimator: F)-> (Vec<(Sha256dHash, Vec<TxOut>)>, Vec<SpendableOutputDescriptor>)
|
||||
where B::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
for tx in txn_matched {
|
||||
let mut output_val = 0;
|
||||
|
|
@ -2556,7 +2569,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
};
|
||||
if funding_txo.is_none() || (prevout.txid == funding_txo.as_ref().unwrap().0.txid && prevout.vout == funding_txo.as_ref().unwrap().0.index as u32) {
|
||||
if (tx.input[0].sequence >> 8*3) as u8 == 0x80 && (tx.lock_time >> 8*3) as u8 == 0x20 {
|
||||
let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(&tx, height, fee_estimator);
|
||||
let (remote_txn, new_outputs, mut spendable_output) = self.check_spend_remote_transaction(&tx, height, &*fee_estimator);
|
||||
txn = remote_txn;
|
||||
spendable_outputs.append(&mut spendable_output);
|
||||
if !new_outputs.1.is_empty() {
|
||||
|
|
@ -2578,7 +2591,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
}
|
||||
} else {
|
||||
if let Some(&(commitment_number, _)) = self.remote_commitment_txn_on_chain.get(&prevout.txid) {
|
||||
let (tx, spendable_output) = self.check_spend_remote_htlc(&tx, commitment_number, height, fee_estimator);
|
||||
let (tx, spendable_output) = self.check_spend_remote_htlc(&tx, commitment_number, height, &*fee_estimator);
|
||||
if let Some(tx) = tx {
|
||||
txn.push(tx);
|
||||
}
|
||||
|
|
@ -2738,7 +2751,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
for first_claim_txid in bump_candidates.iter() {
|
||||
if let Some((new_timer, new_feerate)) = {
|
||||
if let Some(claim_material) = self.pending_claim_requests.get(first_claim_txid) {
|
||||
if let Some((new_timer, new_feerate, bump_tx)) = self.bump_claim_tx(height, &claim_material, fee_estimator) {
|
||||
if let Some((new_timer, new_feerate, bump_tx)) = self.bump_claim_tx(height, &claim_material, &*fee_estimator) {
|
||||
broadcaster.broadcast_transaction(&bump_tx);
|
||||
Some((new_timer, new_feerate))
|
||||
} else { None }
|
||||
|
|
@ -2757,8 +2770,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
(watch_outputs, spendable_outputs)
|
||||
}
|
||||
|
||||
fn block_disconnected<B: Deref>(&mut self, height: u32, block_hash: &Sha256dHash, broadcaster: B, fee_estimator: &FeeEstimator)
|
||||
where B::Target: BroadcasterInterface
|
||||
fn block_disconnected<B: Deref, F: Deref>(&mut self, height: u32, block_hash: &Sha256dHash, broadcaster: B, fee_estimator: F)
|
||||
where B::Target: BroadcasterInterface,
|
||||
F::Target: FeeEstimator
|
||||
{
|
||||
log_trace!(self, "Block {} at height {} disconnected", block_hash, height);
|
||||
let mut bump_candidates = HashMap::new();
|
||||
|
|
@ -2784,7 +2798,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
}
|
||||
}
|
||||
for (_, claim_material) in bump_candidates.iter_mut() {
|
||||
if let Some((new_timer, new_feerate, bump_tx)) = self.bump_claim_tx(height, &claim_material, fee_estimator) {
|
||||
if let Some((new_timer, new_feerate, bump_tx)) = self.bump_claim_tx(height, &claim_material, &*fee_estimator) {
|
||||
claim_material.height_timer = new_timer;
|
||||
claim_material.feerate_previous = new_feerate;
|
||||
broadcaster.broadcast_transaction(&bump_tx);
|
||||
|
|
@ -3014,7 +3028,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
|
|||
|
||||
/// Lightning security model (i.e being able to redeem/timeout HTLC or penalize coutnerparty onchain) lays on the assumption of claim transactions getting confirmed before timelock expiration
|
||||
/// (CSV or CLTV following cases). In case of high-fee spikes, claim tx may stuck in the mempool, so you need to bump its feerate quickly using Replace-By-Fee or Child-Pay-For-Parent.
|
||||
fn bump_claim_tx(&self, height: u32, cached_claim_datas: &ClaimTxBumpMaterial, fee_estimator: &FeeEstimator) -> Option<(u32, u64, Transaction)> {
|
||||
fn bump_claim_tx<F: Deref>(&self, height: u32, cached_claim_datas: &ClaimTxBumpMaterial, fee_estimator: F) -> Option<(u32, u64, Transaction)>
|
||||
where F::Target: FeeEstimator
|
||||
{
|
||||
if cached_claim_datas.per_input_material.len() == 0 { return None } // But don't prune pending claiming request yet, we may have to resurrect HTLCs
|
||||
let mut inputs = Vec::new();
|
||||
for outp in cached_claim_datas.per_input_material.keys() {
|
||||
|
|
|
|||
|
|
@ -62,12 +62,13 @@ pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b>
|
|||
|
||||
pub struct TestChanMonCfg {
|
||||
pub tx_broadcaster: test_utils::TestBroadcaster,
|
||||
pub fee_estimator: test_utils::TestFeeEstimator,
|
||||
}
|
||||
|
||||
pub struct NodeCfg<'a> {
|
||||
pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
|
||||
pub tx_broadcaster: &'a test_utils::TestBroadcaster,
|
||||
pub fee_estimator: Arc<test_utils::TestFeeEstimator>,
|
||||
pub fee_estimator: &'a test_utils::TestFeeEstimator,
|
||||
pub chan_monitor: test_utils::TestChannelMonitor<'a>,
|
||||
pub keys_manager: test_utils::TestKeysInterface,
|
||||
pub logger: Arc<test_utils::TestLogger>,
|
||||
|
|
@ -80,7 +81,7 @@ pub struct Node<'a, 'b: 'a, 'c: 'b> {
|
|||
pub tx_broadcaster: &'c test_utils::TestBroadcaster,
|
||||
pub chan_monitor: &'b test_utils::TestChannelMonitor<'c>,
|
||||
pub keys_manager: &'b test_utils::TestKeysInterface,
|
||||
pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface>,
|
||||
pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>,
|
||||
pub router: Router,
|
||||
pub node_seed: [u8; 32],
|
||||
pub network_payment_count: Rc<RefCell<u8>>,
|
||||
|
|
@ -99,7 +100,7 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
|
|||
// Check that if we serialize and then deserialize all our channel monitors we get the
|
||||
// same set of outputs to watch for on chain as we have now. Note that if we write
|
||||
// tests that fully close channels and remove the monitors at some point this may break.
|
||||
let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
|
||||
let feeest = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
let old_monitors = self.chan_monitor.simple_monitor.monitors.lock().unwrap();
|
||||
let mut deserialized_monitors = Vec::new();
|
||||
for (_, old_monitor) in old_monitors.iter() {
|
||||
|
|
@ -120,10 +121,10 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
|
|||
|
||||
let mut w = test_utils::TestVecWriter(Vec::new());
|
||||
self.node.write(&mut w).unwrap();
|
||||
<(Sha256d, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
|
||||
<(Sha256d, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(w.0), ChannelManagerReadArgs {
|
||||
default_config: UserConfig::default(),
|
||||
keys_manager: self.keys_manager,
|
||||
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
|
||||
fee_estimator: &test_utils::TestFeeEstimator { sat_per_kw: 253 },
|
||||
monitor: self.chan_monitor,
|
||||
tx_broadcaster: self.tx_broadcaster.clone(),
|
||||
logger: Arc::new(test_utils::TestLogger::new()),
|
||||
|
|
@ -132,7 +133,7 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
|
|||
}
|
||||
|
||||
let chain_watch = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&self.logger) as Arc<Logger>));
|
||||
let channel_monitor = test_utils::TestChannelMonitor::new(chain_watch.clone(), self.tx_broadcaster.clone(), self.logger.clone(), feeest);
|
||||
let channel_monitor = test_utils::TestChannelMonitor::new(chain_watch.clone(), self.tx_broadcaster.clone(), self.logger.clone(), &feeest);
|
||||
for deserialized_monitor in deserialized_monitors.drain(..) {
|
||||
if let Err(_) = channel_monitor.add_monitor(deserialized_monitor.get_funding_txo().unwrap(), deserialized_monitor) {
|
||||
panic!();
|
||||
|
|
@ -920,7 +921,8 @@ pub fn create_chanmon_cfgs(node_count: usize) -> Vec<TestChanMonCfg> {
|
|||
let mut chan_mon_cfgs = Vec::new();
|
||||
for _ in 0..node_count {
|
||||
let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), broadcasted_txn: Mutex::new(HashSet::new())};
|
||||
chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster });
|
||||
let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator });
|
||||
}
|
||||
|
||||
chan_mon_cfgs
|
||||
|
|
@ -932,32 +934,31 @@ pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec<TestChanMon
|
|||
|
||||
for i in 0..node_count {
|
||||
let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
|
||||
let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
|
||||
let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, logger.clone() as Arc<Logger>));
|
||||
let mut seed = [0; 32];
|
||||
rng.fill_bytes(&mut seed);
|
||||
let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet, logger.clone() as Arc<Logger>);
|
||||
let chan_monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), &chanmon_cfgs[i].tx_broadcaster, logger.clone(), fee_estimator.clone());
|
||||
nodes.push(NodeCfg { chain_monitor, logger, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, fee_estimator, chan_monitor, keys_manager, node_seed: seed });
|
||||
let chan_monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), &chanmon_cfgs[i].tx_broadcaster, logger.clone(), &chanmon_cfgs[i].fee_estimator);
|
||||
nodes.push(NodeCfg { chain_monitor, logger, tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, fee_estimator: &chanmon_cfgs[i].fee_estimator, chan_monitor, keys_manager, node_seed: seed });
|
||||
}
|
||||
|
||||
nodes
|
||||
}
|
||||
|
||||
pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<EnforcingChannelKeys, &'a TestChannelMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface>> {
|
||||
pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg<'b>>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<EnforcingChannelKeys, &'a TestChannelMonitor<'b>, &'b test_utils::TestBroadcaster, &'a test_utils::TestKeysInterface, &'b test_utils::TestFeeEstimator>> {
|
||||
let mut chanmgrs = Vec::new();
|
||||
for i in 0..node_count {
|
||||
let mut default_config = UserConfig::default();
|
||||
default_config.channel_options.announced_channel = true;
|
||||
default_config.peer_channel_config_limits.force_announced_channel_preference = false;
|
||||
let node = ChannelManager::new(Network::Testnet, cfgs[i].fee_estimator.clone(), &cfgs[i].chan_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger.clone(), &cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
|
||||
let node = ChannelManager::new(Network::Testnet, cfgs[i].fee_estimator, &cfgs[i].chan_monitor, cfgs[i].tx_broadcaster, cfgs[i].logger.clone(), &cfgs[i].keys_manager, if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
|
||||
chanmgrs.push(node);
|
||||
}
|
||||
|
||||
chanmgrs
|
||||
}
|
||||
|
||||
pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface>>) -> Vec<Node<'a, 'b, 'c>> {
|
||||
pub fn create_network<'a, 'b: 'a, 'c: 'b>(node_count: usize, cfgs: &'b Vec<NodeCfg<'c>>, chan_mgrs: &'a Vec<ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor<'c>, &'c test_utils::TestBroadcaster, &'b test_utils::TestKeysInterface, &'c test_utils::TestFeeEstimator>>) -> Vec<Node<'a, 'b, 'c>> {
|
||||
let secp_ctx = Secp256k1::new();
|
||||
let mut nodes = Vec::new();
|
||||
let chan_count = Rc::new(RefCell::new(0));
|
||||
|
|
|
|||
|
|
@ -3673,9 +3673,10 @@ fn test_no_txn_manager_serialize_deserialize() {
|
|||
let chanmon_cfgs = create_chanmon_cfgs(2);
|
||||
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
|
||||
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
|
||||
let fee_estimator: test_utils::TestFeeEstimator;
|
||||
let new_chan_monitor: test_utils::TestChannelMonitor;
|
||||
let keys_manager: test_utils::TestKeysInterface;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
|
||||
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
|
||||
|
||||
let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::supported(), InitFeatures::supported());
|
||||
|
|
@ -3686,7 +3687,8 @@ fn test_no_txn_manager_serialize_deserialize() {
|
|||
let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
|
||||
nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
|
||||
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }));
|
||||
fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), &fee_estimator);
|
||||
nodes[0].chan_monitor = &new_chan_monitor;
|
||||
let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
|
||||
let (_, mut chan_0_monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
|
||||
|
|
@ -3698,10 +3700,10 @@ fn test_no_txn_manager_serialize_deserialize() {
|
|||
let (_, nodes_0_deserialized_tmp) = {
|
||||
let mut channel_monitors = HashMap::new();
|
||||
channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &mut chan_0_monitor);
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
default_config: config,
|
||||
keys_manager: &keys_manager,
|
||||
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
|
||||
fee_estimator: &fee_estimator,
|
||||
monitor: nodes[0].chan_monitor,
|
||||
tx_broadcaster: nodes[0].tx_broadcaster.clone(),
|
||||
logger: Arc::new(test_utils::TestLogger::new()),
|
||||
|
|
@ -3743,9 +3745,10 @@ fn test_simple_manager_serialize_deserialize() {
|
|||
let chanmon_cfgs = create_chanmon_cfgs(2);
|
||||
let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
|
||||
let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
|
||||
let fee_estimator: test_utils::TestFeeEstimator;
|
||||
let new_chan_monitor: test_utils::TestChannelMonitor;
|
||||
let keys_manager: test_utils::TestKeysInterface;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
|
||||
let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
|
||||
create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
|
||||
|
||||
|
|
@ -3758,7 +3761,8 @@ fn test_simple_manager_serialize_deserialize() {
|
|||
let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
|
||||
nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
|
||||
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }));
|
||||
fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), &fee_estimator);
|
||||
nodes[0].chan_monitor = &new_chan_monitor;
|
||||
let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
|
||||
let (_, mut chan_0_monitor) = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
|
||||
|
|
@ -3769,10 +3773,10 @@ fn test_simple_manager_serialize_deserialize() {
|
|||
let (_, nodes_0_deserialized_tmp) = {
|
||||
let mut channel_monitors = HashMap::new();
|
||||
channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &mut chan_0_monitor);
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
default_config: UserConfig::default(),
|
||||
keys_manager: &keys_manager,
|
||||
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
|
||||
fee_estimator: &fee_estimator,
|
||||
monitor: nodes[0].chan_monitor,
|
||||
tx_broadcaster: nodes[0].tx_broadcaster.clone(),
|
||||
logger: Arc::new(test_utils::TestLogger::new()),
|
||||
|
|
@ -3798,9 +3802,10 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
let chanmon_cfgs = create_chanmon_cfgs(4);
|
||||
let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
|
||||
let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
|
||||
let fee_estimator: test_utils::TestFeeEstimator;
|
||||
let new_chan_monitor: test_utils::TestChannelMonitor;
|
||||
let keys_manager: test_utils::TestKeysInterface;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>;
|
||||
let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>;
|
||||
let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
|
||||
create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
|
||||
create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::supported(), InitFeatures::supported());
|
||||
|
|
@ -3825,7 +3830,8 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
node_0_monitors_serialized.push(writer.0);
|
||||
}
|
||||
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }));
|
||||
fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new()), &fee_estimator);
|
||||
nodes[0].chan_monitor = &new_chan_monitor;
|
||||
let mut node_0_monitors = Vec::new();
|
||||
for serialized in node_0_monitors_serialized.iter() {
|
||||
|
|
@ -3837,10 +3843,10 @@ fn test_manager_serialize_deserialize_inconsistent_monitor() {
|
|||
|
||||
let mut nodes_0_read = &nodes_0_serialized[..];
|
||||
keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new()));
|
||||
let (_, nodes_0_deserialized_tmp) = <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
let (_, nodes_0_deserialized_tmp) = <(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
|
||||
default_config: UserConfig::default(),
|
||||
keys_manager: &keys_manager,
|
||||
fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
|
||||
fee_estimator: &fee_estimator,
|
||||
monitor: nodes[0].chan_monitor,
|
||||
tx_broadcaster: nodes[0].tx_broadcaster.clone(),
|
||||
logger: Arc::new(test_utils::TestLogger::new()),
|
||||
|
|
@ -6487,7 +6493,7 @@ fn test_user_configurable_csv_delay() {
|
|||
|
||||
// We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_outbound()
|
||||
let keys_manager: Arc<KeysInterface<ChanKeySigner = EnforcingChannelKeys>> = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
|
||||
if let Err(error) = Channel::new_outbound(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), 1000000, 1000000, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
|
||||
if let Err(error) = Channel::new_outbound(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), 1000000, 1000000, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
|
||||
match error {
|
||||
APIError::APIMisuseError { err } => { assert_eq!(err, "Configured with an unreasonable our_to_self_delay putting user funds at risks"); },
|
||||
_ => panic!("Unexpected event"),
|
||||
|
|
@ -6498,7 +6504,7 @@ fn test_user_configurable_csv_delay() {
|
|||
nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42).unwrap();
|
||||
let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
|
||||
open_channel.to_self_delay = 200;
|
||||
if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
|
||||
if let Err(error) = Channel::new_from_req(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &low_our_to_self_config) {
|
||||
match error {
|
||||
ChannelError::Close(err) => { assert_eq!(err, "Configured with an unreasonable our_to_self_delay putting user funds at risks"); },
|
||||
_ => panic!("Unexpected event"),
|
||||
|
|
@ -6524,7 +6530,7 @@ fn test_user_configurable_csv_delay() {
|
|||
nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42).unwrap();
|
||||
let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
|
||||
open_channel.to_self_delay = 200;
|
||||
if let Err(error) = Channel::new_from_req(&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &high_their_to_self_config) {
|
||||
if let Err(error) = Channel::new_from_req(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::supported(), &open_channel, 0, Arc::new(test_utils::TestLogger::new()), &high_their_to_self_config) {
|
||||
match error {
|
||||
ChannelError::Close(err) => { assert_eq!(err, "They wanted our payments to be delayed by a needlessly long period"); },
|
||||
_ => panic!("Unexpected event"),
|
||||
|
|
@ -6539,6 +6545,7 @@ fn test_data_loss_protect() {
|
|||
// * we close channel in case of detecting other being fallen behind
|
||||
// * we are able to claim our own outputs thanks to remote my_current_per_commitment_point
|
||||
let keys_manager;
|
||||
let fee_estimator;
|
||||
let tx_broadcaster;
|
||||
let monitor;
|
||||
let node_state_0;
|
||||
|
|
@ -6565,15 +6572,15 @@ fn test_data_loss_protect() {
|
|||
let mut chan_monitor = <(Sha256dHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0), Arc::clone(&logger)).unwrap().1;
|
||||
let chain_monitor = Arc::new(ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
|
||||
tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), broadcasted_txn: Mutex::new(HashSet::new())};
|
||||
let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
|
||||
fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
|
||||
keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet, Arc::clone(&logger));
|
||||
monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), &tx_broadcaster, logger.clone(), feeest.clone());
|
||||
monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), &tx_broadcaster, logger.clone(), &fee_estimator);
|
||||
node_state_0 = {
|
||||
let mut channel_monitors = HashMap::new();
|
||||
channel_monitors.insert(OutPoint { txid: chan.3.txid(), index: 0 }, &mut chan_monitor);
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface>)>::read(&mut ::std::io::Cursor::new(previous_node_state), ChannelManagerReadArgs {
|
||||
<(Sha256dHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator>)>::read(&mut ::std::io::Cursor::new(previous_node_state), ChannelManagerReadArgs {
|
||||
keys_manager: &keys_manager,
|
||||
fee_estimator: feeest.clone(),
|
||||
fee_estimator: &fee_estimator,
|
||||
monitor: &monitor,
|
||||
logger: Arc::clone(&logger),
|
||||
tx_broadcaster: &tx_broadcaster,
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ fn _check_usize_is_32_or_64() {
|
|||
/// lifetimes). Other times you can afford a reference, which is more efficient, in which case
|
||||
/// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents
|
||||
/// issues such as overly long function definitions.
|
||||
pub type SimpleArcPeerManager<SD, M, T> = Arc<PeerManager<SD, SimpleArcChannelManager<M, T>>>;
|
||||
pub type SimpleArcPeerManager<SD, M, T, F> = Arc<PeerManager<SD, SimpleArcChannelManager<M, T, F>>>;
|
||||
|
||||
/// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference
|
||||
/// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't
|
||||
|
|
@ -170,7 +170,7 @@ pub type SimpleArcPeerManager<SD, M, T> = Arc<PeerManager<SD, SimpleArcChannelMa
|
|||
/// usage of lightning-net-tokio (since tokio::spawn requires parameters with static lifetimes).
|
||||
/// But if this is not necessary, using a reference is more efficient. Defining these type aliases
|
||||
/// helps with issues such as long function definitions.
|
||||
pub type SimpleRefPeerManager<'a, 'b, 'c, SD, M, T> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, M, T>>;
|
||||
pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, SD, M, T, F> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, M, T, F>>;
|
||||
|
||||
/// A PeerManager manages a set of peers, described by their SocketDescriptor and marshalls socket
|
||||
/// events into messages which it passes on to its MessageHandlers.
|
||||
|
|
|
|||
|
|
@ -47,11 +47,11 @@ impl chaininterface::FeeEstimator for TestFeeEstimator {
|
|||
pub struct TestChannelMonitor<'a> {
|
||||
pub added_monitors: Mutex<Vec<(OutPoint, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>>,
|
||||
pub latest_monitor_update_id: Mutex<HashMap<[u8; 32], (OutPoint, u64)>>,
|
||||
pub simple_monitor: channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, &'a chaininterface::BroadcasterInterface>,
|
||||
pub simple_monitor: channelmonitor::SimpleManyChannelMonitor<OutPoint, EnforcingChannelKeys, &'a chaininterface::BroadcasterInterface, &'a TestFeeEstimator>,
|
||||
pub update_ret: Mutex<Result<(), channelmonitor::ChannelMonitorUpdateErr>>,
|
||||
}
|
||||
impl<'a> TestChannelMonitor<'a> {
|
||||
pub fn new(chain_monitor: Arc<chaininterface::ChainWatchInterface>, broadcaster: &'a chaininterface::BroadcasterInterface, logger: Arc<Logger>, fee_estimator: Arc<chaininterface::FeeEstimator>) -> Self {
|
||||
pub fn new(chain_monitor: Arc<chaininterface::ChainWatchInterface>, broadcaster: &'a chaininterface::BroadcasterInterface, logger: Arc<Logger>, fee_estimator: &'a TestFeeEstimator) -> Self {
|
||||
Self {
|
||||
added_monitors: Mutex::new(Vec::new()),
|
||||
latest_monitor_update_id: Mutex::new(HashMap::new()),
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue