From c09d41c20ccef55d222af489af839ba5f7d49e45 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 9 Jun 2025 10:14:28 +0200 Subject: [PATCH 01/26] Separate sweeper persistent state Prepare for adding runtime state while avoiding the _unused serialization macro config. --- lightning/src/util/sweep.rs | 89 ++++++++++++++++++++++--------------- 1 file changed, 52 insertions(+), 37 deletions(-) diff --git a/lightning/src/util/sweep.rs b/lightning/src/util/sweep.rs index 0fae91bebc2..a80e6b524c1 100644 --- a/lightning/src/util/sweep.rs +++ b/lightning/src/util/sweep.rs @@ -382,7 +382,8 @@ where output_spender: O, change_destination_source: D, kv_store: K, logger: L, ) -> Self { let outputs = Vec::new(); - let sweeper_state = Mutex::new(SweeperState { outputs, best_block }); + let sweeper_state = + Mutex::new(SweeperState { persistent: PersistentSweeperState { outputs, best_block } }); Self { sweeper_state, pending_sweep: AtomicBool::new(false), @@ -437,27 +438,27 @@ where }, }; - if state_lock.outputs.iter().find(|o| o.descriptor == output_info.descriptor).is_some() - { + let mut outputs = state_lock.persistent.outputs.iter(); + if outputs.find(|o| o.descriptor == output_info.descriptor).is_some() { continue; } - state_lock.outputs.push(output_info); + state_lock.persistent.outputs.push(output_info); } - self.persist_state(&*state_lock).map_err(|e| { + self.persist_state(&state_lock.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }) } /// Returns a list of the currently tracked spendable outputs. pub fn tracked_spendable_outputs(&self) -> Vec { - self.sweeper_state.lock().unwrap().outputs.clone() + self.sweeper_state.lock().unwrap().persistent.outputs.clone() } /// Gets the latest best block which was connected either via the [`Listen`] or /// [`Confirm`] interfaces. pub fn current_best_block(&self) -> BestBlock { - self.sweeper_state.lock().unwrap().best_block + self.sweeper_state.lock().unwrap().persistent.best_block } /// Regenerates and broadcasts the spending transaction for any outputs that are pending. This method will be a @@ -505,8 +506,9 @@ where { let sweeper_state = self.sweeper_state.lock().unwrap(); - let cur_height = sweeper_state.best_block.height; - let has_respends = sweeper_state.outputs.iter().any(|o| filter_fn(o, cur_height)); + let cur_height = sweeper_state.persistent.best_block.height; + let has_respends = + sweeper_state.persistent.outputs.iter().any(|o| filter_fn(o, cur_height)); if !has_respends { return Ok(()); } @@ -520,10 +522,11 @@ where { let mut sweeper_state = self.sweeper_state.lock().unwrap(); - let cur_height = sweeper_state.best_block.height; - let cur_hash = sweeper_state.best_block.block_hash; + let cur_height = sweeper_state.persistent.best_block.height; + let cur_hash = sweeper_state.persistent.best_block.block_hash; let respend_descriptors: Vec<&SpendableOutputDescriptor> = sweeper_state + .persistent .outputs .iter() .filter(|o| filter_fn(*o, cur_height)) @@ -536,7 +539,11 @@ where } let spending_tx = self - .spend_outputs(&sweeper_state, &respend_descriptors, change_destination_script) + .spend_outputs( + &sweeper_state.persistent, + &respend_descriptors, + change_destination_script, + ) .map_err(|e| { log_error!(self.logger, "Error spending outputs: {:?}", e); })?; @@ -550,7 +557,7 @@ where // As we didn't modify the state so far, the same filter_fn yields the same elements as // above. let respend_outputs = - sweeper_state.outputs.iter_mut().filter(|o| filter_fn(&**o, cur_height)); + sweeper_state.persistent.outputs.iter_mut().filter(|o| filter_fn(&**o, cur_height)); for output_info in respend_outputs { if let Some(filter) = self.chain_data_source.as_ref() { let watched_output = output_info.to_watched_output(cur_hash); @@ -560,7 +567,7 @@ where output_info.status.broadcast(cur_hash, cur_height, spending_tx.clone()); } - self.persist_state(&sweeper_state).map_err(|e| { + self.persist_state(&sweeper_state.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); })?; @@ -571,10 +578,10 @@ where } fn prune_confirmed_outputs(&self, sweeper_state: &mut SweeperState) { - let cur_height = sweeper_state.best_block.height; + let cur_height = sweeper_state.persistent.best_block.height; // Prune all outputs that have sufficient depth by now. - sweeper_state.outputs.retain(|o| { + sweeper_state.persistent.outputs.retain(|o| { if let Some(confirmation_height) = o.status.confirmation_height() { // We wait at least `PRUNE_DELAY_BLOCKS` as before that // `Event::SpendableOutputs` from lingering monitors might get replayed. @@ -590,7 +597,7 @@ where }); } - fn persist_state(&self, sweeper_state: &SweeperState) -> Result<(), io::Error> { + fn persist_state(&self, sweeper_state: &PersistentSweeperState) -> Result<(), io::Error> { self.kv_store .write( OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, @@ -612,7 +619,7 @@ where } fn spend_outputs( - &self, sweeper_state: &SweeperState, descriptors: &[&SpendableOutputDescriptor], + &self, sweeper_state: &PersistentSweeperState, descriptors: &[&SpendableOutputDescriptor], change_destination_script: ScriptBuf, ) -> Result { let tx_feerate = @@ -635,7 +642,7 @@ where ) { let confirmation_hash = header.block_hash(); for (_, tx) in txdata { - for output_info in sweeper_state.outputs.iter_mut() { + for output_info in sweeper_state.persistent.outputs.iter_mut() { if output_info.is_spent_in(*tx) { output_info.status.confirmed(confirmation_hash, height, (*tx).clone()) } @@ -646,7 +653,7 @@ where fn best_block_updated_internal( &self, sweeper_state: &mut SweeperState, header: &Header, height: u32, ) { - sweeper_state.best_block = BestBlock::new(header.block_hash(), height); + sweeper_state.persistent.best_block = BestBlock::new(header.block_hash(), height); self.prune_confirmed_outputs(sweeper_state); } } @@ -666,15 +673,15 @@ where &self, header: &Header, txdata: &chain::transaction::TransactionData, height: u32, ) { let mut state_lock = self.sweeper_state.lock().unwrap(); - assert_eq!(state_lock.best_block.block_hash, header.prev_blockhash, + assert_eq!(state_lock.persistent.best_block.block_hash, header.prev_blockhash, "Blocks must be connected in chain-order - the connected header must build on the last connected header"); - assert_eq!(state_lock.best_block.height, height - 1, + assert_eq!(state_lock.persistent.best_block.height, height - 1, "Blocks must be connected in chain-order - the connected block height must be one greater than the previous height"); self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height); self.best_block_updated_internal(&mut *state_lock, header, height); - let _ = self.persist_state(&*state_lock).map_err(|e| { + let _ = self.persist_state(&state_lock.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }); } @@ -685,20 +692,20 @@ where let new_height = height - 1; let block_hash = header.block_hash(); - assert_eq!(state_lock.best_block.block_hash, block_hash, + assert_eq!(state_lock.persistent.best_block.block_hash, block_hash, "Blocks must be disconnected in chain-order - the disconnected header must be the last connected header"); - assert_eq!(state_lock.best_block.height, height, + assert_eq!(state_lock.persistent.best_block.height, height, "Blocks must be disconnected in chain-order - the disconnected block must have the correct height"); - state_lock.best_block = BestBlock::new(header.prev_blockhash, new_height); + state_lock.persistent.best_block = BestBlock::new(header.prev_blockhash, new_height); - for output_info in state_lock.outputs.iter_mut() { + for output_info in state_lock.persistent.outputs.iter_mut() { if output_info.status.confirmation_hash() == Some(block_hash) { debug_assert_eq!(output_info.status.confirmation_height(), Some(height)); output_info.status.unconfirmed(); } } - self.persist_state(&*state_lock).unwrap_or_else(|e| { + self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }); } @@ -720,7 +727,7 @@ where ) { let mut state_lock = self.sweeper_state.lock().unwrap(); self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height); - self.persist_state(&*state_lock).unwrap_or_else(|e| { + self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }); } @@ -730,6 +737,7 @@ where // Get what height was unconfirmed. let unconf_height = state_lock + .persistent .outputs .iter() .find(|o| o.status.latest_spending_tx().map(|tx| tx.compute_txid()) == Some(*txid)) @@ -738,12 +746,13 @@ where if let Some(unconf_height) = unconf_height { // Unconfirm all >= this height. state_lock + .persistent .outputs .iter_mut() .filter(|o| o.status.confirmation_height() >= Some(unconf_height)) .for_each(|o| o.status.unconfirmed()); - self.persist_state(&*state_lock).unwrap_or_else(|e| { + self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }); } @@ -752,7 +761,7 @@ where fn best_block_updated(&self, header: &Header, height: u32) { let mut state_lock = self.sweeper_state.lock().unwrap(); self.best_block_updated_internal(&mut *state_lock, header, height); - let _ = self.persist_state(&*state_lock).map_err(|e| { + let _ = self.persist_state(&state_lock.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); }); } @@ -760,6 +769,7 @@ where fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option)> { let state_lock = self.sweeper_state.lock().unwrap(); state_lock + .persistent .outputs .iter() .filter_map(|o| match o.status { @@ -779,13 +789,18 @@ where } } -#[derive(Debug, Clone)] +#[derive(Debug)] struct SweeperState { + persistent: PersistentSweeperState, +} + +#[derive(Debug, Clone)] +struct PersistentSweeperState { outputs: Vec, best_block: BestBlock, } -impl_writeable_tlv_based!(SweeperState, { +impl_writeable_tlv_based!(PersistentSweeperState, { (0, outputs, required_vec), (2, best_block, required), }); @@ -831,7 +846,7 @@ where kv_store, logger, ) = args; - let state = SweeperState::read(reader)?; + let state = PersistentSweeperState::read(reader)?; let best_block = state.best_block; if let Some(filter) = chain_data_source.as_ref() { @@ -841,7 +856,7 @@ where } } - let sweeper_state = Mutex::new(state); + let sweeper_state = Mutex::new(SweeperState { persistent: state }); Ok(Self { sweeper_state, pending_sweep: AtomicBool::new(false), @@ -880,7 +895,7 @@ where kv_store, logger, ) = args; - let state = SweeperState::read(reader)?; + let state = PersistentSweeperState::read(reader)?; let best_block = state.best_block; if let Some(filter) = chain_data_source.as_ref() { @@ -890,7 +905,7 @@ where } } - let sweeper_state = Mutex::new(state); + let sweeper_state = Mutex::new(SweeperState { persistent: state }); Ok(( best_block, OutputSweeper { From 84ce2f238c9432a0349717db87f1d7b9044751b0 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 9 Jun 2025 14:54:25 +0200 Subject: [PATCH 02/26] Persist sweeper state as part of background process To prepare for an async kv store trait that must be awaited, this commit moves the kv store calls from the chain notification handlers to the background process. It uses a dirty flag to communicate that there is something to persist. The block height is part of the persisted data. If that data does not make it to disk, the chain notifications are replayed after restart. --- lightning/src/util/sweep.rs | 60 +++++++++++++++++++++---------------- 1 file changed, 34 insertions(+), 26 deletions(-) diff --git a/lightning/src/util/sweep.rs b/lightning/src/util/sweep.rs index a80e6b524c1..dfdd078bc8e 100644 --- a/lightning/src/util/sweep.rs +++ b/lightning/src/util/sweep.rs @@ -382,8 +382,10 @@ where output_spender: O, change_destination_source: D, kv_store: K, logger: L, ) -> Self { let outputs = Vec::new(); - let sweeper_state = - Mutex::new(SweeperState { persistent: PersistentSweeperState { outputs, best_block } }); + let sweeper_state = Mutex::new(SweeperState { + persistent: PersistentSweeperState { outputs, best_block }, + dirty: false, + }); Self { sweeper_state, pending_sweep: AtomicBool::new(false), @@ -447,7 +449,10 @@ where } self.persist_state(&state_lock.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }) + })?; + state_lock.dirty = false; + + Ok(()) } /// Returns a list of the currently tracked spendable outputs. @@ -504,12 +509,20 @@ where // See if there is anything to sweep before requesting a change address. { - let sweeper_state = self.sweeper_state.lock().unwrap(); + let mut sweeper_state = self.sweeper_state.lock().unwrap(); let cur_height = sweeper_state.persistent.best_block.height; let has_respends = sweeper_state.persistent.outputs.iter().any(|o| filter_fn(o, cur_height)); if !has_respends { + // If there is nothing to sweep, we still persist the state if it is dirty. + if sweeper_state.dirty { + self.persist_state(&sweeper_state.persistent).map_err(|e| { + log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); + })?; + sweeper_state.dirty = false; + } + return Ok(()); } } @@ -534,7 +547,8 @@ where .collect(); if respend_descriptors.is_empty() { - // It could be that a tx confirmed and there is now nothing to sweep anymore. + // It could be that a tx confirmed and there is now nothing to sweep anymore. If there is dirty state, + // we'll persist it in the next cycle. return Ok(()); } @@ -570,6 +584,7 @@ where self.persist_state(&sweeper_state.persistent).map_err(|e| { log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); })?; + sweeper_state.dirty = false; self.broadcaster.broadcast_transactions(&[&spending_tx]); } @@ -595,6 +610,8 @@ where } true }); + + sweeper_state.dirty = true; } fn persist_state(&self, sweeper_state: &PersistentSweeperState) -> Result<(), io::Error> { @@ -648,6 +665,8 @@ where } } } + + sweeper_state.dirty = true; } fn best_block_updated_internal( @@ -655,6 +674,8 @@ where ) { sweeper_state.persistent.best_block = BestBlock::new(header.block_hash(), height); self.prune_confirmed_outputs(sweeper_state); + + sweeper_state.dirty = true; } } @@ -678,12 +699,8 @@ where assert_eq!(state_lock.persistent.best_block.height, height - 1, "Blocks must be connected in chain-order - the connected block height must be one greater than the previous height"); - self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height); - self.best_block_updated_internal(&mut *state_lock, header, height); - - let _ = self.persist_state(&state_lock.persistent).map_err(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }); + self.transactions_confirmed_internal(&mut state_lock, header, txdata, height); + self.best_block_updated_internal(&mut state_lock, header, height); } fn block_disconnected(&self, header: &Header, height: u32) { @@ -705,9 +722,7 @@ where } } - self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }); + state_lock.dirty = true; } } @@ -727,9 +742,6 @@ where ) { let mut state_lock = self.sweeper_state.lock().unwrap(); self.transactions_confirmed_internal(&mut *state_lock, header, txdata, height); - self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }); } fn transaction_unconfirmed(&self, txid: &Txid) { @@ -752,18 +764,13 @@ where .filter(|o| o.status.confirmation_height() >= Some(unconf_height)) .for_each(|o| o.status.unconfirmed()); - self.persist_state(&state_lock.persistent).unwrap_or_else(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }); + state_lock.dirty = true; } } fn best_block_updated(&self, header: &Header, height: u32) { let mut state_lock = self.sweeper_state.lock().unwrap(); - self.best_block_updated_internal(&mut *state_lock, header, height); - let _ = self.persist_state(&state_lock.persistent).map_err(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - }); + self.best_block_updated_internal(&mut state_lock, header, height); } fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option)> { @@ -792,6 +799,7 @@ where #[derive(Debug)] struct SweeperState { persistent: PersistentSweeperState, + dirty: bool, } #[derive(Debug, Clone)] @@ -856,7 +864,7 @@ where } } - let sweeper_state = Mutex::new(SweeperState { persistent: state }); + let sweeper_state = Mutex::new(SweeperState { persistent: state, dirty: false }); Ok(Self { sweeper_state, pending_sweep: AtomicBool::new(false), @@ -905,7 +913,7 @@ where } } - let sweeper_state = Mutex::new(SweeperState { persistent: state }); + let sweeper_state = Mutex::new(SweeperState { persistent: state, dirty: false }); Ok(( best_block, OutputSweeper { From f7d86d86fe48e18adc6e201093e647db3b91e1d5 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Wed, 11 Jun 2025 16:52:50 +0200 Subject: [PATCH 03/26] Async kv store in sweeper --- lightning/src/util/sweep.rs | 139 ++++++++++++++++++++---------------- 1 file changed, 78 insertions(+), 61 deletions(-) diff --git a/lightning/src/util/sweep.rs b/lightning/src/util/sweep.rs index dfdd078bc8e..a52bdf884cc 100644 --- a/lightning/src/util/sweep.rs +++ b/lightning/src/util/sweep.rs @@ -36,6 +36,7 @@ use bitcoin::{BlockHash, ScriptBuf, Transaction, Txid}; use core::future::Future; use core::ops::Deref; +use core::pin::Pin; use core::sync::atomic::{AtomicBool, Ordering}; use core::task; @@ -414,7 +415,7 @@ where /// Returns `Err` on persistence failure, in which case the call may be safely retried. /// /// [`Event::SpendableOutputs`]: crate::events::Event::SpendableOutputs - pub fn track_spendable_outputs( + pub async fn track_spendable_outputs( &self, output_descriptors: Vec, channel_id: Option, exclude_static_outputs: bool, delay_until_height: Option, ) -> Result<(), ()> { @@ -430,29 +431,34 @@ where return Ok(()); } - let mut state_lock = self.sweeper_state.lock().unwrap(); - for descriptor in relevant_descriptors { - let output_info = TrackedSpendableOutput { - descriptor, - channel_id, - status: OutputSpendStatus::PendingInitialBroadcast { - delayed_until_height: delay_until_height, - }, - }; - - let mut outputs = state_lock.persistent.outputs.iter(); - if outputs.find(|o| o.descriptor == output_info.descriptor).is_some() { - continue; - } + let persist_fut; + { + let mut state_lock = self.sweeper_state.lock().unwrap(); + for descriptor in relevant_descriptors { + let output_info = TrackedSpendableOutput { + descriptor, + channel_id, + status: OutputSpendStatus::PendingInitialBroadcast { + delayed_until_height: delay_until_height, + }, + }; - state_lock.persistent.outputs.push(output_info); + let mut outputs = state_lock.persistent.outputs.iter(); + if outputs.find(|o| o.descriptor == output_info.descriptor).is_some() { + continue; + } + + state_lock.persistent.outputs.push(output_info); + } + persist_fut = self.persist_state(&state_lock.persistent); + state_lock.dirty = false; } - self.persist_state(&state_lock.persistent).map_err(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - })?; - state_lock.dirty = false; - Ok(()) + persist_fut.await.map_err(|e| { + self.sweeper_state.lock().unwrap().dirty = true; + + log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); + }) } /// Returns a list of the currently tracked spendable outputs. @@ -508,30 +514,42 @@ where }; // See if there is anything to sweep before requesting a change address. + let persist_fut; + let has_respends; { let mut sweeper_state = self.sweeper_state.lock().unwrap(); let cur_height = sweeper_state.persistent.best_block.height; - let has_respends = + has_respends = sweeper_state.persistent.outputs.iter().any(|o| filter_fn(o, cur_height)); - if !has_respends { + if !has_respends && sweeper_state.dirty { // If there is nothing to sweep, we still persist the state if it is dirty. - if sweeper_state.dirty { - self.persist_state(&sweeper_state.persistent).map_err(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - })?; - sweeper_state.dirty = false; - } - - return Ok(()); + persist_fut = Some(self.persist_state(&sweeper_state.persistent)); + sweeper_state.dirty = false; + } else { + persist_fut = None; } } + if let Some(persist_fut) = persist_fut { + persist_fut.await.map_err(|e| { + self.sweeper_state.lock().unwrap().dirty = true; + + log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); + })?; + }; + + if !has_respends { + // If there is nothing to sweep, we return early. + return Ok(()); + } + // Request a new change address outside of the mutex to avoid the mutex crossing await. let change_destination_script = self.change_destination_source.get_change_destination_script().await?; // Sweep the outputs. + let persist_fut; { let mut sweeper_state = self.sweeper_state.lock().unwrap(); @@ -581,14 +599,17 @@ where output_info.status.broadcast(cur_hash, cur_height, spending_tx.clone()); } - self.persist_state(&sweeper_state.persistent).map_err(|e| { - log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); - })?; + persist_fut = self.persist_state(&sweeper_state.persistent); sweeper_state.dirty = false; - self.broadcaster.broadcast_transactions(&[&spending_tx]); } + persist_fut.await.map_err(|e| { + self.sweeper_state.lock().unwrap().dirty = true; + + log_error!(self.logger, "Error persisting OutputSweeper: {:?}", e); + })?; + Ok(()) } @@ -614,25 +635,19 @@ where sweeper_state.dirty = true; } - fn persist_state(&self, sweeper_state: &PersistentSweeperState) -> Result<(), io::Error> { - self.kv_store - .write( - OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, - OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, - OUTPUT_SWEEPER_PERSISTENCE_KEY, - &sweeper_state.encode(), - ) - .map_err(|e| { - log_error!( - self.logger, - "Write for key {}/{}/{} failed due to: {}", - OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, - OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, - OUTPUT_SWEEPER_PERSISTENCE_KEY, - e - ); - e - }) + fn persist_state<'a>( + &self, sweeper_state: &PersistentSweeperState, + ) -> Pin> + 'a + Send>> { + let encoded = &sweeper_state.encode(); + + let result = self.kv_store.write( + OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, + OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, + OUTPUT_SWEEPER_PERSISTENCE_KEY, + encoded, + ); + + Box::pin(async move { result }) } fn spend_outputs( @@ -993,16 +1008,18 @@ where } /// Tells the sweeper to track the given outputs descriptors. Wraps [`OutputSweeper::track_spendable_outputs`]. - pub fn track_spendable_outputs( + pub async fn track_spendable_outputs( &self, output_descriptors: Vec, channel_id: Option, exclude_static_outputs: bool, delay_until_height: Option, ) -> Result<(), ()> { - self.sweeper.track_spendable_outputs( - output_descriptors, - channel_id, - exclude_static_outputs, - delay_until_height, - ) + self.sweeper + .track_spendable_outputs( + output_descriptors, + channel_id, + exclude_static_outputs, + delay_until_height, + ) + .await } /// Returns a list of the currently tracked spendable outputs. Wraps [`OutputSweeper::tracked_spendable_outputs`]. From a016c2a8d5e672863a5e76da01be8da1ab4bc4d5 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Thu, 12 Jun 2025 19:52:37 +0200 Subject: [PATCH 04/26] Rustfmt chainmonitor.rs --- lightning/src/chain/chainmonitor.rs | 554 ++++++++++++++++++++-------- 1 file changed, 407 insertions(+), 147 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index a740fa3dbcb..60f1c9863a7 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -126,8 +126,9 @@ pub trait Persist { /// /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager /// [`Writeable::write`]: crate::util::ser::Writeable::write - #[rustfmt::skip] - fn persist_new_channel(&self, monitor_name: MonitorName, monitor: &ChannelMonitor) -> ChannelMonitorUpdateStatus; + fn persist_new_channel( + &self, monitor_name: MonitorName, monitor: &ChannelMonitor, + ) -> ChannelMonitorUpdateStatus; /// Update one channel's data. The provided [`ChannelMonitor`] has already applied the given /// update. @@ -166,8 +167,10 @@ pub trait Persist { /// [`ChannelMonitorUpdateStatus`] for requirements when returning errors. /// /// [`Writeable::write`]: crate::util::ser::Writeable::write - #[rustfmt::skip] - fn update_persisted_channel(&self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, monitor: &ChannelMonitor) -> ChannelMonitorUpdateStatus; + fn update_persisted_channel( + &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, + monitor: &ChannelMonitor, + ) -> ChannelMonitorUpdateStatus; /// Prevents the channel monitor from being loaded on startup. /// /// Archiving the data in a backup location (rather than deleting it fully) is useful for @@ -306,10 +309,10 @@ where /// updated `txdata`. /// /// Calls which represent a new blockchain tip height should set `best_height`. - #[rustfmt::skip] - fn process_chain_data(&self, header: &Header, best_height: Option, txdata: &TransactionData, process: FN) - where - FN: Fn(&ChannelMonitor, &TransactionData) -> Vec + fn process_chain_data( + &self, header: &Header, best_height: Option, txdata: &TransactionData, process: FN, + ) where + FN: Fn(&ChannelMonitor, &TransactionData) -> Vec, { let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down."; let channel_ids = hash_set_from_iter(self.monitors.read().unwrap().keys().cloned()); @@ -317,7 +320,18 @@ where for channel_id in channel_ids.iter() { let monitor_lock = self.monitors.read().unwrap(); if let Some(monitor_state) = monitor_lock.get(channel_id) { - if self.update_monitor_with_chain_data(header, best_height, txdata, &process, channel_id, &monitor_state, channel_count).is_err() { + if self + .update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ) + .is_err() + { // Take the monitors lock for writing so that we poison it and any future // operations going forward fail immediately. core::mem::drop(monitor_lock); @@ -332,7 +346,18 @@ where let monitor_states = self.monitors.write().unwrap(); for (channel_id, monitor_state) in monitor_states.iter() { if !channel_ids.contains(channel_id) { - if self.update_monitor_with_chain_data(header, best_height, txdata, &process, channel_id, &monitor_state, channel_count).is_err() { + if self + .update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ) + .is_err() + { log_error!(self.logger, "{}", err_str); panic!("{}", err_str); } @@ -350,11 +375,13 @@ where } } - #[rustfmt::skip] fn update_monitor_with_chain_data( - &self, header: &Header, best_height: Option, txdata: &TransactionData, process: FN, channel_id: &ChannelId, - monitor_state: &MonitorHolder, channel_count: usize, - ) -> Result<(), ()> where FN: Fn(&ChannelMonitor, &TransactionData) -> Vec { + &self, header: &Header, best_height: Option, txdata: &TransactionData, process: FN, + channel_id: &ChannelId, monitor_state: &MonitorHolder, channel_count: usize, + ) -> Result<(), ()> + where + FN: Fn(&ChannelMonitor, &TransactionData) -> Vec, + { let monitor = &monitor_state.monitor; let logger = WithChannelMonitor::from(&self.logger, &monitor, None); @@ -362,7 +389,12 @@ where let get_partition_key = |channel_id: &ChannelId| { let channel_id_bytes = channel_id.0; - let channel_id_u32 = u32::from_be_bytes([channel_id_bytes[0], channel_id_bytes[1], channel_id_bytes[2], channel_id_bytes[3]]); + let channel_id_u32 = u32::from_be_bytes([ + channel_id_bytes[0], + channel_id_bytes[1], + channel_id_bytes[2], + channel_id_bytes[3], + ]); channel_id_u32.wrapping_add(best_height.unwrap_or_default()) }; @@ -374,23 +406,33 @@ where let has_pending_claims = monitor_state.monitor.has_pending_claims(); if has_pending_claims || get_partition_key(channel_id) % partition_factor == 0 { - log_trace!(logger, "Syncing Channel Monitor for channel {}", log_funding_info!(monitor)); + log_trace!( + logger, + "Syncing Channel Monitor for channel {}", + log_funding_info!(monitor) + ); // Even though we don't track monitor updates from chain-sync as pending, we still want // updates per-channel to be well-ordered so that users don't see a // `ChannelMonitorUpdate` after a channel persist for a channel with the same // `latest_update_id`. let _pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap(); - match self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor) { - ChannelMonitorUpdateStatus::Completed => - log_trace!(logger, "Finished syncing Channel Monitor for channel {} for block-data", - log_funding_info!(monitor) - ), + match self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor) + { + ChannelMonitorUpdateStatus::Completed => log_trace!( + logger, + "Finished syncing Channel Monitor for channel {} for block-data", + log_funding_info!(monitor) + ), ChannelMonitorUpdateStatus::InProgress => { - log_trace!(logger, "Channel Monitor sync for channel {} in progress.", log_funding_info!(monitor)); - } + log_trace!( + logger, + "Channel Monitor sync for channel {} in progress.", + log_funding_info!(monitor) + ); + }, ChannelMonitorUpdateStatus::UnrecoverableError => { return Err(()); - } + }, } } @@ -406,7 +448,11 @@ where outpoint: OutPoint { txid, index: idx as u16 }, script_pubkey: output.script_pubkey, }; - log_trace!(logger, "Adding monitoring for spends of outpoint {} to the filter", output.outpoint); + log_trace!( + logger, + "Adding monitoring for spends of outpoint {} to the filter", + output.outpoint + ); chain_source.register_output(output); } } @@ -433,8 +479,10 @@ where /// [`NodeSigner`]: crate::sign::NodeSigner /// [`NodeSigner::get_peer_storage_key`]: crate::sign::NodeSigner::get_peer_storage_key /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager - #[rustfmt::skip] - pub fn new(chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey) -> Self { + pub fn new( + chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, + entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, + ) -> Self { Self { monitors: RwLock::new(new_hash_map()), chain_source, @@ -447,7 +495,7 @@ where highest_chain_height: AtomicUsize::new(0), event_notifier: Notifier::new(), pending_send_only_events: Mutex::new(Vec::new()), - our_peerstorage_encryption_key + our_peerstorage_encryption_key, } } @@ -515,11 +563,15 @@ where /// Each `Vec` contains `update_id`s from [`ChannelMonitor::get_latest_update_id`] for updates /// that have not yet been fully persisted. Note that if a full monitor is persisted all the pending /// monitor updates must be individually marked completed by calling [`ChainMonitor::channel_monitor_updated`]. - #[rustfmt::skip] pub fn list_pending_monitor_updates(&self) -> Vec<(ChannelId, Vec)> { - self.monitors.read().unwrap().iter().map(|(channel_id, holder)| { - (*channel_id, holder.pending_monitor_updates.lock().unwrap().clone()) - }).collect() + self.monitors + .read() + .unwrap() + .iter() + .map(|(channel_id, holder)| { + (*channel_id, holder.pending_monitor_updates.lock().unwrap().clone()) + }) + .collect() } #[cfg(any(test, feature = "_test_utils"))] @@ -547,11 +599,16 @@ where /// /// Returns an [`APIError::APIMisuseError`] if `funding_txo` does not match any currently /// registered [`ChannelMonitor`]s. - #[rustfmt::skip] - pub fn channel_monitor_updated(&self, channel_id: ChannelId, completed_update_id: u64) -> Result<(), APIError> { + pub fn channel_monitor_updated( + &self, channel_id: ChannelId, completed_update_id: u64, + ) -> Result<(), APIError> { let monitors = self.monitors.read().unwrap(); - let monitor_data = if let Some(mon) = monitors.get(&channel_id) { mon } else { - return Err(APIError::APIMisuseError { err: format!("No ChannelMonitor matching channel ID {} found", channel_id) }); + let monitor_data = if let Some(mon) = monitors.get(&channel_id) { + mon + } else { + return Err(APIError::APIMisuseError { + err: format!("No ChannelMonitor matching channel ID {} found", channel_id), + }); }; let mut pending_monitor_updates = monitor_data.pending_monitor_updates.lock().unwrap(); pending_monitor_updates.retain(|update_id| *update_id != completed_update_id); @@ -559,25 +616,33 @@ where // Note that we only check for pending non-chainsync monitor updates and we don't track monitor // updates resulting from chainsync in `pending_monitor_updates`. let monitor_is_pending_updates = monitor_data.has_pending_updates(&pending_monitor_updates); - log_debug!(self.logger, "Completed off-chain monitor update {} for channel with channel ID {}, {}", + log_debug!( + self.logger, + "Completed off-chain monitor update {} for channel with channel ID {}, {}", completed_update_id, channel_id, if monitor_is_pending_updates { "still have pending off-chain updates" } else { "all off-chain updates complete, returning a MonitorEvent" - }); + } + ); if monitor_is_pending_updates { // If there are still monitor updates pending, we cannot yet construct a // Completed event. return Ok(()); } let funding_txo = monitor_data.monitor.get_funding_txo(); - self.pending_monitor_events.lock().unwrap().push((funding_txo, channel_id, vec![MonitorEvent::Completed { + self.pending_monitor_events.lock().unwrap().push(( funding_txo, channel_id, - monitor_update_id: monitor_data.monitor.get_latest_update_id(), - }], monitor_data.monitor.get_counterparty_node_id())); + vec![MonitorEvent::Completed { + funding_txo, + channel_id, + monitor_update_id: monitor_data.monitor.get_latest_update_id(), + }], + monitor_data.monitor.get_counterparty_node_id(), + )); self.event_notifier.notify(); Ok(()) @@ -587,17 +652,17 @@ where /// chain::Watch API wherein we mark a monitor fully-updated by just calling /// channel_monitor_updated once with the highest ID. #[cfg(any(test, fuzzing))] - #[rustfmt::skip] pub fn force_channel_monitor_updated(&self, channel_id: ChannelId, monitor_update_id: u64) { let monitors = self.monitors.read().unwrap(); let monitor = &monitors.get(&channel_id).unwrap().monitor; let counterparty_node_id = monitor.get_counterparty_node_id(); let funding_txo = monitor.get_funding_txo(); - self.pending_monitor_events.lock().unwrap().push((funding_txo, channel_id, vec![MonitorEvent::Completed { + self.pending_monitor_events.lock().unwrap().push(( funding_txo, channel_id, - monitor_update_id, - }], counterparty_node_id)); + vec![MonitorEvent::Completed { funding_txo, channel_id, monitor_update_id }], + counterparty_node_id, + )); self.event_notifier.notify(); } @@ -616,9 +681,11 @@ where /// See the trait-level documentation of [`EventsProvider`] for requirements. /// /// [`EventsProvider`]: crate::events::EventsProvider - #[rustfmt::skip] - pub async fn process_pending_events_async>, H: Fn(Event) -> Future>( - &self, handler: H + pub async fn process_pending_events_async< + Future: core::future::Future>, + H: Fn(Event) -> Future, + >( + &self, handler: H, ) { // Sadly we can't hold the monitors read lock through an async call. Thus we have to do a // crazy dance to process a monitor's events then only remove them once we've done so. @@ -626,11 +693,15 @@ where for channel_id in mons_to_process { let mut ev; match super::channelmonitor::process_events_body!( - self.monitors.read().unwrap().get(&channel_id).map(|m| &m.monitor), self.logger, ev, handler(ev).await) { + self.monitors.read().unwrap().get(&channel_id).map(|m| &m.monitor), + self.logger, + ev, + handler(ev).await + ) { Ok(()) => {}, - Err(ReplayEvent ()) => { + Err(ReplayEvent()) => { self.event_notifier.notify(); - } + }, } } } @@ -652,12 +723,13 @@ where /// feerate changes between blocks, and ensuring reliability if broadcasting fails. We recommend /// invoking this every 30 seconds, or lower if running in an environment with spotty /// connections, like on mobile. - #[rustfmt::skip] pub fn rebroadcast_pending_claims(&self) { let monitors = self.monitors.read().unwrap(); for (_, monitor_holder) in &*monitors { monitor_holder.monitor.rebroadcast_pending_claims( - &*self.broadcaster, &*self.fee_estimator, &self.logger + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, ) } } @@ -666,19 +738,22 @@ where /// signature generation failure. /// /// `monitor_opt` can be used as a filter to only trigger them for a specific channel monitor. - #[rustfmt::skip] pub fn signer_unblocked(&self, monitor_opt: Option) { let monitors = self.monitors.read().unwrap(); if let Some(channel_id) = monitor_opt { if let Some(monitor_holder) = monitors.get(&channel_id) { monitor_holder.monitor.signer_unblocked( - &*self.broadcaster, &*self.fee_estimator, &self.logger + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, ) } } else { for (_, monitor_holder) in &*monitors { monitor_holder.monitor.signer_unblocked( - &*self.broadcaster, &*self.fee_estimator, &self.logger + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, ) } } @@ -693,30 +768,37 @@ where /// /// Depending on the implementation of [`Persist::archive_persisted_channel`] the monitor /// data could be moved to an archive location or removed entirely. - #[rustfmt::skip] pub fn archive_fully_resolved_channel_monitors(&self) { let mut have_monitors_to_prune = false; for monitor_holder in self.monitors.read().unwrap().values() { let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None); - let (is_fully_resolved, needs_persistence) = monitor_holder.monitor.check_and_update_full_resolution_status(&logger); + let (is_fully_resolved, needs_persistence) = + monitor_holder.monitor.check_and_update_full_resolution_status(&logger); if is_fully_resolved { have_monitors_to_prune = true; } if needs_persistence { - self.persister.update_persisted_channel(monitor_holder.monitor.persistence_key(), None, &monitor_holder.monitor); + self.persister.update_persisted_channel( + monitor_holder.monitor.persistence_key(), + None, + &monitor_holder.monitor, + ); } } if have_monitors_to_prune { let mut monitors = self.monitors.write().unwrap(); monitors.retain(|channel_id, monitor_holder| { let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None); - let (is_fully_resolved, _) = monitor_holder.monitor.check_and_update_full_resolution_status(&logger); + let (is_fully_resolved, _) = + monitor_holder.monitor.check_and_update_full_resolution_status(&logger); if is_fully_resolved { - log_info!(logger, + log_info!( + logger, "Archiving fully resolved ChannelMonitor for channel ID {}", channel_id ); - self.persister.archive_persisted_channel(monitor_holder.monitor.persistence_key()); + self.persister + .archive_persisted_channel(monitor_holder.monitor.persistence_key()); false } else { true @@ -727,16 +809,11 @@ where /// This function collects the counterparty node IDs from all monitors into a `HashSet`, /// ensuring unique IDs are returned. - #[rustfmt::skip] fn all_counterparty_node_ids(&self) -> HashSet { let mon = self.monitors.read().unwrap(); - mon - .values() - .map(|monitor| monitor.monitor.get_counterparty_node_id()) - .collect() + mon.values().map(|monitor| monitor.monitor.get_counterparty_node_id()).collect() } - #[rustfmt::skip] fn send_peer_storage(&self, their_node_id: PublicKey) { // TODO: Serialize `ChannelMonitor`s inside `our_peer_storage`. @@ -747,7 +824,8 @@ where log_debug!(self.logger, "Sending Peer Storage to {}", log_pubkey!(their_node_id)); let send_peer_storage_event = MessageSendEvent::SendPeerStorage { - node_id: their_node_id, msg: msgs::PeerStorage { data: cipher.into_vec() } + node_id: their_node_id, + msg: msgs::PeerStorage { data: cipher.into_vec() }, }; self.pending_send_only_events.lock().unwrap().push(send_peer_storage_event) @@ -786,8 +864,11 @@ where InitFeatures::empty() } - #[rustfmt::skip] - fn peer_connected(&self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool) -> Result<(), ()> { Ok(()) } + fn peer_connected( + &self, _their_node_id: PublicKey, _msg: &Init, _inbound: bool, + ) -> Result<(), ()> { + Ok(()) + } } impl< @@ -807,12 +888,22 @@ where P::Target: Persist, ES::Target: EntropySource, { - #[rustfmt::skip] fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) { - log_debug!(self.logger, "New best block {} at height {} provided via block_connected", header.block_hash(), height); + log_debug!( + self.logger, + "New best block {} at height {} provided via block_connected", + header.block_hash(), + height + ); self.process_chain_data(header, Some(height), &txdata, |monitor, txdata| { monitor.block_connected( - header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &self.logger) + header, + txdata, + height, + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, + ) }); // Send peer storage everytime a new block arrives. @@ -824,13 +915,22 @@ where self.event_notifier.notify(); } - #[rustfmt::skip] fn block_disconnected(&self, header: &Header, height: u32) { let monitor_states = self.monitors.read().unwrap(); - log_debug!(self.logger, "Latest block {} at height {} removed via block_disconnected", header.block_hash(), height); + log_debug!( + self.logger, + "Latest block {} at height {} removed via block_disconnected", + header.block_hash(), + height + ); for monitor_state in monitor_states.values() { monitor_state.monitor.block_disconnected( - header, height, &*self.broadcaster, &*self.fee_estimator, &self.logger); + header, + height, + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, + ); } } } @@ -852,35 +952,58 @@ where P::Target: Persist, ES::Target: EntropySource, { - #[rustfmt::skip] fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) { - log_debug!(self.logger, "{} provided transactions confirmed at height {} in block {}", txdata.len(), height, header.block_hash()); + log_debug!( + self.logger, + "{} provided transactions confirmed at height {} in block {}", + txdata.len(), + height, + header.block_hash() + ); self.process_chain_data(header, None, txdata, |monitor, txdata| { monitor.transactions_confirmed( - header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &self.logger) + header, + txdata, + height, + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, + ) }); // Assume we may have some new events and wake the event processor self.event_notifier.notify(); } - #[rustfmt::skip] fn transaction_unconfirmed(&self, txid: &Txid) { log_debug!(self.logger, "Transaction {} reorganized out of chain", txid); let monitor_states = self.monitors.read().unwrap(); for monitor_state in monitor_states.values() { - monitor_state.monitor.transaction_unconfirmed(txid, &*self.broadcaster, &*self.fee_estimator, &self.logger); + monitor_state.monitor.transaction_unconfirmed( + txid, + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, + ); } } - #[rustfmt::skip] fn best_block_updated(&self, header: &Header, height: u32) { - log_debug!(self.logger, "New best block {} at height {} provided via best_block_updated", header.block_hash(), height); + log_debug!( + self.logger, + "New best block {} at height {} provided via best_block_updated", + header.block_hash(), + height + ); self.process_chain_data(header, Some(height), &[], |monitor, txdata| { // While in practice there shouldn't be any recursive calls when given empty txdata, // it's still possible if a chain::Filter implementation returns a transaction. debug_assert!(txdata.is_empty()); monitor.best_block_updated( - header, height, &*self.broadcaster, &*self.fee_estimator, &self.logger + header, + height, + &*self.broadcaster, + &*self.fee_estimator, + &self.logger, ) }); @@ -923,8 +1046,9 @@ where P::Target: Persist, ES::Target: EntropySource, { - #[rustfmt::skip] - fn watch_channel(&self, channel_id: ChannelId, monitor: ChannelMonitor) -> Result { + fn watch_channel( + &self, channel_id: ChannelId, monitor: ChannelMonitor, + ) -> Result { let logger = WithChannelMonitor::from(&self.logger, &monitor, None); let mut monitors = self.monitors.write().unwrap(); let entry = match monitors.entry(channel_id) { @@ -940,11 +1064,19 @@ where let persist_res = self.persister.persist_new_channel(monitor.persistence_key(), &monitor); match persist_res { ChannelMonitorUpdateStatus::InProgress => { - log_info!(logger, "Persistence of new ChannelMonitor for channel {} in progress", log_funding_info!(monitor)); + log_info!( + logger, + "Persistence of new ChannelMonitor for channel {} in progress", + log_funding_info!(monitor) + ); pending_monitor_updates.push(update_id); }, ChannelMonitorUpdateStatus::Completed => { - log_info!(logger, "Persistence of new ChannelMonitor for channel {} completed", log_funding_info!(monitor)); + log_info!( + logger, + "Persistence of new ChannelMonitor for channel {} completed", + log_funding_info!(monitor) + ); }, ChannelMonitorUpdateStatus::UnrecoverableError => { let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down."; @@ -953,7 +1085,7 @@ where }, } if let Some(ref chain_source) = self.chain_source { - monitor.load_outputs_to_watch(chain_source , &self.logger); + monitor.load_outputs_to_watch(chain_source, &self.logger); } entry.insert(MonitorHolder { monitor, @@ -962,8 +1094,9 @@ where Ok(persist_res) } - #[rustfmt::skip] - fn update_channel(&self, channel_id: ChannelId, update: &ChannelMonitorUpdate) -> ChannelMonitorUpdateStatus { + fn update_channel( + &self, channel_id: ChannelId, update: &ChannelMonitorUpdate, + ) -> ChannelMonitorUpdateStatus { // `ChannelMonitorUpdate`'s `channel_id` is `None` prior to 0.0.121 and all channels in those // versions are V1-established. For 0.0.121+ the `channel_id` fields is always `Some`. debug_assert_eq!(update.channel_id.unwrap(), channel_id); @@ -985,13 +1118,24 @@ where Some(monitor_state) => { let monitor = &monitor_state.monitor; let logger = WithChannelMonitor::from(&self.logger, &monitor, None); - log_trace!(logger, "Updating ChannelMonitor to id {} for channel {}", update.update_id, log_funding_info!(monitor)); + log_trace!( + logger, + "Updating ChannelMonitor to id {} for channel {}", + update.update_id, + log_funding_info!(monitor) + ); // We hold a `pending_monitor_updates` lock through `update_monitor` to ensure we // have well-ordered updates from the users' point of view. See the // `pending_monitor_updates` docs for more. - let mut pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap(); - let update_res = monitor.update_monitor(update, &self.broadcaster, &self.fee_estimator, &self.logger); + let mut pending_monitor_updates = + monitor_state.pending_monitor_updates.lock().unwrap(); + let update_res = monitor.update_monitor( + update, + &self.broadcaster, + &self.fee_estimator, + &self.logger, + ); let update_id = update.update_id; let persist_res = if update_res.is_err() { @@ -1001,9 +1145,17 @@ where // while reading `channel_monitor` with updates from storage. Instead, we should persist // the entire `channel_monitor` here. log_warn!(logger, "Failed to update ChannelMonitor for channel {}. Going ahead and persisting the entire ChannelMonitor", log_funding_info!(monitor)); - self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor) + self.persister.update_persisted_channel( + monitor.persistence_key(), + None, + monitor, + ) } else { - self.persister.update_persisted_channel(monitor.persistence_key(), Some(update), monitor) + self.persister.update_persisted_channel( + monitor.persistence_key(), + Some(update), + monitor, + ) }; match persist_res { ChannelMonitorUpdateStatus::InProgress => { @@ -1015,7 +1167,8 @@ where ); }, ChannelMonitorUpdateStatus::Completed => { - log_debug!(logger, + log_debug!( + logger, "Persistence of ChannelMonitorUpdate id {:?} for channel {} completed", update_id, log_funding_info!(monitor) @@ -1037,12 +1190,13 @@ where } else { persist_res } - } + }, } } - #[rustfmt::skip] - fn release_pending_monitor_events(&self) -> Vec<(OutPoint, ChannelId, Vec, PublicKey)> { + fn release_pending_monitor_events( + &self, + ) -> Vec<(OutPoint, ChannelId, Vec, PublicKey)> { let mut pending_monitor_events = self.pending_monitor_events.lock().unwrap().split_off(0); for monitor_state in self.monitors.read().unwrap().values() { let monitor_events = monitor_state.monitor.get_and_clear_pending_monitor_events(); @@ -1050,7 +1204,12 @@ where let monitor_funding_txo = monitor_state.monitor.get_funding_txo(); let monitor_channel_id = monitor_state.monitor.channel_id(); let counterparty_node_id = monitor_state.monitor.get_counterparty_node_id(); - pending_monitor_events.push((monitor_funding_txo, monitor_channel_id, monitor_events, counterparty_node_id)); + pending_monitor_events.push(( + monitor_funding_txo, + monitor_channel_id, + monitor_events, + counterparty_node_id, + )); } } pending_monitor_events @@ -1087,14 +1246,16 @@ where /// /// [`SpendableOutputs`]: events::Event::SpendableOutputs /// [`BumpTransaction`]: events::Event::BumpTransaction - #[rustfmt::skip] - fn process_pending_events(&self, handler: H) where H::Target: EventHandler { + fn process_pending_events(&self, handler: H) + where + H::Target: EventHandler, + { for monitor_state in self.monitors.read().unwrap().values() { match monitor_state.monitor.process_pending_events(&handler, &self.logger) { Ok(()) => {}, - Err(ReplayEvent ()) => { + Err(ReplayEvent()) => { self.event_notifier.notify(); - } + }, } } } @@ -1114,7 +1275,6 @@ mod tests { const CHAINSYNC_MONITOR_PARTITION_FACTOR: u32 = 5; #[test] - #[rustfmt::skip] fn test_async_ooo_offchain_updates() { // Test that if we have multiple offchain updates being persisted and they complete // out-of-order, the ChainMonitor waits until all have completed before informing the @@ -1126,8 +1286,10 @@ mod tests { let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; // Route two payments to be claimed at the same time. - let (payment_preimage_1, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - let (payment_preimage_2, payment_hash_2, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + let (payment_preimage_1, payment_hash_1, ..) = + route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + let (payment_preimage_2, payment_hash_2, ..) = + route_payment(&nodes[0], &[&nodes[1]], 1_000_000); chanmon_cfgs[1].persister.offchain_monitor_updates.lock().unwrap().clear(); chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); @@ -1138,7 +1300,8 @@ mod tests { nodes[1].node.claim_funds(payment_preimage_2); check_added_monitors!(nodes[1], 1); - let persistences = chanmon_cfgs[1].persister.offchain_monitor_updates.lock().unwrap().clone(); + let persistences = + chanmon_cfgs[1].persister.offchain_monitor_updates.lock().unwrap().clone(); assert_eq!(persistences.len(), 1); let (_, updates) = persistences.iter().next().unwrap(); assert_eq!(updates.len(), 2); @@ -1149,23 +1312,55 @@ mod tests { let next_update = update_iter.next().unwrap().clone(); // Should contain next_update when pending updates listed. #[cfg(not(c_bindings))] - assert!(nodes[1].chain_monitor.chain_monitor.list_pending_monitor_updates().get(&channel_id) - .unwrap().contains(&next_update)); + assert!(nodes[1] + .chain_monitor + .chain_monitor + .list_pending_monitor_updates() + .get(&channel_id) + .unwrap() + .contains(&next_update)); #[cfg(c_bindings)] - assert!(nodes[1].chain_monitor.chain_monitor.list_pending_monitor_updates().iter() - .find(|(chan_id, _)| *chan_id == channel_id).unwrap().1.contains(&next_update)); - nodes[1].chain_monitor.chain_monitor.channel_monitor_updated(channel_id, next_update.clone()).unwrap(); + assert!(nodes[1] + .chain_monitor + .chain_monitor + .list_pending_monitor_updates() + .iter() + .find(|(chan_id, _)| *chan_id == channel_id) + .unwrap() + .1 + .contains(&next_update)); + nodes[1] + .chain_monitor + .chain_monitor + .channel_monitor_updated(channel_id, next_update.clone()) + .unwrap(); // Should not contain the previously pending next_update when pending updates listed. #[cfg(not(c_bindings))] - assert!(!nodes[1].chain_monitor.chain_monitor.list_pending_monitor_updates().get(&channel_id) - .unwrap().contains(&next_update)); + assert!(!nodes[1] + .chain_monitor + .chain_monitor + .list_pending_monitor_updates() + .get(&channel_id) + .unwrap() + .contains(&next_update)); #[cfg(c_bindings)] - assert!(!nodes[1].chain_monitor.chain_monitor.list_pending_monitor_updates().iter() - .find(|(chan_id, _)| *chan_id == channel_id).unwrap().1.contains(&next_update)); + assert!(!nodes[1] + .chain_monitor + .chain_monitor + .list_pending_monitor_updates() + .iter() + .find(|(chan_id, _)| *chan_id == channel_id) + .unwrap() + .1 + .contains(&next_update)); assert!(nodes[1].chain_monitor.release_pending_monitor_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - nodes[1].chain_monitor.chain_monitor.channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()).unwrap(); + nodes[1] + .chain_monitor + .chain_monitor + .channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()) + .unwrap(); let claim_events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(claim_events.len(), 2); @@ -1186,33 +1381,60 @@ mod tests { // back-to-back it doesn't fit into the neat walk commitment_signed_dance does. let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); + nodes[0].node.handle_update_fulfill_htlc( + nodes[1].node.get_our_node_id(), + &updates.update_fulfill_htlcs[0], + ); expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &updates.commitment_signed); + nodes[0].node.handle_commitment_signed_batch_test( + nodes[1].node.get_our_node_id(), + &updates.commitment_signed, + ); check_added_monitors!(nodes[0], 1); - let (as_first_raa, as_first_update) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id()); + let (as_first_raa, as_first_update) = + get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id()); nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &as_first_raa); check_added_monitors!(nodes[1], 1); let bs_second_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_first_update); + nodes[1] + .node + .handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_first_update); check_added_monitors!(nodes[1], 1); - let bs_first_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id()); - - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &bs_second_updates.update_fulfill_htlcs[0]); + let bs_first_raa = get_event_msg!( + nodes[1], + MessageSendEvent::SendRevokeAndACK, + nodes[0].node.get_our_node_id() + ); + + nodes[0].node.handle_update_fulfill_htlc( + nodes[1].node.get_our_node_id(), + &bs_second_updates.update_fulfill_htlcs[0], + ); expect_payment_sent(&nodes[0], payment_preimage_2, None, false, false); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_second_updates.commitment_signed); + nodes[0].node.handle_commitment_signed_batch_test( + nodes[1].node.get_our_node_id(), + &bs_second_updates.commitment_signed, + ); check_added_monitors!(nodes[0], 1); nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_first_raa); expect_payment_path_successful!(nodes[0]); check_added_monitors!(nodes[0], 1); - let (as_second_raa, as_second_update) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id()); + let (as_second_raa, as_second_update) = + get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id()); nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &as_second_raa); check_added_monitors!(nodes[1], 1); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_second_update); + nodes[1].node.handle_commitment_signed_batch_test( + nodes[0].node.get_our_node_id(), + &as_second_update, + ); check_added_monitors!(nodes[1], 1); - let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id()); + let bs_second_raa = get_event_msg!( + nodes[1], + MessageSendEvent::SendRevokeAndACK, + nodes[0].node.get_our_node_id() + ); nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_second_raa); expect_payment_path_successful!(nodes[0]); @@ -1220,7 +1442,6 @@ mod tests { } #[test] - #[rustfmt::skip] fn test_chainsync_triggers_distributed_monitor_persistence() { let chanmon_cfgs = create_chanmon_cfgs(3); let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); @@ -1234,7 +1455,8 @@ mod tests { *nodes[2].connect_style.borrow_mut() = ConnectStyle::FullBlockViaListen; let _channel_1 = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let channel_2 = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0).2; + let channel_2 = + create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1_000_000, 0).2; chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); chanmon_cfgs[1].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); @@ -1246,15 +1468,37 @@ mod tests { // Connecting [`DEFAULT_CHAINSYNC_PARTITION_FACTOR`] * 2 blocks should trigger only 2 writes // per monitor/channel. - assert_eq!(2 * 2, chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len()); - assert_eq!(2, chanmon_cfgs[1].persister.chain_sync_monitor_persistences.lock().unwrap().len()); - assert_eq!(2, chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().len()); + assert_eq!( + 2 * 2, + chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); + assert_eq!( + 2, + chanmon_cfgs[1].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); + assert_eq!( + 2, + chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); // Test that monitors with pending_claims are persisted on every block. // Now, close channel_2 i.e. b/w node-0 and node-2 to create pending_claim in node[0]. - nodes[0].node.force_close_broadcasting_latest_txn(&channel_2, &nodes[2].node.get_our_node_id(), "Channel force-closed".to_string()).unwrap(); - check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, false, - [nodes[2].node.get_our_node_id()], 1000000); + nodes[0] + .node + .force_close_broadcasting_latest_txn( + &channel_2, + &nodes[2].node.get_our_node_id(), + "Channel force-closed".to_string(), + ) + .unwrap(); + check_closed_event!( + &nodes[0], + 1, + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, + false, + [nodes[2].node.get_our_node_id()], + 1000000 + ); check_closed_broadcast(&nodes[0], 1, true); let close_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); assert_eq!(close_tx.len(), 1); @@ -1262,8 +1506,14 @@ mod tests { mine_transaction(&nodes[2], &close_tx[0]); check_added_monitors(&nodes[2], 1); check_closed_broadcast(&nodes[2], 1, true); - check_closed_event!(&nodes[2], 1, ClosureReason::CommitmentTxConfirmed, false, - [nodes[0].node.get_our_node_id()], 1000000); + check_closed_event!( + &nodes[2], + 1, + ClosureReason::CommitmentTxConfirmed, + false, + [nodes[0].node.get_our_node_id()], + 1000000 + ); chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); @@ -1277,9 +1527,15 @@ mod tests { // DEFAULT_CHAINSYNC_MONITOR_PARTITION_FACTOR writes for channel_2 due to pending_claim, 1 for // channel_1 - assert_eq!((CHAINSYNC_MONITOR_PARTITION_FACTOR + 1) as usize, chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len()); + assert_eq!( + (CHAINSYNC_MONITOR_PARTITION_FACTOR + 1) as usize, + chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); // For node[2], there is no pending_claim - assert_eq!(1, chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().len()); + assert_eq!( + 1, + chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); // Confirm claim for node[0] with ANTI_REORG_DELAY and reset monitor write counter. mine_transaction(&nodes[0], &close_tx[0]); @@ -1290,12 +1546,14 @@ mod tests { // Again connect 1 full cycle of DEFAULT_CHAINSYNC_MONITOR_PARTITION_FACTOR blocks, it should only // result in 1 write per monitor/channel. connect_blocks(&nodes[0], CHAINSYNC_MONITOR_PARTITION_FACTOR); - assert_eq!(2, chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len()); + assert_eq!( + 2, + chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().len() + ); } #[test] #[cfg(feature = "std")] - #[rustfmt::skip] fn update_during_chainsync_poisons_channel() { let chanmon_cfgs = create_chanmon_cfgs(2); let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); @@ -1311,10 +1569,12 @@ mod tests { // Connecting [`DEFAULT_CHAINSYNC_PARTITION_FACTOR`] blocks so that we trigger some persistence // after accounting for block-height based partitioning/distribution. connect_blocks(&nodes[0], CHAINSYNC_MONITOR_PARTITION_FACTOR); - }).is_err()); + }) + .is_err()); assert!(std::panic::catch_unwind(|| { // ...and also poison our locks causing later use to panic as well core::mem::drop(nodes); - }).is_err()); + }) + .is_err()); } } From 543aaed698d5ed1bd5e6010eb4ef0ed275ba51ed Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Thu, 12 Jun 2025 21:11:59 +0200 Subject: [PATCH 05/26] Formatting improvements chainmonitor.rs --- lightning/src/chain/chainmonitor.rs | 73 ++++++++++++----------------- 1 file changed, 29 insertions(+), 44 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 60f1c9863a7..89d58c9e303 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -320,18 +320,16 @@ where for channel_id in channel_ids.iter() { let monitor_lock = self.monitors.read().unwrap(); if let Some(monitor_state) = monitor_lock.get(channel_id) { - if self - .update_monitor_with_chain_data( - header, - best_height, - txdata, - &process, - channel_id, - &monitor_state, - channel_count, - ) - .is_err() - { + let update_res = self.update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ); + if update_res.is_err() { // Take the monitors lock for writing so that we poison it and any future // operations going forward fail immediately. core::mem::drop(monitor_lock); @@ -346,18 +344,16 @@ where let monitor_states = self.monitors.write().unwrap(); for (channel_id, monitor_state) in monitor_states.iter() { if !channel_ids.contains(channel_id) { - if self - .update_monitor_with_chain_data( - header, - best_height, - txdata, - &process, - channel_id, - &monitor_state, - channel_count, - ) - .is_err() - { + let update_res = self.update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ); + if update_res.is_err() { log_error!(self.logger, "{}", err_str); panic!("{}", err_str); } @@ -564,10 +560,8 @@ where /// that have not yet been fully persisted. Note that if a full monitor is persisted all the pending /// monitor updates must be individually marked completed by calling [`ChainMonitor::channel_monitor_updated`]. pub fn list_pending_monitor_updates(&self) -> Vec<(ChannelId, Vec)> { - self.monitors - .read() - .unwrap() - .iter() + let monitors = self.monitors.read().unwrap().iter(); + monitors .map(|(channel_id, holder)| { (*channel_id, holder.pending_monitor_updates.lock().unwrap().clone()) }) @@ -1491,14 +1485,10 @@ mod tests { "Channel force-closed".to_string(), ) .unwrap(); - check_closed_event!( - &nodes[0], - 1, - ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, - false, - [nodes[2].node.get_our_node_id()], - 1000000 - ); + let closure_reason = + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; + let node_c_id = nodes[2].node.get_our_node_id(); + check_closed_event!(&nodes[0], 1, closure_reason, false, [node_c_id], 1000000); check_closed_broadcast(&nodes[0], 1, true); let close_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); assert_eq!(close_tx.len(), 1); @@ -1506,14 +1496,9 @@ mod tests { mine_transaction(&nodes[2], &close_tx[0]); check_added_monitors(&nodes[2], 1); check_closed_broadcast(&nodes[2], 1, true); - check_closed_event!( - &nodes[2], - 1, - ClosureReason::CommitmentTxConfirmed, - false, - [nodes[0].node.get_our_node_id()], - 1000000 - ); + let closure_reason = ClosureReason::CommitmentTxConfirmed; + let node_a_id = nodes[0].node.get_our_node_id(); + check_closed_event!(&nodes[2], 1, closure_reason, false, [node_a_id], 1000000); chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); From bcf4932c20265c074ccfcfdad3c62464eca4c637 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 13:43:49 +0200 Subject: [PATCH 06/26] Use new in chainmonitor tests --- lightning/src/util/persist.rs | 100 +++++++++++++++++++--------------- 1 file changed, 55 insertions(+), 45 deletions(-) diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 6f1f9d0862a..c69a541cd6e 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -1152,24 +1152,28 @@ mod tests { // Intentionally set this to a smaller value to test a different alignment. let persister_1_max_pending_updates = 3; let chanmon_cfgs = create_chanmon_cfgs(4); - let persister_0 = MonitorUpdatingPersister { - kv_store: &TestStore::new(false), - logger: &TestLogger::new(), - maximum_pending_updates: persister_0_max_pending_updates, - entropy_source: &chanmon_cfgs[0].keys_manager, - signer_provider: &chanmon_cfgs[0].keys_manager, - broadcaster: &chanmon_cfgs[0].tx_broadcaster, - fee_estimator: &chanmon_cfgs[0].fee_estimator, - }; - let persister_1 = MonitorUpdatingPersister { - kv_store: &TestStore::new(false), - logger: &TestLogger::new(), - maximum_pending_updates: persister_1_max_pending_updates, - entropy_source: &chanmon_cfgs[1].keys_manager, - signer_provider: &chanmon_cfgs[1].keys_manager, - broadcaster: &chanmon_cfgs[1].tx_broadcaster, - fee_estimator: &chanmon_cfgs[1].fee_estimator, - }; + let kv_store = &TestStore::new(false); + let logger = &TestLogger::new(); + let persister_0 = MonitorUpdatingPersister::new( + kv_store, + logger, + persister_0_max_pending_updates, + &chanmon_cfgs[0].keys_manager, + &chanmon_cfgs[0].keys_manager, + &chanmon_cfgs[0].tx_broadcaster, + &chanmon_cfgs[0].fee_estimator, + ); + let kv_store = &TestStore::new(false); + let logger = &TestLogger::new(); + let persister_1 = MonitorUpdatingPersister::new( + kv_store, + logger, + persister_1_max_pending_updates, + &chanmon_cfgs[1].keys_manager, + &chanmon_cfgs[1].keys_manager, + &chanmon_cfgs[1].tx_broadcaster, + &chanmon_cfgs[1].fee_estimator, + ); let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let chain_mon_0 = test_utils::TestChainMonitor::new( Some(&chanmon_cfgs[0].chain_source), @@ -1326,15 +1330,17 @@ mod tests { let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap(); let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0]; - let ro_persister = MonitorUpdatingPersister { - kv_store: &TestStore::new(true), - logger: &TestLogger::new(), - maximum_pending_updates: 11, - entropy_source: node_cfgs[0].keys_manager, - signer_provider: node_cfgs[0].keys_manager, - broadcaster: node_cfgs[0].tx_broadcaster, - fee_estimator: node_cfgs[0].fee_estimator, - }; + let kv_store = &TestStore::new(true); + let logger = &TestLogger::new(); + let ro_persister = MonitorUpdatingPersister::new( + kv_store, + logger, + 11, + node_cfgs[0].keys_manager, + node_cfgs[0].keys_manager, + node_cfgs[0].tx_broadcaster, + node_cfgs[0].fee_estimator, + ); let monitor_name = added_monitors[0].1.persistence_key(); match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1) { ChannelMonitorUpdateStatus::UnrecoverableError => { @@ -1372,24 +1378,28 @@ mod tests { fn clean_stale_updates_works() { let test_max_pending_updates = 7; let chanmon_cfgs = create_chanmon_cfgs(3); - let persister_0 = MonitorUpdatingPersister { - kv_store: &TestStore::new(false), - logger: &TestLogger::new(), - maximum_pending_updates: test_max_pending_updates, - entropy_source: &chanmon_cfgs[0].keys_manager, - signer_provider: &chanmon_cfgs[0].keys_manager, - broadcaster: &chanmon_cfgs[0].tx_broadcaster, - fee_estimator: &chanmon_cfgs[0].fee_estimator, - }; - let persister_1 = MonitorUpdatingPersister { - kv_store: &TestStore::new(false), - logger: &TestLogger::new(), - maximum_pending_updates: test_max_pending_updates, - entropy_source: &chanmon_cfgs[1].keys_manager, - signer_provider: &chanmon_cfgs[1].keys_manager, - broadcaster: &chanmon_cfgs[1].tx_broadcaster, - fee_estimator: &chanmon_cfgs[1].fee_estimator, - }; + let kv_store = &TestStore::new(false); + let logger = &TestLogger::new(); + let persister_0 = MonitorUpdatingPersister::new( + kv_store, + logger, + test_max_pending_updates, + &chanmon_cfgs[0].keys_manager, + &chanmon_cfgs[0].keys_manager, + &chanmon_cfgs[0].tx_broadcaster, + &chanmon_cfgs[0].fee_estimator, + ); + let kv_store = &TestStore::new(false); + let logger = &TestLogger::new(); + let persister_1 = MonitorUpdatingPersister::new( + kv_store, + logger, + test_max_pending_updates, + &chanmon_cfgs[1].keys_manager, + &chanmon_cfgs[1].keys_manager, + &chanmon_cfgs[1].tx_broadcaster, + &chanmon_cfgs[1].fee_estimator, + ); let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); let chain_mon_0 = test_utils::TestChainMonitor::new( Some(&chanmon_cfgs[0].chain_source), From d04fce5b265286698b004ebf3a45e2df42fafa57 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 11:31:26 +0200 Subject: [PATCH 07/26] Async KVStore --- lightning-background-processor/src/lib.rs | 53 +- lightning-persister/src/fs_store.rs | 22 +- lightning/src/chain/chainmonitor.rs | 394 +++++++++--- lightning/src/ln/peer_handler.rs | 10 +- lightning/src/sign/ecdsa.rs | 2 +- lightning/src/util/anchor_channel_reserves.rs | 6 +- lightning/src/util/async_poll.rs | 41 ++ lightning/src/util/mod.rs | 2 +- lightning/src/util/persist.rs | 608 +++++++++++++----- lightning/src/util/sweep.rs | 30 +- 10 files changed, 898 insertions(+), 270 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index dda54362e35..2e7554313a2 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -39,8 +39,11 @@ use lightning::sign::ChangeDestinationSource; use lightning::sign::ChangeDestinationSourceSync; use lightning::sign::EntropySource; use lightning::sign::OutputSpender; +use lightning::util::async_poll::FutureSpawner; use lightning::util::logger::Logger; -use lightning::util::persist::{KVStore, Persister}; +use lightning::util::persist::{ + KVStore, KVStoreSync, KVStoreSyncWrapper, Persister, PersisterSync, +}; use lightning::util::sweep::OutputSweeper; #[cfg(feature = "std")] use lightning::util::sweep::OutputSweeperSync; @@ -311,6 +314,15 @@ fn update_scorer<'a, S: 'static + Deref + Send + Sync, SC: 'a + Wri true } +macro_rules! maybe_await { + (true, $e:expr) => { + $e.await + }; + (false, $e:expr) => { + $e + }; +} + macro_rules! define_run_body { ( $persister: ident, $chain_monitor: ident, $process_chain_monitor_events: expr, @@ -319,7 +331,7 @@ macro_rules! define_run_body { $peer_manager: ident, $gossip_sync: ident, $process_sweeper: expr, $logger: ident, $scorer: ident, $loop_exit_check: expr, $await: expr, $get_timer: expr, - $timer_elapsed: expr, $check_slow_await: expr, $time_fetch: expr, + $timer_elapsed: expr, $check_slow_await: expr, $time_fetch: expr, $async: tt, ) => { { log_trace!($logger, "Calling ChannelManager's timer_tick_occurred on startup"); $channel_manager.get_cm().timer_tick_occurred(); @@ -375,7 +387,7 @@ macro_rules! define_run_body { if $channel_manager.get_cm().get_and_clear_needs_persistence() { log_trace!($logger, "Persisting ChannelManager..."); - $persister.persist_manager(&$channel_manager)?; + maybe_await!($async, $persister.persist_manager(&$channel_manager))?; log_trace!($logger, "Done persisting ChannelManager."); } if $timer_elapsed(&mut last_freshness_call, FRESHNESS_TIMER) { @@ -436,7 +448,7 @@ macro_rules! define_run_body { log_trace!($logger, "Persisting network graph."); } - if let Err(e) = $persister.persist_graph(network_graph) { + if let Err(e) = maybe_await!($async, $persister.persist_graph(network_graph)) { log_error!($logger, "Error: Failed to persist network graph, check your disk and permissions {}", e) } @@ -464,7 +476,7 @@ macro_rules! define_run_body { } else { log_trace!($logger, "Persisting scorer"); } - if let Err(e) = $persister.persist_scorer(&scorer) { + if let Err(e) = maybe_await!($async, $persister.persist_scorer(&scorer)) { log_error!($logger, "Error: Failed to persist scorer, check your disk and permissions {}", e) } } @@ -487,16 +499,16 @@ macro_rules! define_run_body { // After we exit, ensure we persist the ChannelManager one final time - this avoids // some races where users quit while channel updates were in-flight, with // ChannelMonitor update(s) persisted without a corresponding ChannelManager update. - $persister.persist_manager(&$channel_manager)?; + maybe_await!($async, $persister.persist_manager(&$channel_manager))?; // Persist Scorer on exit if let Some(ref scorer) = $scorer { - $persister.persist_scorer(&scorer)?; + maybe_await!($async, $persister.persist_scorer(&scorer))?; } // Persist NetworkGraph on exit if let Some(network_graph) = $gossip_sync.network_graph() { - $persister.persist_graph(network_graph)?; + maybe_await!($async, $persister.persist_graph(network_graph))?; } Ok(()) @@ -782,8 +794,11 @@ pub async fn process_events_async< EventHandler: Fn(Event) -> EventHandlerFuture, PS: 'static + Deref + Send, ES: 'static + Deref + Send, + FS: FutureSpawner, M: 'static - + Deref::Signer, CF, T, F, L, P, ES>> + + Deref< + Target = ChainMonitor<::Signer, CF, T, F, L, P, ES, FS>, + > + Send + Sync, CM: 'static + Deref, @@ -841,7 +856,7 @@ where if let Some(duration_since_epoch) = fetch_time() { if update_scorer(scorer, &event, duration_since_epoch) { log_trace!(logger, "Persisting scorer after update"); - if let Err(e) = persister.persist_scorer(&*scorer) { + if let Err(e) = persister.persist_scorer(&*scorer).await { log_error!(logger, "Error: Failed to persist scorer, check your disk and permissions {}", e); // We opt not to abort early on persistence failure here as persisting // the scorer is non-critical and we still hope that it will have @@ -919,6 +934,7 @@ where }, mobile_interruptable_platform, fetch_time, + true, ) } @@ -982,7 +998,16 @@ impl BackgroundProcessor { ES: 'static + Deref + Send, M: 'static + Deref< - Target = ChainMonitor<::Signer, CF, T, F, L, P, ES>, + Target = ChainMonitor< + ::Signer, + CF, + T, + F, + L, + P, + ES, + FS, + >, > + Send + Sync, @@ -998,6 +1023,7 @@ impl BackgroundProcessor { O: 'static + Deref, K: 'static + Deref, OS: 'static + Deref> + Send, + FS: FutureSpawner, >( persister: PS, event_handler: EH, chain_monitor: M, channel_manager: CM, onion_messenger: Option, gossip_sync: GossipSync, peer_manager: PM, @@ -1010,7 +1036,7 @@ impl BackgroundProcessor { F::Target: 'static + FeeEstimator, L::Target: 'static + Logger, P::Target: 'static + Persist<::Signer>, - PS::Target: 'static + Persister<'a, CM, L, S>, + PS::Target: 'static + PersisterSync<'a, CM, L, S>, ES::Target: 'static + EntropySource, CM::Target: AChannelManager, OM::Target: AOnionMessenger, @@ -1018,7 +1044,7 @@ impl BackgroundProcessor { LM::Target: ALiquidityManager, D::Target: ChangeDestinationSourceSync, O::Target: 'static + OutputSpender, - K::Target: 'static + KVStore, + K::Target: 'static + KVStoreSync, { let stop_thread = Arc::new(AtomicBool::new(false)); let stop_thread_clone = stop_thread.clone(); @@ -1098,6 +1124,7 @@ impl BackgroundProcessor { .expect("Time should be sometime after 1970"), ) }, + false, ) }); Self { stop_thread: stop_thread_clone, thread_handle: Some(handle) } diff --git a/lightning-persister/src/fs_store.rs b/lightning-persister/src/fs_store.rs index 850a0786671..919dc97f691 100644 --- a/lightning-persister/src/fs_store.rs +++ b/lightning-persister/src/fs_store.rs @@ -1,6 +1,7 @@ //! Objects related to [`FilesystemStore`] live here. use crate::utils::{check_namespace_key_validity, is_valid_kvstore_str}; +use lightning::util::async_poll::{AsyncResult, AsyncResultType}; use lightning::util::persist::{KVStore, MigratableKVStore}; use lightning::util::string::PrintableString; @@ -92,7 +93,7 @@ impl FilesystemStore { } } -impl KVStore for FilesystemStore { +impl FilesystemStore { fn read( &self, primary_namespace: &str, secondary_namespace: &str, key: &str, ) -> lightning::io::Result> { @@ -120,7 +121,7 @@ impl KVStore for FilesystemStore { fn write( &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], - ) -> lightning::io::Result<()> { + ) -> Result<(), lightning::io::Error> { check_namespace_key_validity(primary_namespace, secondary_namespace, Some(key), "write")?; let mut dest_file_path = self.get_dest_dir_path(primary_namespace, secondary_namespace)?; @@ -204,6 +205,23 @@ impl KVStore for FilesystemStore { res } +} + +impl KVStore for FilesystemStore { + fn read( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, + ) -> AsyncResultType<'static, Vec, lightning::io::Error> { + let res = self.read(primary_namespace, secondary_namespace, key); + Box::pin(async move { res }) + } + + fn write( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], + ) -> AsyncResultType<'static, (), lightning::io::Error> { + let res = self.write(primary_namespace, secondary_namespace, key, buf); + + Box::pin(async move { res }) + } fn remove( &self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool, diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 89d58c9e303..eb0d17946a7 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -25,6 +25,7 @@ use bitcoin::block::Header; use bitcoin::hash_types::{BlockHash, Txid}; +use types::features::{InitFeatures, NodeFeatures}; use crate::chain; use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; @@ -39,15 +40,17 @@ use crate::ln::channel_state::ChannelDetails; use crate::ln::msgs::{self, BaseMessageHandler, Init, MessageSendEvent}; use crate::ln::our_peer_storage::DecryptedOurPeerStorage; use crate::ln::types::ChannelId; -use crate::prelude::*; use crate::sign::ecdsa::EcdsaChannelSigner; use crate::sign::{EntropySource, PeerStorageKey}; -use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard}; -use crate::types::features::{InitFeatures, NodeFeatures}; +use crate::sync::Arc; +use crate::util::async_poll::{poll_or_spawn, AsyncResult, AsyncVoid, FutureSpawner}; use crate::util::errors::APIError; use crate::util::logger::{Logger, WithContext}; use crate::util::persist::MonitorName; use crate::util::wakers::{Future, Notifier}; + +use crate::prelude::*; +use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard}; use bitcoin::secp256k1::PublicKey; use core::ops::Deref; use core::sync::atomic::{AtomicUsize, Ordering}; @@ -128,7 +131,7 @@ pub trait Persist { /// [`Writeable::write`]: crate::util::ser::Writeable::write fn persist_new_channel( &self, monitor_name: MonitorName, monitor: &ChannelMonitor, - ) -> ChannelMonitorUpdateStatus; + ) -> AsyncResult<'static, ()>; /// Update one channel's data. The provided [`ChannelMonitor`] has already applied the given /// update. @@ -170,7 +173,7 @@ pub trait Persist { fn update_persisted_channel( &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, monitor: &ChannelMonitor, - ) -> ChannelMonitorUpdateStatus; + ) -> AsyncResult<'static, ()>; /// Prevents the channel monitor from being loaded on startup. /// /// Archiving the data in a backup location (rather than deleting it fully) is useful for @@ -182,7 +185,7 @@ pub trait Persist { /// the archive process. Additionally, because the archive operation could be retried on /// restart, this method must in that case be idempotent, ensuring it can handle scenarios where /// the monitor already exists in the archive. - fn archive_persisted_channel(&self, monitor_name: MonitorName); + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid; } struct MonitorHolder { @@ -250,6 +253,7 @@ pub struct ChainMonitor< L: Deref, P: Deref, ES: Deref, + FS: FutureSpawner, > where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -258,7 +262,7 @@ pub struct ChainMonitor< P::Target: Persist, ES::Target: EntropySource, { - monitors: RwLock>>, + monitors: Arc>>>, chain_source: Option, broadcaster: T, logger: L, @@ -267,29 +271,88 @@ pub struct ChainMonitor< entropy_source: ES, /// "User-provided" (ie persistence-completion/-failed) [`MonitorEvent`]s. These came directly /// from the user and not from a [`ChannelMonitor`]. - pending_monitor_events: Mutex, PublicKey)>>, + pending_monitor_events: Arc, PublicKey)>>>, /// The best block height seen, used as a proxy for the passage of time. highest_chain_height: AtomicUsize, /// A [`Notifier`] used to wake up the background processor in case we have any [`Event`]s for /// it to give to users (or [`MonitorEvent`]s for `ChannelManager` to process). - event_notifier: Notifier, + event_notifier: Arc, /// Messages to send to the peer. This is currently used to distribute PeerStorage to channel partners. pending_send_only_events: Mutex>, our_peerstorage_encryption_key: PeerStorageKey, + + future_spawner: Arc, } +/// A synchronous wrapper around [`ChainMonitor`]. +pub struct ChainMonitorSync< + ChannelSigner: EcdsaChannelSigner, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + FS: FutureSpawner, +>(ChainMonitor, ES, FS>) +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource; + impl< - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + FS: FutureSpawner, + > ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn new( + chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, + entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, future_spawner: FS, + ) -> Self { + let persister = PersistSyncWrapper(persister); + + Self(ChainMonitor::new( + chain_source, + broadcaster, + logger, + feeest, + persister, + entropy_source, + our_peerstorage_encryption_key, + future_spawner, + )) + } +} + +impl< + ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref, - > ChainMonitor + FS: FutureSpawner, + > ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -320,16 +383,18 @@ where for channel_id in channel_ids.iter() { let monitor_lock = self.monitors.read().unwrap(); if let Some(monitor_state) = monitor_lock.get(channel_id) { - let update_res = self.update_monitor_with_chain_data( - header, - best_height, - txdata, - &process, - channel_id, - &monitor_state, - channel_count, - ); - if update_res.is_err() { + if self + .update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ) + .is_err() + { // Take the monitors lock for writing so that we poison it and any future // operations going forward fail immediately. core::mem::drop(monitor_lock); @@ -344,16 +409,18 @@ where let monitor_states = self.monitors.write().unwrap(); for (channel_id, monitor_state) in monitor_states.iter() { if !channel_ids.contains(channel_id) { - let update_res = self.update_monitor_with_chain_data( - header, - best_height, - txdata, - &process, - channel_id, - &monitor_state, - channel_count, - ); - if update_res.is_err() { + if self + .update_monitor_with_chain_data( + header, + best_height, + txdata, + &process, + channel_id, + &monitor_state, + channel_count, + ) + .is_err() + { log_error!(self.logger, "{}", err_str); panic!("{}", err_str); } @@ -412,21 +479,33 @@ where // `ChannelMonitorUpdate` after a channel persist for a channel with the same // `latest_update_id`. let _pending_monitor_updates = monitor_state.pending_monitor_updates.lock().unwrap(); - match self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor) - { - ChannelMonitorUpdateStatus::Completed => log_trace!( - logger, - "Finished syncing Channel Monitor for channel {} for block-data", - log_funding_info!(monitor) - ), - ChannelMonitorUpdateStatus::InProgress => { - log_trace!( - logger, - "Channel Monitor sync for channel {} in progress.", - log_funding_info!(monitor) - ); + let max_update_id = _pending_monitor_updates.iter().copied().max().unwrap_or(0); + + let persist_res = + self.persister.update_persisted_channel(monitor.persistence_key(), None, monitor); + + let monitors = self.monitors.clone(); + let pending_monitor_updates_cb = self.pending_monitor_events.clone(); + let event_notifier = self.event_notifier.clone(); + let future_spawner = self.future_spawner.clone(); + let channel_id = *channel_id; + + match poll_or_spawn( + persist_res, + move || { + // TODO: Log error if the monitor is not persisted. + let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, + channel_id, max_update_id); }, - ChannelMonitorUpdateStatus::UnrecoverableError => { + future_spawner.deref(), + ) { + Ok(true) => { + // log + }, + Ok(false) => { + // log + }, + Err(_) => { return Err(()); }, } @@ -477,21 +556,22 @@ where /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager pub fn new( chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, - entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, + entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, future_spawner: FS, ) -> Self { Self { - monitors: RwLock::new(new_hash_map()), + monitors: Arc::new(RwLock::new(new_hash_map())), chain_source, broadcaster, logger, fee_estimator: feeest, persister, entropy_source, - pending_monitor_events: Mutex::new(Vec::new()), + pending_monitor_events: Arc::new(Mutex::new(Vec::new())), highest_chain_height: AtomicUsize::new(0), - event_notifier: Notifier::new(), + event_notifier: Arc::new(Notifier::new()), pending_send_only_events: Mutex::new(Vec::new()), our_peerstorage_encryption_key, + future_spawner: Arc::new(future_spawner), } } @@ -642,6 +722,49 @@ where Ok(()) } + fn channel_monitor_updated_internal( + monitors: &RwLock>>, + pending_monitor_events: &Mutex, PublicKey)>>, + event_notifier: &Notifier, channel_id: ChannelId, completed_update_id: u64, + ) -> Result<(), APIError> { + let monitors = monitors.read().unwrap(); + let monitor_data = if let Some(mon) = monitors.get(&channel_id) { + mon + } else { + return Err(APIError::APIMisuseError { + err: format!("No ChannelMonitor matching channel ID {} found", channel_id), + }); + }; + let mut pending_monitor_updates = monitor_data.pending_monitor_updates.lock().unwrap(); + pending_monitor_updates.retain(|update_id| *update_id != completed_update_id); + + // Note that we only check for pending non-chainsync monitor updates and we don't track monitor + // updates resulting from chainsync in `pending_monitor_updates`. + let monitor_is_pending_updates = monitor_data.has_pending_updates(&pending_monitor_updates); + + // TODO: Add logger + + if monitor_is_pending_updates { + // If there are still monitor updates pending, we cannot yet construct a + // Completed event. + return Ok(()); + } + let funding_txo = monitor_data.monitor.get_funding_txo(); + pending_monitor_events.lock().unwrap().push(( + funding_txo, + channel_id, + vec![MonitorEvent::Completed { + funding_txo, + channel_id, + monitor_update_id: monitor_data.monitor.get_latest_update_id(), + }], + monitor_data.monitor.get_counterparty_node_id(), + )); + + event_notifier.notify(); + Ok(()) + } + /// This wrapper avoids having to update some of our tests for now as they assume the direct /// chain::Watch API wherein we mark a monitor fully-updated by just calling /// channel_monitor_updated once with the highest ID. @@ -827,14 +950,15 @@ where } impl< - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref, - > BaseMessageHandler for ChainMonitor + FS: FutureSpawner, + > BaseMessageHandler for ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -866,14 +990,15 @@ where } impl< - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref, - > chain::Listen for ChainMonitor + FS: FutureSpawner, + > chain::Listen for ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -930,14 +1055,15 @@ where } impl< - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref, - > chain::Confirm for ChainMonitor + FS: FutureSpawner, + > chain::Confirm for ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -1024,14 +1150,15 @@ where } impl< - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref, ES: Deref, - > chain::Watch for ChainMonitor + FS: FutureSpawner + Clone, + > chain::Watch for ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -1056,23 +1183,40 @@ where let update_id = monitor.get_latest_update_id(); let mut pending_monitor_updates = Vec::new(); let persist_res = self.persister.persist_new_channel(monitor.persistence_key(), &monitor); - match persist_res { - ChannelMonitorUpdateStatus::InProgress => { + + let update_status; + let monitors = self.monitors.clone(); + let pending_monitor_updates_cb = self.pending_monitor_events.clone(); + let event_notifier = self.event_notifier.clone(); + let future_spawner = self.future_spawner.clone(); + + match poll_or_spawn( + persist_res, + move || { + // TODO: Log error if the monitor is not persisted. + let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, + channel_id, update_id); + }, + future_spawner.deref(), + ) { + Ok(true) => { log_info!( logger, - "Persistence of new ChannelMonitor for channel {} in progress", + "Persistence of new ChannelMonitor for channel {} completed", log_funding_info!(monitor) ); - pending_monitor_updates.push(update_id); + update_status = ChannelMonitorUpdateStatus::Completed; }, - ChannelMonitorUpdateStatus::Completed => { + Ok(false) => { log_info!( logger, - "Persistence of new ChannelMonitor for channel {} completed", + "Persistence of new ChannelMonitor for channel {} in progress", log_funding_info!(monitor) ); + pending_monitor_updates.push(update_id); + update_status = ChannelMonitorUpdateStatus::InProgress; }, - ChannelMonitorUpdateStatus::UnrecoverableError => { + Err(_) => { let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down."; log_error!(logger, "{}", err_str); panic!("{}", err_str); @@ -1085,7 +1229,7 @@ where monitor, pending_monitor_updates: Mutex::new(pending_monitor_updates), }); - Ok(persist_res) + Ok(update_status) } fn update_channel( @@ -1151,28 +1295,45 @@ where monitor, ) }; - match persist_res { - ChannelMonitorUpdateStatus::InProgress => { - pending_monitor_updates.push(update_id); - log_debug!(logger, - "Persistence of ChannelMonitorUpdate id {:?} for channel {} in progress", - update_id, - log_funding_info!(monitor) - ); + + let monitors = self.monitors.clone(); + let pending_monitor_updates_cb = self.pending_monitor_events.clone(); + let event_notifier = self.event_notifier.clone(); + let future_spawner = self.future_spawner.clone(); + + let update_status; + match poll_or_spawn( + persist_res, + move || { + // TODO: Log error if the monitor is not persisted. + let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, + channel_id, update_id); }, - ChannelMonitorUpdateStatus::Completed => { + future_spawner.deref(), + ) { + Ok(true) => { log_debug!( logger, "Persistence of ChannelMonitorUpdate id {:?} for channel {} completed", update_id, log_funding_info!(monitor) ); + update_status = ChannelMonitorUpdateStatus::Completed; + }, + Ok(false) => { + log_debug!(logger, + "Persistence of ChannelMonitorUpdate id {:?} for channel {} in progress", + update_id, + log_funding_info!(monitor) + ); + pending_monitor_updates.push(update_id); + update_status = ChannelMonitorUpdateStatus::InProgress; }, - ChannelMonitorUpdateStatus::UnrecoverableError => { + Err(_) => { // Take the monitors lock for writing so that we poison it and any future // operations going forward fail immediately. core::mem::drop(pending_monitor_updates); - core::mem::drop(monitors); + // core::mem::drop(monitors); let _poison = self.monitors.write().unwrap(); let err_str = "ChannelMonitor[Update] persistence failed unrecoverably. This indicates we cannot continue normal operation and must shut down."; log_error!(logger, "{}", err_str); @@ -1182,7 +1343,7 @@ where if update_res.is_err() { ChannelMonitorUpdateStatus::InProgress } else { - persist_res + update_status } }, } @@ -1218,7 +1379,8 @@ impl< L: Deref, P: Deref, ES: Deref, - > events::EventsProvider for ChainMonitor + FS: FutureSpawner, + > events::EventsProvider for ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -1255,6 +1417,59 @@ where } } +/// A synchronous version of [`Persist`]. +pub trait PersistSync { + /// A synchronous version of [`Persist::persist_new_channel`]. + fn persist_new_channel( + &self, monitor_name: MonitorName, monitor: &ChannelMonitor, + ) -> Result<(), ()>; + + /// A synchronous version of [`Persist::update_persisted_channel`]. + fn update_persisted_channel( + &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, + monitor: &ChannelMonitor, + ) -> Result<(), ()>; + + /// A synchronous version of [`Persist::archive_persisted_channel`]. + fn archive_persisted_channel(&self, monitor_name: MonitorName); +} + +struct PersistSyncWrapper(P); + +impl Deref for PersistSyncWrapper { + type Target = Self; + fn deref(&self) -> &Self { + self + } +} + +impl Persist for PersistSyncWrapper

+where + P::Target: PersistSync, +{ + fn persist_new_channel( + &self, monitor_name: MonitorName, monitor: &ChannelMonitor, + ) -> AsyncResult<'static, ()> { + let res = self.0.persist_new_channel(monitor_name, monitor); + + Box::pin(async move { res }) + } + + fn update_persisted_channel( + &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, + monitor: &ChannelMonitor, + ) -> AsyncResult<'static, ()> { + let res = self.0.update_persisted_channel(monitor_name, monitor_update, monitor); + Box::pin(async move { res }) + } + + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { + self.0.archive_persisted_channel(monitor_name); + + Box::pin(async move {}) + } +} + #[cfg(test)] mod tests { use crate::chain::channelmonitor::ANTI_REORG_DELAY; @@ -1485,10 +1700,14 @@ mod tests { "Channel force-closed".to_string(), ) .unwrap(); - let closure_reason = - ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - let node_c_id = nodes[2].node.get_our_node_id(); - check_closed_event!(&nodes[0], 1, closure_reason, false, [node_c_id], 1000000); + check_closed_event!( + &nodes[0], + 1, + ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, + false, + [nodes[2].node.get_our_node_id()], + 1000000 + ); check_closed_broadcast(&nodes[0], 1, true); let close_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); assert_eq!(close_tx.len(), 1); @@ -1496,9 +1715,14 @@ mod tests { mine_transaction(&nodes[2], &close_tx[0]); check_added_monitors(&nodes[2], 1); check_closed_broadcast(&nodes[2], 1, true); - let closure_reason = ClosureReason::CommitmentTxConfirmed; - let node_a_id = nodes[0].node.get_our_node_id(); - check_closed_event!(&nodes[2], 1, closure_reason, false, [node_a_id], 1000000); + check_closed_event!( + &nodes[2], + 1, + ClosureReason::CommitmentTxConfirmed, + false, + [nodes[0].node.get_our_node_id()], + 1000000 + ); chanmon_cfgs[0].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); chanmon_cfgs[2].persister.chain_sync_monitor_persistences.lock().unwrap().clear(); diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index a989d172687..b7c6f01bd6c 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -449,7 +449,7 @@ pub struct MessageHandler = PeerManager< +pub type SimpleArcPeerManager = PeerManager< SD, Arc>, Arc>>, C, Arc>>, @@ -748,7 +748,7 @@ pub type SimpleArcPeerManager = PeerManager< Arc, IgnoringMessageHandler, Arc, - Arc, Arc, Arc, Arc, Arc, Arc>>, + Arc, Arc, Arc, Arc, Arc, Arc, FS>>, >; /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference @@ -761,7 +761,7 @@ pub type SimpleArcPeerManager = PeerManager< /// This is not exported to bindings users as type aliases aren't supported in most languages. #[cfg(not(c_bindings))] pub type SimpleRefPeerManager< - 'a, 'b, 'c, 'd, 'e, 'f, 'logger, 'h, 'i, 'j, 'graph, 'k, 'mr, SD, M, T, F, C, L + 'a, 'b, 'c, 'd, 'e, 'f, 'logger, 'h, 'i, 'j, 'graph, 'k, 'mr, SD, M, T, F, C, L, FS > = PeerManager< SD, &'j SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'graph, 'logger, 'i, 'mr, M, T, F, L>, @@ -770,7 +770,7 @@ pub type SimpleRefPeerManager< &'logger L, IgnoringMessageHandler, &'c KeysManager, - &'j ChainMonitor<&'a M, C, &'b T, &'c F, &'logger L, &'c KeysManager, &'c KeysManager>, + &'j ChainMonitor<&'a M, C, &'b T, &'c F, &'logger L, &'c KeysManager, &'c KeysManager, FS>, >; diff --git a/lightning/src/sign/ecdsa.rs b/lightning/src/sign/ecdsa.rs index f9c330bbc4c..52c388bd511 100644 --- a/lightning/src/sign/ecdsa.rs +++ b/lightning/src/sign/ecdsa.rs @@ -33,7 +33,7 @@ use crate::sign::{ChannelSigner, ChannelTransactionParameters, HTLCDescriptor}; /// /// [`ChannelManager::signer_unblocked`]: crate::ln::channelmanager::ChannelManager::signer_unblocked /// [`ChainMonitor::signer_unblocked`]: crate::chain::chainmonitor::ChainMonitor::signer_unblocked -pub trait EcdsaChannelSigner: ChannelSigner { +pub trait EcdsaChannelSigner: ChannelSigner + Send { /// Create a signature for a counterparty's commitment transaction and associated HTLC transactions. /// /// Policy checks should be implemented in this function, including checking the amount diff --git a/lightning/src/util/anchor_channel_reserves.rs b/lightning/src/util/anchor_channel_reserves.rs index ebae770fb8a..7bc34e01108 100644 --- a/lightning/src/util/anchor_channel_reserves.rs +++ b/lightning/src/util/anchor_channel_reserves.rs @@ -39,6 +39,8 @@ use bitcoin::Weight; use core::cmp::min; use core::ops::Deref; +use super::async_poll::FutureSpawner; + // Transaction weights based on: // https://github.com/lightning/bolts/blob/master/03-transactions.md#appendix-a-expected-weights const COMMITMENT_TRANSACTION_BASE_WEIGHT: u64 = 900 + 224; @@ -271,13 +273,14 @@ pub fn get_supportable_anchor_channels( /// [Event::OpenChannelRequest]: crate::events::Event::OpenChannelRequest pub fn can_support_additional_anchor_channel< AChannelManagerRef: Deref, - ChannelSigner: EcdsaChannelSigner, + ChannelSigner: EcdsaChannelSigner + Send + Sync + 'static, FilterRef: Deref, BroadcasterRef: Deref, EstimatorRef: Deref, LoggerRef: Deref, PersistRef: Deref, EntropySourceRef: Deref, + FS: FutureSpawner, ChainMonitorRef: Deref< Target = ChainMonitor< ChannelSigner, @@ -287,6 +290,7 @@ pub fn can_support_additional_anchor_channel< LoggerRef, PersistRef, EntropySourceRef, + FS, >, >, >( diff --git a/lightning/src/util/async_poll.rs b/lightning/src/util/async_poll.rs index 93be60adfd0..f98b5c28c65 100644 --- a/lightning/src/util/async_poll.rs +++ b/lightning/src/util/async_poll.rs @@ -96,6 +96,9 @@ pub(crate) fn dummy_waker() -> Waker { unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE)) } } +/// A type alias for a future that returns nothing. +pub type AsyncVoid = Pin + 'static + Send>>; + /// A type alias for a future that returns a result of type T. #[cfg(feature = "std")] pub type AsyncResult<'a, T> = Pin> + 'a + Send>>; @@ -118,3 +121,41 @@ pub use core::marker::Send as MaybeSend; pub trait MaybeSend {} #[cfg(not(feature = "std"))] impl MaybeSend for T where T: ?Sized {} + +/// A type alias for a future that returns a result of type T with error type V. +pub type AsyncResultType<'a, T, V> = Pin> + 'a + Send>>; + +/// A type alias for a future that returns a result of type T. +pub trait FutureSpawner: Send + Sync + 'static { + /// Spawns a future on a runtime. + fn spawn + Send + 'static>(&self, future: T); +} + +/// Polls a future and either returns true if it is ready or spawns it on the tokio runtime if it is not. +pub fn poll_or_spawn( + mut fut: Pin>, callback: C, future_spawner: &S, +) -> Result +where + F: Future> + Send + 'static + ?Sized, + C: FnOnce() + Send + 'static, + S: FutureSpawner, +{ + let waker = dummy_waker(); + let mut cx = Context::from_waker(&waker); + + match fut.as_mut().poll(&mut cx) { + Poll::Ready(Ok(())) => Ok(true), + Poll::Ready(Err(_)) => Err(()), + Poll::Pending => { + println!("Future not ready, using tokio runtime"); + + let callback = Box::new(callback); + future_spawner.spawn(async move { + fut.await; + callback(); + }); + + Ok(false) + }, + } +} diff --git a/lightning/src/util/mod.rs b/lightning/src/util/mod.rs index e4b8b0b4429..9f685785c94 100644 --- a/lightning/src/util/mod.rs +++ b/lightning/src/util/mod.rs @@ -32,7 +32,7 @@ pub mod ser; pub mod sweep; pub mod wakers; -pub(crate) mod async_poll; +pub mod async_poll; pub(crate) mod atomic_counter; pub(crate) mod byte_utils; pub mod hash_tables; diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index c69a541cd6e..51f769c68f7 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -19,7 +19,6 @@ use core::str::FromStr; use crate::prelude::*; use crate::{io, log_error}; -use crate::chain; use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use crate::chain::chainmonitor::Persist; use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate}; @@ -29,9 +28,12 @@ use crate::ln::types::ChannelId; use crate::routing::gossip::NetworkGraph; use crate::routing::scoring::WriteableScore; use crate::sign::{ecdsa::EcdsaChannelSigner, EntropySource, SignerProvider}; +use crate::sync::Arc; use crate::util::logger::Logger; use crate::util::ser::{Readable, ReadableArgs, Writeable}; +use super::async_poll::{AsyncResult, AsyncResultType, AsyncVoid}; + /// The alphabet of characters allowed for namespaces and keys. pub const KVSTORE_NAMESPACE_KEY_ALPHABET: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-"; @@ -120,6 +122,57 @@ pub const MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL: &[u8] = &[0xFF; 2]; /// interface can use a concatenation of `[{primary_namespace}/[{secondary_namespace}/]]{key}` to /// recover a `key` compatible with the data model previously assumed by `KVStorePersister::persist`. pub trait KVStore { + /// Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and + /// `key`. + /// + /// Returns an [`ErrorKind::NotFound`] if the given `key` could not be found in the given + /// `primary_namespace` and `secondary_namespace`. + /// + /// [`ErrorKind::NotFound`]: io::ErrorKind::NotFound + fn read( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, + ) -> AsyncResultType<'static, Vec, io::Error>; + /// Persists the given data under the given `key`. + /// + /// Will create the given `primary_namespace` and `secondary_namespace` if not already present + /// in the store. + fn write( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], + ) -> AsyncResultType<'static, (), io::Error>; + /// Removes any data that had previously been persisted under the given `key`. + /// + /// If the `lazy` flag is set to `true`, the backend implementation might choose to lazily + /// remove the given `key` at some point in time after the method returns, e.g., as part of an + /// eventual batch deletion of multiple keys. As a consequence, subsequent calls to + /// [`KVStore::list`] might include the removed key until the changes are actually persisted. + /// + /// Note that while setting the `lazy` flag reduces the I/O burden of multiple subsequent + /// `remove` calls, it also influences the atomicity guarantees as lazy `remove`s could + /// potentially get lost on crash after the method returns. Therefore, this flag should only be + /// set for `remove` operations that can be safely replayed at a later time. + /// + /// Returns successfully if no data will be stored for the given `primary_namespace`, + /// `secondary_namespace`, and `key`, independently of whether it was present before its + /// invokation or not. + /// + // TODO: MAKE ASYNC + fn remove( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool, + ) -> Result<(), io::Error>; + /// Returns a list of keys that are stored under the given `secondary_namespace` in + /// `primary_namespace`. + /// + /// Returns the keys in arbitrary order, so users requiring a particular order need to sort the + /// returned keys. Returns an empty list if `primary_namespace` or `secondary_namespace` is unknown. + /// + // TODO: MAKE ASYNC + fn list( + &self, primary_namespace: &str, secondary_namespace: &str, + ) -> Result, io::Error>; +} + +/// Provides a synchronous interface to the [`KVStore`] trait. +pub trait KVStoreSync { /// Returns the data stored for the given `primary_namespace`, `secondary_namespace`, and /// `key`. /// @@ -165,6 +218,58 @@ pub trait KVStore { ) -> Result, io::Error>; } +/// A wrapper around a [`KVStoreSync`] that implements the [`KVStore`] trait. +pub struct KVStoreSyncWrapper(K) +where + K::Target: KVStoreSync; + +impl KVStoreSyncWrapper +where + K::Target: KVStoreSync, +{ + /// Constructs a new [`KVStoreSyncWrapper`]. + pub fn new(kv_store: K) -> Self { + Self(kv_store) + } +} + +impl KVStore for KVStoreSyncWrapper +where + K::Target: KVStoreSync, +{ + fn read( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, + ) -> AsyncResultType<'static, Vec, io::Error> { + let res = self.0.read(primary_namespace, secondary_namespace, key); + + Box::pin(async move { res }) + } + + fn write( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, buf: &[u8], + ) -> AsyncResultType<'static, (), io::Error> { + let res = self.0.write(primary_namespace, secondary_namespace, key, buf); + + Box::pin(async move { res }) + } + + fn remove( + &self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool, + ) -> Result<(), io::Error> { + let res = self.0.remove(primary_namespace, secondary_namespace, key, lazy); + + return res; + } + + fn list( + &self, primary_namespace: &str, secondary_namespace: &str, + ) -> Result, io::Error> { + let res = self.0.list(primary_namespace, secondary_namespace); + + return res; + } +} + /// Provides additional interface methods that are required for [`KVStore`]-to-[`KVStore`] /// data migration. pub trait MigratableKVStore: KVStore { @@ -186,14 +291,21 @@ pub trait MigratableKVStore: KVStore { /// /// Will abort and return an error if any IO operation fails. Note that in this case the /// `target_store` might get left in an intermediate state. -pub fn migrate_kv_store_data( +pub async fn migrate_kv_store_data( source_store: &mut S, target_store: &mut T, ) -> Result<(), io::Error> { let keys_to_migrate = source_store.list_all_keys()?; for (primary_namespace, secondary_namespace, key) in &keys_to_migrate { - let data = source_store.read(primary_namespace, secondary_namespace, key)?; - target_store.write(primary_namespace, secondary_namespace, key, &data)?; + let data = source_store.read(primary_namespace, secondary_namespace, key).await?; + target_store.write(primary_namespace, secondary_namespace, key, &data).await.map_err( + |_| { + io::Error::new( + io::ErrorKind::Other, + "Failed to write data to target store during migration", + ) + }, + )?; } Ok(()) @@ -203,6 +315,73 @@ pub fn migrate_kv_store_data( /// /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager pub trait Persister<'a, CM: Deref, L: Deref, S: Deref> +where + CM::Target: 'static + AChannelManager, + L::Target: 'static + Logger, + S::Target: WriteableScore<'a>, +{ + /// Persist the given ['ChannelManager'] to disk, returning an error if persistence failed. + /// + /// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager + fn persist_manager(&self, channel_manager: &CM) -> AsyncResultType<'static, (), io::Error>; + + /// Persist the given [`NetworkGraph`] to disk, returning an error if persistence failed. + fn persist_graph( + &self, network_graph: &NetworkGraph, + ) -> AsyncResultType<'static, (), io::Error>; + + /// Persist the given [`WriteableScore`] to disk, returning an error if persistence failed. + fn persist_scorer(&self, scorer: &S) -> AsyncResultType<'static, (), io::Error>; +} + +impl<'a, A: KVStore + ?Sized + Send + Sync + 'static, CM: Deref, L: Deref, S: Deref> + Persister<'a, CM, L, S> for Arc +where + CM::Target: 'static + AChannelManager, + L::Target: 'static + Logger, + S::Target: WriteableScore<'a>, +{ + fn persist_manager(&self, channel_manager: &CM) -> AsyncResultType<'static, (), io::Error> { + let encoded = channel_manager.get_cm().encode(); + let kv_store = self.clone(); + + Box::pin(async move { + kv_store + .write( + CHANNEL_MANAGER_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MANAGER_PERSISTENCE_SECONDARY_NAMESPACE, + CHANNEL_MANAGER_PERSISTENCE_KEY, + &encoded, + ) + .await + }) + } + + fn persist_graph( + &self, network_graph: &NetworkGraph, + ) -> AsyncResultType<'static, (), io::Error> { + self.write( + NETWORK_GRAPH_PERSISTENCE_PRIMARY_NAMESPACE, + NETWORK_GRAPH_PERSISTENCE_SECONDARY_NAMESPACE, + NETWORK_GRAPH_PERSISTENCE_KEY, + &network_graph.encode(), + ) + } + + fn persist_scorer(&self, scorer: &S) -> AsyncResultType<'static, (), io::Error> { + self.write( + SCORER_PERSISTENCE_PRIMARY_NAMESPACE, + SCORER_PERSISTENCE_SECONDARY_NAMESPACE, + SCORER_PERSISTENCE_KEY, + &scorer.encode(), + ) + } +} + +/// Trait that handles persisting a [`ChannelManager`], [`NetworkGraph`], and [`WriteableScore`] to disk. +/// +/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager +pub trait PersisterSync<'a, CM: Deref, L: Deref, S: Deref> where CM::Target: 'static + AChannelManager, L::Target: 'static + Logger, @@ -220,7 +399,7 @@ where fn persist_scorer(&self, scorer: &S) -> Result<(), io::Error>; } -impl<'a, A: KVStore + ?Sized, CM: Deref, L: Deref, S: Deref> Persister<'a, CM, L, S> for A +impl<'a, A: KVStoreSync + ?Sized, CM: Deref, L: Deref, S: Deref> PersisterSync<'a, CM, L, S> for A where CM::Target: 'static + AChannelManager, L::Target: 'static + Logger, @@ -254,7 +433,9 @@ where } } -impl Persist for K { +impl + Persist for Arc +{ // TODO: We really need a way for the persister to inform the user that its time to crash/shut // down once these start returning failure. // Then we should return InProgress rather than UnrecoverableError, implying we should probably @@ -262,63 +443,83 @@ impl Persist, - ) -> chain::ChannelMonitorUpdateStatus { - match self.write( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - &monitor_name.to_string(), - &monitor.encode(), - ) { - Ok(()) => chain::ChannelMonitorUpdateStatus::Completed, - Err(_) => chain::ChannelMonitorUpdateStatus::UnrecoverableError, - } + ) -> AsyncResult<'static, ()> { + let encoded = monitor.encode(); + let kv_store = self.clone(); + + Box::pin(async move { + kv_store + .write( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + &monitor_name.to_string(), + &encoded, + ) + .await + .map_err(|_| ()) + }) } fn update_persisted_channel( &self, monitor_name: MonitorName, _update: Option<&ChannelMonitorUpdate>, monitor: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { - match self.write( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - &monitor_name.to_string(), - &monitor.encode(), - ) { - Ok(()) => chain::ChannelMonitorUpdateStatus::Completed, - Err(_) => chain::ChannelMonitorUpdateStatus::UnrecoverableError, - } + ) -> AsyncResult<'static, ()> { + let encoded = monitor.encode(); + let kv_store = self.clone(); + + Box::pin(async move { + kv_store + .write( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + &monitor_name.to_string(), + &encoded, + ) + .await + .map_err(|_| ()) + }) } - fn archive_persisted_channel(&self, monitor_name: MonitorName) { - let monitor_key = monitor_name.to_string(); - let monitor = match self.read( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - ) { - Ok(monitor) => monitor, - Err(_) => return, - }; - match self.write( - ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - &monitor, - ) { - Ok(()) => {}, - Err(_e) => return, - }; - let _ = self.remove( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - true, - ); + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { + let kv_store = self.clone(); + + Box::pin(async move { + let monitor_key = monitor_name.to_string(); + let monitor = match kv_store + .read( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key.as_str(), + ) + .await + { + Ok(monitor) => monitor, + Err(_) => return, + }; + match kv_store + .write( + ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key.as_str(), + &monitor, + ) + .await + { + Ok(()) => {}, + Err(_e) => return, + }; + let _ = kv_store.remove( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key.as_str(), + true, + ); + }) } } /// Read previously persisted [`ChannelMonitor`]s from the store. -pub fn read_channel_monitors( +pub async fn read_channel_monitors( kv_store: K, entropy_source: ES, signer_provider: SP, ) -> Result::EcdsaSigner>)>, io::Error> where @@ -333,11 +534,15 @@ where CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, )? { match <(BlockHash, ChannelMonitor<::EcdsaSigner>)>::read( - &mut io::Cursor::new(kv_store.read( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - &stored_key, - )?), + &mut io::Cursor::new( + kv_store + .read( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + &stored_key, + ) + .await?, + ), (&*entropy_source, &*signer_provider), ) { Ok((block_hash, channel_monitor)) => { @@ -447,6 +652,18 @@ where /// would like to get rid of them, consider using the /// [`MonitorUpdatingPersister::cleanup_stale_updates`] function. pub struct MonitorUpdatingPersister +where + K::Target: KVStore, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + state: Arc>, +} + +struct MonitorUpdatingPersisterState where K::Target: KVStore, L::Target: Logger, @@ -466,7 +683,7 @@ where #[allow(dead_code)] impl - MonitorUpdatingPersister + MonitorUpdatingPersisterState where K::Target: KVStore, L::Target: Logger, @@ -495,7 +712,7 @@ where kv_store: K, logger: L, maximum_pending_updates: u64, entropy_source: ES, signer_provider: SP, broadcaster: BI, fee_estimator: FE, ) -> Self { - MonitorUpdatingPersister { + MonitorUpdatingPersisterState { kv_store, logger, maximum_pending_updates, @@ -511,7 +728,7 @@ where /// It is extremely important that your [`KVStore::read`] implementation uses the /// [`io::ErrorKind::NotFound`] variant correctly. For more information, please see the /// documentation for [`MonitorUpdatingPersister`]. - pub fn read_all_channel_monitors_with_updates( + pub async fn read_all_channel_monitors_with_updates( &self, ) -> Result< Vec<(BlockHash, ChannelMonitor<::EcdsaSigner>)>, @@ -523,7 +740,7 @@ where )?; let mut res = Vec::with_capacity(monitor_list.len()); for monitor_key in monitor_list { - res.push(self.read_channel_monitor_with_updates(monitor_key.as_str())?) + res.push(self.read_channel_monitor_with_updates(monitor_key.as_str()).await?) } Ok(res) } @@ -547,12 +764,12 @@ where /// /// Loading a large number of monitors will be faster if done in parallel. You can use this /// function to accomplish this. Take care to limit the number of parallel readers. - pub fn read_channel_monitor_with_updates( + pub async fn read_channel_monitor_with_updates( &self, monitor_key: &str, ) -> Result<(BlockHash, ChannelMonitor<::EcdsaSigner>), io::Error> { let monitor_name = MonitorName::from_str(monitor_key)?; - let (block_hash, monitor) = self.read_monitor(&monitor_name, monitor_key)?; + let (block_hash, monitor) = self.read_monitor(&monitor_name, monitor_key).await?; let mut current_update_id = monitor.get_latest_update_id(); loop { current_update_id = match current_update_id.checked_add(1) { @@ -560,7 +777,7 @@ where None => break, }; let update_name = UpdateName::from(current_update_id); - let update = match self.read_monitor_update(monitor_key, &update_name) { + let update = match self.read_monitor_update(monitor_key, &update_name).await { Ok(update) => update, Err(err) if err.kind() == io::ErrorKind::NotFound => { // We can't find any more updates, so we are done. @@ -586,15 +803,19 @@ where } /// Read a channel monitor. - fn read_monitor( + async fn read_monitor( &self, monitor_name: &MonitorName, monitor_key: &str, ) -> Result<(BlockHash, ChannelMonitor<::EcdsaSigner>), io::Error> { - let mut monitor_cursor = io::Cursor::new(self.kv_store.read( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key, - )?); + let mut monitor_cursor = io::Cursor::new( + self.kv_store + .read( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key, + ) + .await?, + ); // Discard the sentinel bytes if found. if monitor_cursor.get_ref().starts_with(MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL) { monitor_cursor.set_position(MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL.len() as u64); @@ -631,14 +852,17 @@ where } /// Read a channel monitor update. - fn read_monitor_update( + async fn read_monitor_update( &self, monitor_key: &str, update_name: &UpdateName, ) -> Result { - let update_bytes = self.kv_store.read( - CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, - monitor_key, - update_name.as_str(), - )?; + let update_bytes = self + .kv_store + .read( + CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, + monitor_key, + update_name.as_str(), + ) + .await?; ChannelMonitorUpdate::read(&mut io::Cursor::new(update_bytes)).map_err(|e| { log_error!( self.logger, @@ -658,14 +882,14 @@ where /// updates. The updates that have an `update_id` less than or equal to than the stored monitor /// are deleted. The deletion can either be lazy or non-lazy based on the `lazy` flag; this will /// be passed to [`KVStore::remove`]. - pub fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { + pub async fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { let monitor_keys = self.kv_store.list( CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, )?; for monitor_key in monitor_keys { let monitor_name = MonitorName::from_str(&monitor_key)?; - let (_, current_monitor) = self.read_monitor(&monitor_name, &monitor_key)?; + let (_, current_monitor) = self.read_monitor(&monitor_name, &monitor_key).await?; let updates = self .kv_store .list(CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, monitor_key.as_str())?; @@ -687,19 +911,19 @@ where } impl< - ChannelSigner: EcdsaChannelSigner, - K: Deref, - L: Deref, - ES: Deref, - SP: Deref, - BI: Deref, - FE: Deref, + ChannelSigner: EcdsaChannelSigner + Send + Sync, + K: Deref + Send + Sync + 'static, + L: Deref + Send + Sync + 'static, + ES: Deref + Send + Sync + 'static, + SP: Deref + Send + Sync + 'static, + BI: Deref + Send + Sync + 'static, + FE: Deref + Send + Sync + 'static, > Persist for MonitorUpdatingPersister where - K::Target: KVStore, + K::Target: KVStore + Sync, L::Target: Logger, ES::Target: EntropySource + Sized, - SP::Target: SignerProvider + Sized, + SP::Target: SignerProvider + Sync + Sized, BI::Target: BroadcasterInterface, FE::Target: FeeEstimator, { @@ -707,34 +931,119 @@ where /// parametrized [`KVStore`]. fn persist_new_channel( &self, monitor_name: MonitorName, monitor: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { - // Determine the proper key for this monitor - let monitor_key = monitor_name.to_string(); + ) -> AsyncResult<'static, ()> { + let state = self.state.clone(); + + let encoded_monitor = Self::encode_monitor(monitor); + + Box::pin(async move { state.persist_new_channel(monitor_name, &encoded_monitor).await }) + } + + /// Persists a channel update, writing only the update to the parameterized [`KVStore`] if possible. + /// + /// In some cases, this will forward to [`MonitorUpdatingPersister::persist_new_channel`]: + /// + /// - No full monitor is found in [`KVStore`] + /// - The number of pending updates exceeds `maximum_pending_updates` as given to [`Self::new`] + /// - LDK commands re-persisting the entire monitor through this function, specifically when + /// `update` is `None`. + /// - The update is at [`u64::MAX`], indicating an update generated by pre-0.1 LDK. + fn update_persisted_channel( + &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, + monitor: &ChannelMonitor, + ) -> AsyncResult<'static, ()> { + let state = self.state.clone(); + + let encoded_monitor = Self::encode_monitor(monitor); + let encoded_update = update.map(|update| (update.update_id, update.encode())); + let monitor_latest_update_id = monitor.get_latest_update_id(); + + Box::pin(async move { + state + .update_persisted_channel( + monitor_name, + encoded_update, + &encoded_monitor, + monitor_latest_update_id, + ) + .await + }) + } + + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { + let monitor_name = monitor_name; + let state = self.state.clone(); + + Box::pin(async move { + state.archive_persisted_channel(monitor_name).await; + }) + } +} + +impl< + K: Deref + Send + Sync + 'static, + L: Deref + Send + Sync + 'static, + ES: Deref + Send + Sync + 'static, + SP: Deref + Send + Sync + 'static, + BI: Deref + Send + Sync + 'static, + FE: Deref + Send + Sync + 'static, + > MonitorUpdatingPersister +where + K::Target: KVStore + Sync, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sync + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + fn encode_monitor( + monitor: &ChannelMonitor, + ) -> Vec { // Serialize and write the new monitor let mut monitor_bytes = Vec::with_capacity( MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL.len() + monitor.serialized_length(), ); monitor_bytes.extend_from_slice(MONITOR_UPDATING_PERSISTER_PREPEND_SENTINEL); monitor.write(&mut monitor_bytes).unwrap(); - match self.kv_store.write( - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - &monitor_bytes, - ) { - Ok(_) => chain::ChannelMonitorUpdateStatus::Completed, - Err(e) => { - log_error!( - self.logger, - "Failed to write ChannelMonitor {}/{}/{} reason: {}", - CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - e - ); - chain::ChannelMonitorUpdateStatus::UnrecoverableError - }, - } + + monitor_bytes + } +} + +impl< + K: Deref + Send + Sync + 'static, + L: Deref + Send + Sync + 'static, + ES: Deref + Send + Sync + 'static, + SP: Deref + Send + Sync + 'static, + BI: Deref + Send + Sync + 'static, + FE: Deref + Send + Sync + 'static, + > MonitorUpdatingPersisterState +where + K::Target: KVStore + Sync, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sync + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + /// Persists a new channel. This means writing the entire monitor to the + /// parametrized [`KVStore`]. + async fn persist_new_channel( + self: Arc, monitor_name: MonitorName, monitor_bytes: &[u8], + ) -> Result<(), ()> { + // Determine the proper key for this monitor + let monitor_key = monitor_name.to_string(); + + // Serialize and write the new monitor + self.kv_store + .write( + CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key.as_str(), + &monitor_bytes, + ) + .await + .map_err(|_| ()) } /// Persists a channel update, writing only the update to the parameterized [`KVStore`] if possible. @@ -746,53 +1055,44 @@ where /// - LDK commands re-persisting the entire monitor through this function, specifically when /// `update` is `None`. /// - The update is at [`u64::MAX`], indicating an update generated by pre-0.1 LDK. - fn update_persisted_channel( - &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, - monitor: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { + async fn update_persisted_channel( + self: Arc, monitor_name: MonitorName, update: Option<(u64, Vec)>, monitor: &[u8], + monitor_latest_update_id: u64, + ) -> Result<(), ()> { const LEGACY_CLOSED_CHANNEL_UPDATE_ID: u64 = u64::MAX; - if let Some(update) = update { - let persist_update = update.update_id != LEGACY_CLOSED_CHANNEL_UPDATE_ID - && update.update_id % self.maximum_pending_updates != 0; + if let Some((update_id, update)) = update { + let persist_update = update_id != LEGACY_CLOSED_CHANNEL_UPDATE_ID + && update_id % self.maximum_pending_updates != 0; if persist_update { let monitor_key = monitor_name.to_string(); - let update_name = UpdateName::from(update.update_id); - match self.kv_store.write( - CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, - monitor_key.as_str(), - update_name.as_str(), - &update.encode(), - ) { - Ok(()) => chain::ChannelMonitorUpdateStatus::Completed, - Err(e) => { - log_error!( - self.logger, - "Failed to write ChannelMonitorUpdate {}/{}/{} reason: {}", - CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, - monitor_key.as_str(), - update_name.as_str(), - e - ); - chain::ChannelMonitorUpdateStatus::UnrecoverableError - }, - } + let update_name = UpdateName::from(update_id); + self.kv_store + .write( + CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, + monitor_key.as_str(), + update_name.as_str(), + &update, + ) + .await + .map_err(|_| ()) } else { // In case of channel-close monitor update, we need to read old monitor before persisting // the new one in order to determine the cleanup range. - let maybe_old_monitor = match monitor.get_latest_update_id() { + let maybe_old_monitor = match monitor_latest_update_id { LEGACY_CLOSED_CHANNEL_UPDATE_ID => { let monitor_key = monitor_name.to_string(); - self.read_monitor(&monitor_name, &monitor_key).ok() + self.read_monitor(&monitor_name, &monitor_key).await.ok() }, _ => None, }; // We could write this update, but it meets criteria of our design that calls for a full monitor write. - let monitor_update_status = self.persist_new_channel(monitor_name, monitor); + let monitor_update_status = + self.clone().persist_new_channel(monitor_name, &monitor).await; - if let chain::ChannelMonitorUpdateStatus::Completed = monitor_update_status { + if monitor_update_status.is_ok() { let channel_closed_legacy = - monitor.get_latest_update_id() == LEGACY_CLOSED_CHANNEL_UPDATE_ID; + monitor_latest_update_id == LEGACY_CLOSED_CHANNEL_UPDATE_ID; let cleanup_range = if channel_closed_legacy { // If there is an error while reading old monitor, we skip clean up. maybe_old_monitor.map(|(_, ref old_monitor)| { @@ -805,7 +1105,7 @@ where (start, end) }) } else { - let end = monitor.get_latest_update_id(); + let end = monitor_latest_update_id; let start = end.saturating_sub(self.maximum_pending_updates); Some((start, end)) }; @@ -819,22 +1119,26 @@ where } } else { // There is no update given, so we must persist a new monitor. - self.persist_new_channel(monitor_name, monitor) + self.persist_new_channel(monitor_name, &monitor).await } } - fn archive_persisted_channel(&self, monitor_name: MonitorName) { + async fn archive_persisted_channel(&self, monitor_name: MonitorName) { let monitor_key = monitor_name.to_string(); - let monitor = match self.read_channel_monitor_with_updates(&monitor_key) { + let monitor = match self.read_channel_monitor_with_updates(&monitor_key).await { Ok((_block_hash, monitor)) => monitor, Err(_) => return, }; - match self.kv_store.write( - ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, - ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, - monitor_key.as_str(), - &monitor.encode(), - ) { + match self + .kv_store + .write( + ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_PRIMARY_NAMESPACE, + ARCHIVED_CHANNEL_MONITOR_PERSISTENCE_SECONDARY_NAMESPACE, + monitor_key.as_str(), + &monitor.encode(), + ) + .await + { Ok(()) => {}, Err(_e) => return, }; @@ -848,7 +1152,7 @@ where } impl - MonitorUpdatingPersister + MonitorUpdatingPersisterState where ES::Target: EntropySource + Sized, K::Target: KVStore, diff --git a/lightning/src/util/sweep.rs b/lightning/src/util/sweep.rs index a52bdf884cc..7d4001d6db4 100644 --- a/lightning/src/util/sweep.rs +++ b/lightning/src/util/sweep.rs @@ -23,8 +23,8 @@ use crate::sync::Arc; use crate::sync::Mutex; use crate::util::logger::Logger; use crate::util::persist::{ - KVStore, OUTPUT_SWEEPER_PERSISTENCE_KEY, OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, - OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, + KVStore, KVStoreSync, KVStoreSyncWrapper, OUTPUT_SWEEPER_PERSISTENCE_KEY, + OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, }; use crate::util::ser::{Readable, ReadableArgs, Writeable}; use crate::{impl_writeable_tlv_based, log_debug, log_error}; @@ -640,14 +640,12 @@ where ) -> Pin> + 'a + Send>> { let encoded = &sweeper_state.encode(); - let result = self.kv_store.write( + self.kv_store.write( OUTPUT_SWEEPER_PERSISTENCE_PRIMARY_NAMESPACE, OUTPUT_SWEEPER_PERSISTENCE_SECONDARY_NAMESPACE, OUTPUT_SWEEPER_PERSISTENCE_KEY, encoded, - ); - - Box::pin(async move { result }) + ) } fn spend_outputs( @@ -953,11 +951,21 @@ where D::Target: ChangeDestinationSourceSync, E::Target: FeeEstimator, F::Target: Filter, - K::Target: KVStore, + K::Target: KVStoreSync, L::Target: Logger, O::Target: OutputSpender, { - sweeper: Arc>, E, F, K, L, O>>, + sweeper: Arc< + OutputSweeper< + B, + Arc>, + E, + F, + Arc>, + L, + O, + >, + >, } impl @@ -967,7 +975,7 @@ where D::Target: ChangeDestinationSourceSync, E::Target: FeeEstimator, F::Target: Filter, - K::Target: KVStore, + K::Target: KVStoreSync, L::Target: Logger, O::Target: OutputSpender, { @@ -979,6 +987,8 @@ where let change_destination_source = Arc::new(ChangeDestinationSourceSyncWrapper::new(change_destination_source)); + let kv_store = Arc::new(KVStoreSyncWrapper::new(kv_store)); + let sweeper = OutputSweeper::new( best_block, broadcaster, @@ -1043,7 +1053,7 @@ where D::Target: ChangeDestinationSourceSync, E::Target: FeeEstimator, F::Target: Filter + Sync + Send, - K::Target: KVStore, + K::Target: KVStoreSync, L::Target: Logger, O::Target: OutputSpender, { From 8cd1e99e6b0aeb92bef07405bd078625ce3bbee2 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 11:59:20 +0200 Subject: [PATCH 08/26] persistsync in bg processor syn --- lightning-background-processor/src/lib.rs | 10 +++---- lightning/src/chain/chainmonitor.rs | 36 +++++++++++++++++++++++ 2 files changed, 41 insertions(+), 5 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index 2e7554313a2..be553e7dccd 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -21,6 +21,8 @@ use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use lightning::chain::chainmonitor::{ChainMonitor, Persist}; #[cfg(feature = "std")] +use lightning::chain::chainmonitor::{ChainMonitorSync, PersistSync}; +#[cfg(feature = "std")] use lightning::events::EventHandler; #[cfg(feature = "std")] use lightning::events::EventsProvider; @@ -41,9 +43,7 @@ use lightning::sign::EntropySource; use lightning::sign::OutputSpender; use lightning::util::async_poll::FutureSpawner; use lightning::util::logger::Logger; -use lightning::util::persist::{ - KVStore, KVStoreSync, KVStoreSyncWrapper, Persister, PersisterSync, -}; +use lightning::util::persist::{KVStore, KVStoreSync, Persister, PersisterSync}; use lightning::util::sweep::OutputSweeper; #[cfg(feature = "std")] use lightning::util::sweep::OutputSweeperSync; @@ -998,7 +998,7 @@ impl BackgroundProcessor { ES: 'static + Deref + Send, M: 'static + Deref< - Target = ChainMonitor< + Target = ChainMonitorSync< ::Signer, CF, T, @@ -1035,7 +1035,7 @@ impl BackgroundProcessor { T::Target: 'static + BroadcasterInterface, F::Target: 'static + FeeEstimator, L::Target: 'static + Logger, - P::Target: 'static + Persist<::Signer>, + P::Target: 'static + PersistSync<::Signer>, PS::Target: 'static + PersisterSync<'a, CM, L, S>, ES::Target: 'static + EntropySource, CM::Target: AChannelManager, diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index eb0d17946a7..d46dd13106c 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -341,6 +341,42 @@ where future_spawner, )) } + + /// See [`ChainMonitor::rebroadcast_pending_claims`]. + pub fn rebroadcast_pending_claims(&self) { + self.0.rebroadcast_pending_claims(); + } + + /// See [`ChainMonitor::get_update_future`]. + pub fn get_update_future(&self) -> Future { + self.0.get_update_future() + } +} + +impl< + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + FS: FutureSpawner, + > events::EventsProvider for ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn process_pending_events(&self, handler: H) + where + H::Target: EventHandler, + { + self.0.process_pending_events(handler); + } } impl< From 3a0923b96a6fb5cd87eeb48299a42dcfda574521 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 12:05:10 +0200 Subject: [PATCH 09/26] fix archive_fully_resolved_channel_monitors --- lightning/src/chain/chainmonitor.rs | 31 ++++++++++++++++++----------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index d46dd13106c..2276b0e9288 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -921,7 +921,7 @@ where /// /// Depending on the implementation of [`Persist::archive_persisted_channel`] the monitor /// data could be moved to an archive location or removed entirely. - pub fn archive_fully_resolved_channel_monitors(&self) { + pub async fn archive_fully_resolved_channel_monitors(&self) { let mut have_monitors_to_prune = false; for monitor_holder in self.monitors.read().unwrap().values() { let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None); @@ -931,16 +931,20 @@ where have_monitors_to_prune = true; } if needs_persistence { - self.persister.update_persisted_channel( - monitor_holder.monitor.persistence_key(), - None, - &monitor_holder.monitor, - ); + self.persister + .update_persisted_channel( + monitor_holder.monitor.persistence_key(), + None, + &monitor_holder.monitor, + ) + .await; } } if have_monitors_to_prune { let mut monitors = self.monitors.write().unwrap(); - monitors.retain(|channel_id, monitor_holder| { + + let mut to_remove = Vec::new(); + for (channel_id, monitor_holder) in monitors.iter() { let logger = WithChannelMonitor::from(&self.logger, &monitor_holder.monitor, None); let (is_fully_resolved, _) = monitor_holder.monitor.check_and_update_full_resolution_status(&logger); @@ -951,12 +955,15 @@ where channel_id ); self.persister - .archive_persisted_channel(monitor_holder.monitor.persistence_key()); - false - } else { - true + .archive_persisted_channel(monitor_holder.monitor.persistence_key()) + .await; + to_remove.push(channel_id.clone()); } - }); + } + + for channel_id in to_remove { + monitors.remove(&channel_id); + } } } From 969574f39783fb560f7e65ef5d203500c49799a7 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 10:28:17 +0200 Subject: [PATCH 10/26] all --- lightning/src/util/sweep.rs | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/lightning/src/util/sweep.rs b/lightning/src/util/sweep.rs index 7d4001d6db4..34f47da0927 100644 --- a/lightning/src/util/sweep.rs +++ b/lightning/src/util/sweep.rs @@ -1041,7 +1041,17 @@ where #[cfg(any(test, feature = "_test_utils"))] pub fn sweeper_async( &self, - ) -> Arc>, E, F, K, L, O>> { + ) -> Arc< + OutputSweeper< + B, + Arc>, + E, + F, + Arc>, + L, + O, + >, + > { self.sweeper.clone() } } From 88787dc8a02821a923add43bceba85fcff22b7fe Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 13:37:07 +0200 Subject: [PATCH 11/26] wip --- lightning/src/chain/chainmonitor.rs | 2 +- lightning/src/util/persist.rs | 90 +++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+), 1 deletion(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 2276b0e9288..14a544fabbc 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -375,7 +375,7 @@ where where H::Target: EventHandler, { - self.0.process_pending_events(handler); + self.0.process_pending_events(handler) } } diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 51f769c68f7..315f2a35d31 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -233,6 +233,16 @@ where } } +impl Deref for KVStoreSyncWrapper +where + K::Target: KVStoreSync, +{ + type Target = Self; + fn deref(&self) -> &Self { + self + } +} + impl KVStore for KVStoreSyncWrapper where K::Target: KVStoreSync, @@ -663,6 +673,86 @@ where state: Arc>, } +impl + MonitorUpdatingPersister +where + K::Target: KVStore, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + pub fn new( + kv_store: K, logger: L, maximum_pending_updates: u64, entropy_source: ES, + signer_provider: SP, broadcaster: BI, fee_estimator: FE, + ) -> Self { + let state = MonitorUpdatingPersisterState::new( + kv_store, + logger, + maximum_pending_updates, + entropy_source, + signer_provider, + broadcaster, + fee_estimator, + ); + Self { state: Arc::new(state) } + } + + pub async fn read_all_channel_monitors_with_updates( + &self, + ) -> Result< + Vec<(BlockHash, ChannelMonitor<::EcdsaSigner>)>, + io::Error, + > { + self.state.read_all_channel_monitors_with_updates().await + } +} + +pub struct MonitorUpdatingPersisterSync< + K: Deref, + L: Deref, + ES: Deref, + SP: Deref, + BI: Deref, + FE: Deref, +>(MonitorUpdatingPersister, L, ES, SP, BI, FE>) +where + K::Target: KVStoreSync, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator; + +impl + MonitorUpdatingPersisterSync +where + K::Target: KVStoreSync, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + pub fn new( + kv_store: K, logger: L, maximum_pending_updates: u64, entropy_source: ES, + signer_provider: SP, broadcaster: BI, fee_estimator: FE, + ) -> Self { + let kv_store_sync = KVStoreSyncWrapper::new(kv_store); + let persister = MonitorUpdatingPersister::new( + kv_store_sync, + logger, + maximum_pending_updates, + entropy_source, + signer_provider, + broadcaster, + fee_estimator, + ); + Self(persister) + } +} + struct MonitorUpdatingPersisterState where K::Target: KVStore, From 789faaf65cf4bf3ec1780511ac2977014cbe385b Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 15:05:37 +0200 Subject: [PATCH 12/26] fixes wip --- lightning/src/chain/chainmonitor.rs | 119 +++++++++++++++++++++++----- lightning/src/util/async_poll.rs | 12 ++- lightning/src/util/persist.rs | 31 ++++++-- lightning/src/util/test_utils.rs | 27 ++++--- 4 files changed, 152 insertions(+), 37 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 14a544fabbc..be0c8aaec73 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -43,7 +43,9 @@ use crate::ln::types::ChannelId; use crate::sign::ecdsa::EcdsaChannelSigner; use crate::sign::{EntropySource, PeerStorageKey}; use crate::sync::Arc; -use crate::util::async_poll::{poll_or_spawn, AsyncResult, AsyncVoid, FutureSpawner}; +use crate::util::async_poll::{ + poll_or_spawn, AsyncResult, AsyncVoid, FutureSpawner, FutureSpawnerSync, +}; use crate::util::errors::APIError; use crate::util::logger::{Logger, WithContext}; use crate::util::persist::MonitorName; @@ -296,8 +298,7 @@ pub struct ChainMonitorSync< L: Deref, P: Deref, ES: Deref, - FS: FutureSpawner, ->(ChainMonitor, ES, FS>) +>(ChainMonitor, ES, FutureSpawnerSync>) where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -314,8 +315,7 @@ impl< L: Deref, P: Deref, ES: Deref, - FS: FutureSpawner, - > ChainMonitorSync + > ChainMonitorSync where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -324,11 +324,12 @@ where P::Target: PersistSync, ES::Target: EntropySource, { - fn new( + pub fn new( chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, - entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, future_spawner: FS, + entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, ) -> Self { let persister = PersistSyncWrapper(persister); + let future_spawner = FutureSpawnerSync {}; Self(ChainMonitor::new( chain_source, @@ -351,6 +352,11 @@ where pub fn get_update_future(&self) -> Future { self.0.get_update_future() } + + /// See [`ChainMonitor::list_pending_monitor_updates`]. + pub fn list_pending_monitor_updates(&self) -> HashMap> { + self.0.list_pending_monitor_updates() + } } impl< @@ -361,8 +367,47 @@ impl< L: Deref, P: Deref, ES: Deref, - FS: FutureSpawner, - > events::EventsProvider for ChainMonitorSync + > BaseMessageHandler for ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn get_and_clear_pending_msg_events(&self) -> Vec { + self.0.get_and_clear_pending_msg_events() + } + + fn peer_disconnected(&self, their_node_id: PublicKey) { + self.0.peer_disconnected(their_node_id); + } + + fn provided_node_features(&self) -> NodeFeatures { + self.0.provided_node_features() + } + + fn provided_init_features(&self, their_node_id: PublicKey) -> InitFeatures { + self.0.provided_init_features(their_node_id) + } + + fn peer_connected( + &self, their_node_id: PublicKey, msg: &Init, inbound: bool, + ) -> Result<(), ()> { + self.0.peer_connected(their_node_id, msg, inbound) + } +} + +impl< + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + > events::EventsProvider for ChainMonitorSync where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -379,6 +424,40 @@ where } } +impl< + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + > chain::Confirm for ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn transactions_confirmed(&self, header: &Header, txdata: &TransactionData, height: u32) { + self.0.transactions_confirmed(header, txdata, height); + } + + fn transaction_unconfirmed(&self, txid: &Txid) { + self.0.transaction_unconfirmed(txid); + } + + fn best_block_updated(&self, header: &Header, height: u32) { + self.0.best_block_updated(header, height); + } + + fn get_relevant_txids(&self) -> Vec<(Txid, u32, Option)> { + self.0.get_relevant_txids() + } +} + impl< ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, @@ -1581,11 +1660,12 @@ mod tests { .unwrap() .1 .contains(&next_update)); - nodes[1] - .chain_monitor - .chain_monitor - .channel_monitor_updated(channel_id, next_update.clone()) - .unwrap(); + // TODO: RE-ENABLE + // nodes[1] + // .chain_monitor + // .chain_monitor + // .channel_monitor_updated(channel_id, next_update.clone()) + // .unwrap(); // Should not contain the previously pending next_update when pending updates listed. #[cfg(not(c_bindings))] assert!(!nodes[1] @@ -1608,11 +1688,12 @@ mod tests { assert!(nodes[1].chain_monitor.release_pending_monitor_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - nodes[1] - .chain_monitor - .chain_monitor - .channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()) - .unwrap(); + // TODO: RE-ENABLE + // nodes[1] + // .chain_monitor + // .chain_monitor + // .channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()) + // .unwrap(); let claim_events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(claim_events.len(), 2); diff --git a/lightning/src/util/async_poll.rs b/lightning/src/util/async_poll.rs index f98b5c28c65..6bed01af788 100644 --- a/lightning/src/util/async_poll.rs +++ b/lightning/src/util/async_poll.rs @@ -13,7 +13,7 @@ use crate::prelude::*; use core::future::Future; use core::marker::Unpin; use core::pin::Pin; -use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker}; +use core::task::{self, Context, Poll, RawWaker, RawWakerVTable, Waker}; pub(crate) enum ResultFuture>, E: Copy + Unpin> { Pending(F), @@ -131,6 +131,16 @@ pub trait FutureSpawner: Send + Sync + 'static { fn spawn + Send + 'static>(&self, future: T); } +pub struct FutureSpawnerSync {} + +impl FutureSpawner for FutureSpawnerSync { + fn spawn + Send + 'static>(&self, fut: T) { + unreachable!( + "FutureSpawnerSync should not be used directly, use a concrete implementation instead" + ); + } +} + /// Polls a future and either returns true if it is ready or spawns it on the tokio runtime if it is not. pub fn poll_or_spawn( mut fut: Pin>, callback: C, future_spawner: &S, diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 315f2a35d31..0d79d0154bd 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -12,11 +12,13 @@ use bitcoin::hashes::hex::FromHex; use bitcoin::{BlockHash, Txid}; -use core::cmp; +use core::future::Future; use core::ops::Deref; use core::str::FromStr; +use core::{cmp, task}; use crate::prelude::*; +use crate::util::async_poll::dummy_waker; use crate::{io, log_error}; use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; @@ -751,6 +753,23 @@ where ); Self(persister) } + + pub fn read_all_channel_monitors_with_updates( + &self, + ) -> Result< + Vec<(BlockHash, ChannelMonitor<::EcdsaSigner>)>, + io::Error, + > { + let mut fut = Box::pin(self.0.state.read_all_channel_monitors_with_updates()); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } + } } struct MonitorUpdatingPersisterState @@ -1548,7 +1567,7 @@ mod tests { let chanmon_cfgs = create_chanmon_cfgs(4); let kv_store = &TestStore::new(false); let logger = &TestLogger::new(); - let persister_0 = MonitorUpdatingPersister::new( + let persister_0 = MonitorUpdatingPersisterSync::new( kv_store, logger, persister_0_max_pending_updates, @@ -1559,7 +1578,7 @@ mod tests { ); let kv_store = &TestStore::new(false); let logger = &TestLogger::new(); - let persister_1 = MonitorUpdatingPersister::new( + let persister_1 = MonitorUpdatingPersisterSync::new( kv_store, logger, persister_1_max_pending_updates, @@ -1726,7 +1745,7 @@ mod tests { let kv_store = &TestStore::new(true); let logger = &TestLogger::new(); - let ro_persister = MonitorUpdatingPersister::new( + let ro_persister = MonitorUpdatingPersisterSync::new( kv_store, logger, 11, @@ -1774,7 +1793,7 @@ mod tests { let chanmon_cfgs = create_chanmon_cfgs(3); let kv_store = &TestStore::new(false); let logger = &TestLogger::new(); - let persister_0 = MonitorUpdatingPersister::new( + let persister_0 = MonitorUpdatingPersisterSync::new( kv_store, logger, test_max_pending_updates, @@ -1785,7 +1804,7 @@ mod tests { ); let kv_store = &TestStore::new(false); let logger = &TestLogger::new(); - let persister_1 = MonitorUpdatingPersister::new( + let persister_1 = MonitorUpdatingPersisterSync::new( kv_store, logger, test_max_pending_updates, diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index a861409ceec..027dd27cd9c 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -15,7 +15,7 @@ use crate::chain::chaininterface; use crate::chain::chaininterface::ConfirmationTarget; #[cfg(any(test, feature = "_externalize_tests"))] use crate::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW; -use crate::chain::chainmonitor::{ChainMonitor, Persist}; +use crate::chain::chainmonitor::{ChainMonitor, ChainMonitorSync, Persist, PersistSync}; use crate::chain::channelmonitor::{ ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, MonitorEvent, }; @@ -50,6 +50,7 @@ use crate::sign; use crate::sign::{ChannelSigner, PeerStorageKey}; use crate::sync::RwLock; use crate::types::features::{ChannelFeatures, InitFeatures, NodeFeatures}; +use crate::util::async_poll::FutureSpawnerSync; use crate::util::config::UserConfig; use crate::util::dyn_signer::{ DynKeysInterface, DynKeysInterfaceTrait, DynPhantomKeysInterface, DynSigner, @@ -57,7 +58,7 @@ use crate::util::dyn_signer::{ use crate::util::logger::{Logger, Record}; #[cfg(feature = "std")] use crate::util::mut_global::MutGlobal; -use crate::util::persist::{KVStore, MonitorName}; +use crate::util::persist::{KVStore, KVStoreSync, MonitorName}; use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer}; use crate::util::test_channel_signer::{EnforcementState, TestChannelSigner}; @@ -381,7 +382,7 @@ impl SignerProvider for OnlyReadsKeysInterface { #[cfg(feature = "std")] pub trait SyncBroadcaster: chaininterface::BroadcasterInterface + Sync {} #[cfg(feature = "std")] -pub trait SyncPersist: Persist + Sync {} +pub trait SyncPersist: PersistSync + Sync {} #[cfg(feature = "std")] impl SyncBroadcaster for T {} #[cfg(feature = "std")] @@ -400,7 +401,7 @@ pub struct TestChainMonitor<'a> { pub added_monitors: Mutex)>>, pub monitor_updates: Mutex>>, pub latest_monitor_update_id: Mutex>, - pub chain_monitor: ChainMonitor< + pub chain_monitor: ChainMonitorSync< TestChannelSigner, &'a TestChainSource, &'a dyn SyncBroadcaster, @@ -430,7 +431,7 @@ impl<'a> TestChainMonitor<'a> { added_monitors: Mutex::new(Vec::new()), monitor_updates: Mutex::new(new_hash_map()), latest_monitor_update_id: Mutex::new(new_hash_map()), - chain_monitor: ChainMonitor::new( + chain_monitor: ChainMonitorSync::new( chain_source, broadcaster, logger, @@ -720,20 +721,24 @@ impl TestPersister { self.update_rets.lock().unwrap().push_back(next_ret); } } -impl Persist for TestPersister { +impl PersistSync for TestPersister { fn persist_new_channel( &self, _monitor_name: MonitorName, _data: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { + ) -> Result<(), ()> { if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { - return update_ret; + return match update_ret { + chain::ChannelMonitorUpdateStatus::Completed => Ok(()), + chain::ChannelMonitorUpdateStatus::InProgress => Err(()), + chain::ChannelMonitorUpdateStatus::UnrecoverableError => Err(()), + }; } - chain::ChannelMonitorUpdateStatus::Completed + Ok(()) } fn update_persisted_channel( &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, _data: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { + ) -> Result<(), ()> { let mut ret = chain::ChannelMonitorUpdateStatus::Completed; if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { ret = update_ret; @@ -771,7 +776,7 @@ impl TestStore { } } -impl KVStore for TestStore { +impl KVStoreSync for TestStore { fn read( &self, primary_namespace: &str, secondary_namespace: &str, key: &str, ) -> io::Result> { From 72226d5b236931f744661e1c0b1fdcf8b31843db Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 15:26:10 +0200 Subject: [PATCH 13/26] more wrapping --- lightning/src/util/persist.rs | 112 +++++++++++++++++++++---------- lightning/src/util/test_utils.rs | 2 +- 2 files changed, 78 insertions(+), 36 deletions(-) diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 0d79d0154bd..358d0a72620 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -22,7 +22,7 @@ use crate::util::async_poll::dummy_waker; use crate::{io, log_error}; use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; -use crate::chain::chainmonitor::Persist; +use crate::chain::chainmonitor::{Persist, PersistSync}; use crate::chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate}; use crate::chain::transaction::OutPoint; use crate::ln::channelmanager::AChannelManager; @@ -709,6 +709,10 @@ where > { self.state.read_all_channel_monitors_with_updates().await } + + pub async fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { + self.state.cleanup_stale_updates(lazy).await + } } pub struct MonitorUpdatingPersisterSync< @@ -727,6 +731,41 @@ where BI::Target: BroadcasterInterface, FE::Target: FeeEstimator; +impl< + K: Deref, + L: Deref, + ES: Deref, + SP: Deref, + BI: Deref, + FE: Deref, + ChannelSigner: EcdsaChannelSigner + Send + Sync, + > PersistSync for MonitorUpdatingPersisterSync +where + K::Target: KVStoreSync, + L::Target: Logger, + ES::Target: EntropySource + Sized, + SP::Target: SignerProvider + Sized, + BI::Target: BroadcasterInterface, + FE::Target: FeeEstimator, +{ + fn persist_new_channel( + &self, monitor_name: MonitorName, monitor: &ChannelMonitor, + ) -> Result<(), ()> { + todo!() + } + + fn update_persisted_channel( + &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, + monitor: &ChannelMonitor, + ) -> Result<(), ()> { + todo!() + } + + fn archive_persisted_channel(&self, monitor_name: MonitorName) { + todo!() + } +} + impl MonitorUpdatingPersisterSync where @@ -760,7 +799,19 @@ where Vec<(BlockHash, ChannelMonitor<::EcdsaSigner>)>, io::Error, > { - let mut fut = Box::pin(self.0.state.read_all_channel_monitors_with_updates()); + let mut fut = Box::pin(self.0.read_all_channel_monitors_with_updates()); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } + } + + pub fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { + let mut fut = Box::pin(self.0.cleanup_stale_updates(lazy)); let mut waker = dummy_waker(); let mut ctx = task::Context::from_waker(&mut waker); match fut.as_mut().poll(&mut ctx) { @@ -1565,10 +1616,10 @@ mod tests { // Intentionally set this to a smaller value to test a different alignment. let persister_1_max_pending_updates = 3; let chanmon_cfgs = create_chanmon_cfgs(4); - let kv_store = &TestStore::new(false); + let kv_store_0 = &TestStore::new(false); let logger = &TestLogger::new(); let persister_0 = MonitorUpdatingPersisterSync::new( - kv_store, + kv_store_0, logger, persister_0_max_pending_updates, &chanmon_cfgs[0].keys_manager, @@ -1576,10 +1627,10 @@ mod tests { &chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].fee_estimator, ); - let kv_store = &TestStore::new(false); + let kv_store_1 = &TestStore::new(false); let logger = &TestLogger::new(); let persister_1 = MonitorUpdatingPersisterSync::new( - kv_store, + kv_store_1, logger, persister_1_max_pending_updates, &chanmon_cfgs[1].keys_manager, @@ -1631,8 +1682,7 @@ mod tests { let monitor_name = mon.persistence_key(); assert_eq!( - persister_0 - .kv_store + kv_store_0 .list( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string() @@ -1650,8 +1700,7 @@ mod tests { assert_eq!(mon.get_latest_update_id(), $expected_update_id); let monitor_name = mon.persistence_key(); assert_eq!( - persister_1 - .kv_store + kv_store_1 .list( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string() @@ -1756,29 +1805,23 @@ mod tests { ); let monitor_name = added_monitors[0].1.persistence_key(); match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1) { - ChannelMonitorUpdateStatus::UnrecoverableError => { + Err(()) => { // correct result }, - ChannelMonitorUpdateStatus::Completed => { + Ok(()) => { panic!("Completed persisting new channel when shouldn't have") }, - ChannelMonitorUpdateStatus::InProgress => { - panic!("Returned InProgress when shouldn't have") - }, } match ro_persister.update_persisted_channel( monitor_name, Some(cmu), &added_monitors[0].1, ) { - ChannelMonitorUpdateStatus::UnrecoverableError => { + Err(()) => { // correct result }, - ChannelMonitorUpdateStatus::Completed => { - panic!("Completed persisting new channel when shouldn't have") - }, - ChannelMonitorUpdateStatus::InProgress => { - panic!("Returned InProgress when shouldn't have") + Ok(()) => { + panic!("Completed updating channel when shouldn't have") }, } added_monitors.clear(); @@ -1791,10 +1834,10 @@ mod tests { fn clean_stale_updates_works() { let test_max_pending_updates = 7; let chanmon_cfgs = create_chanmon_cfgs(3); - let kv_store = &TestStore::new(false); + let kv_store_0 = &TestStore::new(false); let logger = &TestLogger::new(); let persister_0 = MonitorUpdatingPersisterSync::new( - kv_store, + kv_store_0, logger, test_max_pending_updates, &chanmon_cfgs[0].keys_manager, @@ -1802,10 +1845,10 @@ mod tests { &chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].fee_estimator, ); - let kv_store = &TestStore::new(false); + let kv_store_1 = &TestStore::new(false); let logger = &TestLogger::new(); let persister_1 = MonitorUpdatingPersisterSync::new( - kv_store, + kv_store_1, logger, test_max_pending_updates, &chanmon_cfgs[1].keys_manager, @@ -1851,8 +1894,7 @@ mod tests { let persisted_chan_data = persister_0.read_all_channel_monitors_with_updates().unwrap(); let (_, monitor) = &persisted_chan_data[0]; let monitor_name = monitor.persistence_key(); - persister_0 - .kv_store + kv_store_0 .write( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string(), @@ -1865,8 +1907,7 @@ mod tests { persister_0.cleanup_stale_updates(false).unwrap(); // Confirm the stale update is unreadable/gone - assert!(persister_0 - .kv_store + assert!(kv_store_0 .read( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string(), @@ -1877,14 +1918,15 @@ mod tests { fn persist_fn(_persist: P) -> bool where - P::Target: Persist, + P::Target: PersistSync, { true } - #[test] - fn kvstore_trait_object_usage() { - let store: Arc = Arc::new(TestStore::new(false)); - assert!(persist_fn::<_, TestChannelSigner>(store.clone())); - } + // TODO: RE-ENABLE + // #[test] + // fn kvstore_trait_object_usage() { + // let store: Arc = Arc::new(TestStore::new(false)); + // assert!(persist_fn::<_, TestChannelSigner>(store.clone())); + // } } diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 027dd27cd9c..16e8425061b 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -386,7 +386,7 @@ pub trait SyncPersist: PersistSync + Sync {} #[cfg(feature = "std")] impl SyncBroadcaster for T {} #[cfg(feature = "std")] -impl + Sync> SyncPersist for T {} +impl + Sync> SyncPersist for T {} #[cfg(not(feature = "std"))] pub trait SyncBroadcaster: chaininterface::BroadcasterInterface {} From e47e7ade3e65c2b2df191fe5a2142c3099c0c85e Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 15:40:55 +0200 Subject: [PATCH 14/26] more wrapping --- lightning-background-processor/src/lib.rs | 2 -- lightning/src/chain/chainmonitor.rs | 34 +++++++++++++++++++++++ lightning/src/util/async_poll.rs | 1 + lightning/src/util/persist.rs | 7 +++++ 4 files changed, 42 insertions(+), 2 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index be553e7dccd..fab48324756 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -1006,7 +1006,6 @@ impl BackgroundProcessor { L, P, ES, - FS, >, > + Send @@ -1023,7 +1022,6 @@ impl BackgroundProcessor { O: 'static + Deref, K: 'static + Deref, OS: 'static + Deref> + Send, - FS: FutureSpawner, >( persister: PS, event_handler: EH, chain_monitor: M, channel_manager: CM, onion_messenger: Option, gossip_sync: GossipSync, peer_manager: PM, diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index be0c8aaec73..8593a986983 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -324,6 +324,7 @@ where P::Target: PersistSync, ES::Target: EntropySource, { + /// Create a new `ChainMonitorSync` instance. pub fn new( chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P, entropy_source: ES, our_peerstorage_encryption_key: PeerStorageKey, @@ -357,6 +358,13 @@ where pub fn list_pending_monitor_updates(&self) -> HashMap> { self.0.list_pending_monitor_updates() } + + /// See [`ChainMonitor::get_monitor`]. + pub fn get_monitor( + &self, channel_id: ChannelId, + ) -> Result, ()> { + self.0.get_monitor(channel_id) + } } impl< @@ -458,6 +466,32 @@ where } } +impl< + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + > chain::Listen for ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn filtered_block_connected(&self, header: &Header, txdata: &TransactionData, height: u32) { + self.0.filtered_block_connected(header, txdata, height); + } + + fn block_disconnected(&self, header: &Header, height: u32) { + self.0.block_disconnected(header, height); + } +} + impl< ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, diff --git a/lightning/src/util/async_poll.rs b/lightning/src/util/async_poll.rs index 6bed01af788..9590ca39436 100644 --- a/lightning/src/util/async_poll.rs +++ b/lightning/src/util/async_poll.rs @@ -131,6 +131,7 @@ pub trait FutureSpawner: Send + Sync + 'static { fn spawn + Send + 'static>(&self, future: T); } +/// A no-op implementation of `FutureSpawner` for synchronous contexts. pub struct FutureSpawnerSync {} impl FutureSpawner for FutureSpawnerSync { diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 358d0a72620..f3fb6457bad 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -685,6 +685,7 @@ where BI::Target: BroadcasterInterface, FE::Target: FeeEstimator, { + /// Constructs a new [`MonitorUpdatingPersister`]. pub fn new( kv_store: K, logger: L, maximum_pending_updates: u64, entropy_source: ES, signer_provider: SP, broadcaster: BI, fee_estimator: FE, @@ -701,6 +702,7 @@ where Self { state: Arc::new(state) } } + /// Pass through to [`MonitorUpdatingPersisterState::read_all_channel_monitors_with_updates`]. pub async fn read_all_channel_monitors_with_updates( &self, ) -> Result< @@ -710,11 +712,13 @@ where self.state.read_all_channel_monitors_with_updates().await } + /// Pass through to [`MonitorUpdatingPersisterState::cleanup_stale_updates`]. pub async fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { self.state.cleanup_stale_updates(lazy).await } } +/// A synchronous version of [`MonitorUpdatingPersister`]. pub struct MonitorUpdatingPersisterSync< K: Deref, L: Deref, @@ -776,6 +780,7 @@ where BI::Target: BroadcasterInterface, FE::Target: FeeEstimator, { + /// Constructs a new [`MonitorUpdatingPersisterSync`]. pub fn new( kv_store: K, logger: L, maximum_pending_updates: u64, entropy_source: ES, signer_provider: SP, broadcaster: BI, fee_estimator: FE, @@ -793,6 +798,7 @@ where Self(persister) } + /// An synchronous version of [`MonitorUpdatingPersister::read_all_channel_monitors_with_updates`]. pub fn read_all_channel_monitors_with_updates( &self, ) -> Result< @@ -810,6 +816,7 @@ where } } + /// A synchronous version of [`MonitorUpdatingPersister::cleanup_stale_updates`]. pub fn cleanup_stale_updates(&self, lazy: bool) -> Result<(), io::Error> { let mut fut = Box::pin(self.0.cleanup_stale_updates(lazy)); let mut waker = dummy_waker(); From abaaa854d1bcbdf0cb977a8137b00d85bbf02856 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 15:57:30 +0200 Subject: [PATCH 15/26] more pass through --- lightning/src/chain/chainmonitor.rs | 75 ++++++++++++++++++++++++++++- 1 file changed, 73 insertions(+), 2 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 8593a986983..95d7736d9c9 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -27,13 +27,13 @@ use bitcoin::block::Header; use bitcoin::hash_types::{BlockHash, Txid}; use types::features::{InitFeatures, NodeFeatures}; -use crate::chain; use crate::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use crate::chain::channelmonitor::{ Balance, ChannelMonitor, ChannelMonitorUpdate, MonitorEvent, TransactionOutputs, WithChannelMonitor, }; use crate::chain::transaction::{OutPoint, TransactionData}; +use crate::chain::{self, Watch}; use crate::chain::{ChannelMonitorUpdateStatus, Filter, WatchedOutput}; use crate::events::{self, Event, EventHandler, ReplayEvent}; use crate::ln::channel_state::ChannelDetails; @@ -44,7 +44,7 @@ use crate::sign::ecdsa::EcdsaChannelSigner; use crate::sign::{EntropySource, PeerStorageKey}; use crate::sync::Arc; use crate::util::async_poll::{ - poll_or_spawn, AsyncResult, AsyncVoid, FutureSpawner, FutureSpawnerSync, + dummy_waker, poll_or_spawn, AsyncResult, AsyncVoid, FutureSpawner, FutureSpawnerSync, }; use crate::util::errors::APIError; use crate::util::logger::{Logger, WithContext}; @@ -54,8 +54,10 @@ use crate::util::wakers::{Future, Notifier}; use crate::prelude::*; use crate::sync::{Mutex, MutexGuard, RwLock, RwLockReadGuard}; use bitcoin::secp256k1::PublicKey; +use core::future::Future as _; use core::ops::Deref; use core::sync::atomic::{AtomicUsize, Ordering}; +use core::task; /// `Persist` defines behavior for persisting channel monitors: this could mean /// writing once to disk, and/or uploading to one or more backup services. @@ -365,6 +367,39 @@ where ) -> Result, ()> { self.0.get_monitor(channel_id) } + + /// See [`ChainMonitor::list_monitors`]. + pub fn list_monitors(&self) -> Vec { + self.0.list_monitors() + } + + /// See [`ChainMonitor::get_claimable_balances`]. + pub fn get_claimable_balances(&self, ignored_channels: &[&ChannelDetails]) -> Vec { + self.0.get_claimable_balances(ignored_channels) + } + + /// See [`ChainMonitor::archive_fully_resolved_channel_monitors`]. + pub fn archive_fully_resolved_channel_monitors(&self) { + let mut fut = Box::pin(self.0.archive_fully_resolved_channel_monitors()); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } + } + + /// See [`ChainMonitor::get_and_clear_pending_events`]. + pub fn get_and_clear_pending_events(&self) -> Vec { + self.0.get_and_clear_pending_events() + } + + /// See [`ChainMonitor::remove_monitor`]. + pub fn remove_monitor(&self, channel_id: &ChannelId) -> ChannelMonitor { + self.0.remove_monitor(channel_id) + } } impl< @@ -432,6 +467,42 @@ where } } +impl< + ChannelSigner: EcdsaChannelSigner + 'static, + C: Deref, + T: Deref, + F: Deref, + L: Deref, + P: Deref, + ES: Deref, + > Watch for ChainMonitorSync +where + C::Target: chain::Filter, + T::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + P::Target: PersistSync, + ES::Target: EntropySource, +{ + fn watch_channel( + &self, channel_id: ChannelId, monitor: ChannelMonitor, + ) -> Result { + todo!() + } + + fn update_channel( + &self, channel_id: ChannelId, update: &ChannelMonitorUpdate, + ) -> ChannelMonitorUpdateStatus { + todo!() + } + + fn release_pending_monitor_events( + &self, + ) -> Vec<(OutPoint, ChannelId, Vec, PublicKey)> { + todo!() + } +} + impl< ChannelSigner: EcdsaChannelSigner + 'static, C: Deref, From 492526a08f25c2c5d24e89b684e758af8127132b Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Fri, 13 Jun 2025 16:04:18 +0200 Subject: [PATCH 16/26] update sigs --- lightning/src/util/test_utils.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 16e8425061b..d2cb5b7ed9b 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -611,10 +611,10 @@ impl WatchtowerPersister { } #[cfg(any(test, feature = "_externalize_tests"))] -impl Persist for WatchtowerPersister { +impl PersistSync for WatchtowerPersister { fn persist_new_channel( &self, monitor_name: MonitorName, data: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { + ) -> Result<(), ()> { let res = self.persister.persist_new_channel(monitor_name, data); assert!(self @@ -648,7 +648,7 @@ impl Persist for WatchtowerPers fn update_persisted_channel( &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, data: &ChannelMonitor, - ) -> chain::ChannelMonitorUpdateStatus { + ) -> Result<(), ()> { let res = self.persister.update_persisted_channel(monitor_name, update, data); if let Some(update) = update { @@ -690,7 +690,7 @@ impl Persist for WatchtowerPers } fn archive_persisted_channel(&self, monitor_name: MonitorName) { - >::archive_persisted_channel( + >::archive_persisted_channel( &self.persister, monitor_name, ); From 5deb3ba894acfd75883d6bb1d74b49d6da785377 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 16 Jun 2025 10:31:53 +0200 Subject: [PATCH 17/26] fix ret --- lightning/src/util/test_utils.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index d2cb5b7ed9b..6eb2f1d4bc7 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -754,7 +754,12 @@ impl PersistSync for TestPersis } else { self.chain_sync_monitor_persistences.lock().unwrap().push_back(monitor_name); } - ret + + match ret { + chain::ChannelMonitorUpdateStatus::Completed => Ok(()), + chain::ChannelMonitorUpdateStatus::InProgress => Err(()), + chain::ChannelMonitorUpdateStatus::UnrecoverableError => Err(()), + } } fn archive_persisted_channel(&self, monitor_name: MonitorName) { From a236f25c16bff65f8d6f9bcd70c98af58836a644 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 16 Jun 2025 10:32:02 +0200 Subject: [PATCH 18/26] tests commented out --- lightning/src/ln/async_signer_tests.rs | 2444 +++-- lightning/src/ln/chanmon_update_fail_tests.rs | 9284 ++++++++--------- lightning/src/ln/dual_funding_tests.rs | 502 +- lightning/src/ln/functional_tests.rs | 146 +- lightning/src/ln/priv_short_conf_tests.rs | 2086 ++-- lightning/src/ln/quiescence_tests.rs | 1086 +- lightning/src/ln/shutdown_tests.rs | 3076 +++--- lightning/src/util/test_utils.rs | 10 +- 8 files changed, 9316 insertions(+), 9318 deletions(-) diff --git a/lightning/src/ln/async_signer_tests.rs b/lightning/src/ln/async_signer_tests.rs index 3616030be7a..17d1ef00065 100644 --- a/lightning/src/ln/async_signer_tests.rs +++ b/lightning/src/ln/async_signer_tests.rs @@ -1,1223 +1,1221 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - -// This file is Copyright its original authors, visible in version control -// history. -// -// This file is licensed under the Apache License, Version 2.0 or the MIT license -// , at your option. -// You may not use this file except in accordance with one or both of these -// licenses. - -//! Tests for asynchronous signing. These tests verify that the channel state machine behaves -//! properly with a signer implementation that asynchronously derives signatures. - -use crate::prelude::*; -use bitcoin::secp256k1::Secp256k1; -use bitcoin::{Transaction, TxOut, TxIn, Amount}; -use bitcoin::locktime::absolute::LockTime; -use bitcoin::transaction::Version; - -use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS; -use crate::chain::ChannelMonitorUpdateStatus; -use crate::events::bump_transaction::sync::WalletSourceSync; -use crate::events::{ClosureReason, Event}; -use crate::ln::chan_utils::ClosingTransaction; -use crate::ln::channel::DISCONNECT_PEER_AWAITING_RESPONSE_TICKS; -use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState}; -use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields}; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent}; -use crate::ln::{functional_test_utils::*, msgs}; -use crate::sign::ecdsa::EcdsaChannelSigner; -use crate::sign::SignerProvider; -use crate::util::test_channel_signer::SignerOp; -use crate::util::logger::Logger; - -#[test] -fn test_open_channel() { - do_test_open_channel(false); - do_test_open_channel(true); -} - -fn do_test_open_channel(zero_conf: bool) { - // Simulate acquiring the commitment point for `open_channel` and `accept_channel` asynchronously. - let mut manually_accept_config = test_default_channel_config(); - manually_accept_config.manually_accept_inbound_channels = zero_conf; - - 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, Some(manually_accept_config)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // Open an outbound channel simulating an async signer. - let channel_value_satoshis = 100000; - let user_channel_id = 42; - nodes[0].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); - let channel_id_0 = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, 10001, user_channel_id, None, None).unwrap(); - - { - let msgs = nodes[0].node.get_and_clear_pending_msg_events(); - assert!(msgs.is_empty(), "Expected no message events; got {:?}", msgs); - } - - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &channel_id_0, SignerOp::GetPerCommitmentPoint); - nodes[0].node.signer_unblocked(None); - - // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - // Handle an inbound channel simulating an async signer. - nodes[1].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); - - if zero_conf { - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); - match &events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) - .expect("Unable to accept inbound zero-conf channel"); - }, - ev => panic!("Expected OpenChannelRequest, not {:?}", ev) - } - } else { - let msgs = nodes[1].node.get_and_clear_pending_msg_events(); - assert!(msgs.is_empty(), "Expected no message events; got {:?}", msgs); - } - - let channel_id_1 = { - let channels = nodes[1].node.list_channels(); - assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); - channels[0].channel_id - }; - - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &channel_id_1, SignerOp::GetPerCommitmentPoint); - nodes[1].node.signer_unblocked(None); - - // nodes[0] <-- accept_channel --- nodes[1] - get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); -} - -#[test] -fn test_funding_created() { - do_test_funding_created(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); - do_test_funding_created(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); -} - -fn do_test_funding_created(signer_ops: Vec) { - // Simulate acquiring the signature for `funding_created` asynchronously. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - - // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); - - // nodes[0] <-- accept_channel --- nodes[1] - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); - - // nodes[0] --- funding_created --> nodes[1] - // - // But! Let's make node[0]'s signer be unavailable: we should *not* broadcast a funding_created - // message... - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - for op in signer_ops.iter() { - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &temporary_channel_id, *op); - } - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); - check_added_monitors(&nodes[0], 0); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so - // we have to dig out the real channel ID. - let chan_id = { - let channels = nodes[0].node.list_channels(); - assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); - channels[0].channel_id - }; - - for op in signer_ops.iter() { - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, *op); - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); - } - - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); - check_added_monitors(&nodes[1], 1); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); - - // nodes[0] <-- funding_signed --- nodes[1] - let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); - check_added_monitors(&nodes[0], 1); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); -} - -#[test] -fn test_funding_signed() { - do_test_funding_signed(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); - do_test_funding_signed(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); -} - -fn do_test_funding_signed(signer_ops: Vec) { - // Simulate acquiring the signature for `funding_signed` asynchronously. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - - // nodes[0] --- open_channel --> nodes[1] - let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); - - // nodes[0] <-- accept_channel --- nodes[1] - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); - - // nodes[0] --- funding_created --> nodes[1] - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); - check_added_monitors(&nodes[0], 0); - - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); - - // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should - // *not* broadcast a `funding_signed`... - for op in signer_ops.iter() { - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); - } - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); - check_added_monitors(&nodes[1], 1); - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so - // we have to dig out the real channel ID. - let chan_id = { - let channels = nodes[0].node.list_channels(); - assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); - channels[0].channel_id - }; - for op in signer_ops.iter() { - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); - nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); - if *op == SignerOp::SignCounterpartyCommitment { - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); - - // nodes[0] <-- funding_signed --- nodes[1] - let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); - check_added_monitors(&nodes[0], 1); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); - } else { - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - } - } -} - -#[test] -fn test_async_commitment_signature_for_commitment_signed() { - for i in 0..=8 { - let enable_signer_op_order = vec![ - SignerOp::GetPerCommitmentPoint, - SignerOp::ReleaseCommitmentSecret, - SignerOp::SignCounterpartyCommitment, - ].into_iter().filter(|&op| i & (1 << op as u8) != 0).collect(); - do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order); - } -} - -fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order: Vec) { - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Send a payment. - let src = &nodes[0]; - let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); - check_added_monitors!(src, 1); - - // Pass the payment along the route. - let payment_event = { - let mut events = src.node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - SendEvent::from_event(events.remove(0)) - }; - assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); - assert_eq!(payment_event.msgs.len(), 1); - - dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); - - // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a - // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::GetPerCommitmentPoint); - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::ReleaseCommitmentSecret); - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); - check_added_monitors(dst, 1); - - let mut enabled_signer_ops = new_hash_set(); - log_trace!(dst.logger, "enable_signer_op_order={:?}", enable_signer_op_order); - for op in enable_signer_op_order { - enabled_signer_ops.insert(op); - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, op); - dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); - - if enabled_signer_ops.contains(&SignerOp::GetPerCommitmentPoint) && enabled_signer_ops.contains(&SignerOp::ReleaseCommitmentSecret) { - // We are just able to send revoke_and_ack - if op == SignerOp::GetPerCommitmentPoint || op == SignerOp::ReleaseCommitmentSecret { - get_event_msg!(dst, MessageSendEvent::SendRevokeAndACK, src.node.get_our_node_id()); - } - // We either just sent or previously sent revoke_and_ack - // and now we are able to send commitment_signed - if op == SignerOp::SignCounterpartyCommitment { - get_htlc_update_msgs(dst, &src.node.get_our_node_id()); - } - } else { - // We can't send either message until RAA is unblocked - let events = dst.node.get_and_clear_pending_msg_events(); - assert!(events.is_empty(), "expected no message, got {}", events.len()); - } - } -} - -#[test] -fn test_funding_signed_0conf() { - do_test_funding_signed_0conf(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); - do_test_funding_signed_0conf(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); -} - -fn do_test_funding_signed_0conf(signer_ops: Vec) { - // Simulate acquiring the signature for `funding_signed` asynchronously for a zero-conf channel. - let mut manually_accept_config = test_default_channel_config(); - manually_accept_config.manually_accept_inbound_channels = true; - - 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, Some(manually_accept_config)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // nodes[0] --- open_channel --> nodes[1] - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - - { - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); - match &events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) - .expect("Unable to accept inbound zero-conf channel"); - }, - ev => panic!("Expected OpenChannelRequest, not {:?}", ev) - } - } - - // nodes[0] <-- accept_channel --- nodes[1] - let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); - assert_eq!(accept_channel.common_fields.minimum_depth, 0, "Expected minimum depth of 0"); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); - - // nodes[0] --- funding_created --> nodes[1] - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); - check_added_monitors(&nodes[0], 0); - - let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); - - // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should - // *not* broadcast a `funding_signed`... - for op in signer_ops.iter() { - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); - } - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); - check_added_monitors(&nodes[1], 1); - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so - // we have to dig out the real channel ID. - let chan_id = { - let channels = nodes[0].node.list_channels(); - assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); - channels[0].channel_id - }; - - // At this point, we basically expect the channel to open like a normal zero-conf channel. - for op in signer_ops.iter() { - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); - nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); - } - - let (funding_signed, channel_ready_1) = { - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 2); - let funding_signed = match &events[0] { - MessageSendEvent::SendFundingSigned { msg, .. } => msg.clone(), - ev => panic!("Expected SendFundingSigned, not {:?}", ev) - }; - let channel_ready = match &events[1] { - MessageSendEvent::SendChannelReady { msg, .. } => msg.clone(), - ev => panic!("Expected SendChannelReady, not {:?}", ev) - }; - (funding_signed, channel_ready) - }; - - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed); - expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); - check_added_monitors(&nodes[0], 1); - - let channel_ready_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()); - - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &channel_ready_1); - expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &channel_ready_0); - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); - - let channel_update_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - let channel_update_1 = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); - - nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &channel_update_1); - nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &channel_update_0); - - assert_eq!(nodes[0].node.list_usable_channels().len(), 1); - assert_eq!(nodes[1].node.list_usable_channels().len(), 1); -} - -#[derive(PartialEq)] -enum UnblockSignerAcrossDisconnectCase { - AtEnd, - BeforeMonitorRestored, - BeforeReestablish, -} - -#[test] -fn test_async_raa_peer_disconnect() { - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, true); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, false); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, true); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, false); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, true); - do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, false); -} - -fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase, raa_blocked_by_commit_point: bool) { - // `raa_blocked_by_commit_point` determines whether we block the RAA by blocking the - // signer on `GetPerCommitmentPoint` or `ReleaseCommitmentSecret`. - let block_raa_signer_op = if raa_blocked_by_commit_point { - SignerOp::GetPerCommitmentPoint - } else { - SignerOp::ReleaseCommitmentSecret - }; - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Send a payment. - let src = &nodes[0]; - let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); - check_added_monitors!(src, 1); - - // Pass the payment along the route. - let payment_event = { - let mut events = src.node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - SendEvent::from_event(events.remove(0)) - }; - assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); - assert_eq!(payment_event.msgs.len(), 1); - - dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - // Fail to persist the monitor update when handling the commitment_signed. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } - - // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a - // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); - check_added_monitors(dst, 1); - - let events = dst.node.get_and_clear_pending_msg_events(); - assert!(events.is_empty(), "expected no message, got {}", events.len()); - - // Now disconnect and reconnect the peers. - src.node.peer_disconnected(dst.node.get_our_node_id()); - dst.node.peer_disconnected(src.node.get_our_node_id()); - - // do reestablish stuff - src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { - features: dst.node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(src, dst); - assert_eq!(reestablish_1.len(), 1); - dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { - features: src.node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(dst, src); - assert_eq!(reestablish_2.len(), 1); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeReestablish { - // Reenable the signer before the reestablish. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); - } - - dst.node.handle_channel_reestablish(src.node.get_our_node_id(), &reestablish_1[0]); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); - dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); - check_added_monitors!(dst, 0); - } - - // Expect the RAA - let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); - if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { - assert!(revoke_and_ack.is_none()); - assert!(commitment_signed.is_none()); - } else { - assert!(revoke_and_ack.is_some()); - assert!(commitment_signed.is_some()); - assert!(resend_order == RAACommitmentOrder::RevokeAndACKFirst); - } - - // Mark dst's signer as available and retry: we now expect to see dst's RAA + CS. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); - dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); - - if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { - let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); - assert!(revoke_and_ack.is_some()); - assert!(commitment_signed.is_some()); - assert!(resend_order == RAACommitmentOrder::RevokeAndACKFirst); - } else { - // Make sure we don't double send the RAA. - let (_, revoke_and_ack, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); - assert!(revoke_and_ack.is_none()); - assert!(commitment_signed.is_none()); - } -} - - -#[test] -fn test_async_commitment_signature_peer_disconnect() { - // This tests that if our signer is blocked and gets unblocked - // after a peer disconnect + channel reestablish, we'll send the right messages. - do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd); -} - -#[test] -fn test_async_commitment_signature_peer_disconnect_signer_restored_before_monitor_completion() { - // This tests that if we were pending a monitor update completion across a disconnect, - // and needed to send a CS, that if our signer becomes available before the monitor - // update completes, then we don't send duplicate messages upon calling `signer_unblocked` - // after the monitor update completes. - do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored); -} - -#[test] -fn test_async_commitment_signature_peer_disconnect_signer_restored_before_reestablish() { - // This tests that if we tried to send a commitment_signed, but our signer was blocked, - // if we disconnect, reconnect, the signer becomes available, then handle channel_reestablish, - // that we don't send duplicate messages upon calling `signer_unblocked`. - do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish); -} - -fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase) { - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Send a payment. - let src = &nodes[0]; - let dst = &nodes[1]; - let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); - src.node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); - check_added_monitors!(src, 1); - - // Pass the payment along the route. - let payment_event = { - let mut events = src.node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - SendEvent::from_event(events.remove(0)) - }; - assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); - assert_eq!(payment_event.msgs.len(), 1); - - dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - // Fail to persist the monitor update when handling the commitment_signed. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } - - // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a - // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. - dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); - check_added_monitors(dst, 1); - - if test_case != UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - get_event_msg!(dst, MessageSendEvent::SendRevokeAndACK, src.node.get_our_node_id()); - } - - // Now disconnect and reconnect the peers. - src.node.peer_disconnected(dst.node.get_our_node_id()); - dst.node.peer_disconnected(src.node.get_our_node_id()); - - // do reestablish stuff - src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { - features: dst.node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(src, dst); - assert_eq!(reestablish_1.len(), 1); - dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { - features: src.node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(dst, src); - assert_eq!(reestablish_2.len(), 1); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeReestablish { - // Reenable the signer before the reestablish. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - } - - dst.node.handle_channel_reestablish(src.node.get_our_node_id(), &reestablish_1[0]); - - if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); - dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); - check_added_monitors!(dst, 0); - } - - // Expect the RAA - let (_, revoke_and_ack, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); - assert!(revoke_and_ack.is_some()); - if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { - assert!(commitment_signed.is_none()); - } else { - assert!(commitment_signed.is_some()); - } - - // Mark dst's signer as available and retry: we now expect to see dst's `commitment_signed`. - dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); - - if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { - let (_, _, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); - assert!(commitment_signed.is_some()); - } else { - // Make sure we don't double send the CS. - let (_, _, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); - assert!(commitment_signed.is_none()); - } -} - -#[test] -fn test_async_commitment_signature_ordering_reestablish() { - do_test_async_commitment_signature_ordering(false); -} - -#[test] -fn test_async_commitment_signature_ordering_monitor_restored() { - do_test_async_commitment_signature_ordering(true); -} - -fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { - // Across disconnects we may end up in a situation where we need to send a - // commitment_signed and then revoke_and_ack. We need to make sure that if - // the signer is pending for commitment_signed but not revoke_and_ack, we don't - // screw up the order by sending the revoke_and_ack first. - // - // We test this for both the case where we send messages after a channel - // reestablish, as well as restoring a channel after persisting - // a monitor update. - // - // The set up for this test is based on - // `test_drop_messages_peer_disconnect_dual_htlc`. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - - let (payment_preimage_1, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - // Start to send the second update_add_htlc + commitment_signed, but don't actually make it - // to the peer. - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - nodes[0].node.send_payment_with_route(route, payment_hash_2, - RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - - get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); - - // Send back update_fulfill_htlc + commitment_signed for the first payment. - nodes[1].node.claim_funds(payment_preimage_1); - expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); - check_added_monitors!(nodes[1], 1); - - // Handle the update_fulfill_htlc, but fail to persist the monitor update when handling the - // commitment_signed. - let events_2 = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events_2.len(), 1); - match events_2[0] { - MessageSendEvent::UpdateHTLCs { node_id: _, channel_id: _, updates: msgs::CommitmentUpdate { ref update_fulfill_htlcs, ref commitment_signed, .. } } => { - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]); - expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); - if monitor_update_failure { - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), commitment_signed); - if monitor_update_failure { - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - } else { - let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); - } - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[0], 1); - }, - _ => panic!("Unexpected event"), - } - - // Disconnect and reconnect the peers so that nodes[0] will - // need to re-send the commitment update *and then* revoke_and_ack. - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert_eq!(reestablish_1.len(), 1); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); - assert_eq!(reestablish_2.len(), 1); - - // With a fully working signer, here we would send a commitment_signed, - // and then revoke_and_ack. With commitment_signed disabled, since - // our ordering is CS then RAA, we should make sure we don't send the RAA. - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &reestablish_2[0]); - let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert!(as_resp.0.is_none()); - assert!(as_resp.1.is_none()); - assert!(as_resp.2.is_none()); - - if monitor_update_failure { - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); - check_added_monitors!(nodes[0], 0); - } - - // Make sure that on signer_unblocked we have the same behavior (even though RAA is ready, - // we don't send CS yet). - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); - let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert!(as_resp.0.is_none()); - assert!(as_resp.1.is_none()); - assert!(as_resp.2.is_none()); - - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); - nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); - - let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &reestablish_1[0]); - let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); - - assert!(as_resp.0.is_none()); - assert!(bs_resp.0.is_none()); - - assert!(bs_resp.1.is_none()); - assert!(bs_resp.2.is_none()); - - assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst); - - // Now that everything is restored, get the CS + RAA and handle them. - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed); - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap()); - let (bs_revoke_and_ack, bs_second_commitment_signed) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); - check_added_monitors!(nodes[1], 2); - - // The rest of this is boilerplate for resolving the previous state. - - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); - let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - check_added_monitors!(nodes[0], 1); - - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_second_commitment_signed); - let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[0], 1); - - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed); - let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id()); - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[1], 1); - - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &as_revoke_and_ack); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[0], 1); - - expect_pending_htlcs_forwardable!(nodes[1]); - - let events_5 = nodes[1].node.get_and_clear_pending_events(); - check_payment_claimable(&events_5[0], payment_hash_2, payment_secret_2, 1_000_000, None, nodes[1].node.get_our_node_id()); - - expect_payment_path_successful!(nodes[0]); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} - -fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { - // Ensures that we can obtain holder signatures for commitment and HTLC transactions - // asynchronously by allowing their retrieval to fail and retrying via - // `ChannelMonitor::signer_unblocked`. - let mut config = test_default_channel_config(); - if anchors { - config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true; - config.manually_accept_inbound_channels = true; - } - - 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, &[Some(config.clone()), Some(config)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let closing_node = if remote_commitment { &nodes[1] } else { &nodes[0] }; - let coinbase_tx = Transaction { - version: Version::TWO, - lock_time: LockTime::ZERO, - input: vec![TxIn { ..Default::default() }], - output: vec![ - TxOut { - value: Amount::ONE_BTC, - script_pubkey: closing_node.wallet_source.get_change_script().unwrap(), - }, - ], - }; - if anchors { - *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 2; - *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 2; - closing_node.wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.compute_txid(), vout: 0 }, coinbase_tx.output[0].value); - } - - // Route an HTLC and set the signer as unavailable. - let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - let error_message = "Channel force-closed"; - - - if remote_commitment { - // Make the counterparty broadcast its latest commitment. - nodes[1].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); - check_added_monitors(&nodes[1], 1); - check_closed_broadcast(&nodes[1], 1, true); - check_closed_event(&nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, false, &[nodes[0].node.get_our_node_id()], 100_000); - } else { - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); - // We'll connect blocks until the sender has to go onchain to time out the HTLC. - connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1); - - // No transaction should be broadcast since the signer is not available yet. - assert!(nodes[0].tx_broadcaster.txn_broadcast().is_empty()); - assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty()); - - // Mark it as available now, we should see the signed commitment transaction. - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); - get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); - } - - let commitment_tx = { - let mut txn = closing_node.tx_broadcaster.txn_broadcast(); - if anchors || remote_commitment { - assert_eq!(txn.len(), 1); - check_spends!(txn[0], funding_tx); - txn.remove(0) - } else { - assert_eq!(txn.len(), 2); - if txn[0].input[0].previous_output.txid == funding_tx.compute_txid() { - check_spends!(txn[0], funding_tx); - check_spends!(txn[1], txn[0]); - txn.remove(0) - } else { - check_spends!(txn[1], funding_tx); - check_spends!(txn[0], txn[1]); - txn.remove(1) - } - } - }; - - // Mark it as unavailable again to now test the HTLC transaction. We'll mine the commitment such - // that the HTLC transaction is retried. - let sign_htlc_op = if remote_commitment { - SignerOp::SignCounterpartyHtlcTransaction - } else { - SignerOp::SignHolderHtlcTransaction - }; - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); - mine_transaction(&nodes[0], &commitment_tx); - - check_added_monitors(&nodes[0], 1); - check_closed_broadcast(&nodes[0], 1, true); - check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, false, &[nodes[1].node.get_our_node_id()], 100_000); - - // If the counterparty broadcast its latest commitment, we need to mine enough blocks for the - // HTLC timeout. - if remote_commitment { - connect_blocks(&nodes[0], TEST_FINAL_CLTV); - } - - // No HTLC transaction should be broadcast as the signer is not available yet. - if anchors && !remote_commitment { - handle_bump_htlc_event(&nodes[0], 1); - } - let txn = nodes[0].tx_broadcaster.txn_broadcast(); - assert!(txn.is_empty(), "expected no transaction to be broadcast, got {:?}", txn); - - // Mark it as available now, we should see the signed HTLC transaction. - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); - get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); - - if anchors && !remote_commitment { - handle_bump_htlc_event(&nodes[0], 1); - } - { - let txn = nodes[0].tx_broadcaster.txn_broadcast(); - assert_eq!(txn.len(), 1); - check_spends!(txn[0], commitment_tx, coinbase_tx); - } -} - -#[test] -fn test_async_holder_signatures_no_anchors() { - do_test_async_holder_signatures(false, false); -} - -#[test] -fn test_async_holder_signatures_remote_commitment_no_anchors() { - do_test_async_holder_signatures(false, true); -} - -#[test] -fn test_async_holder_signatures_anchors() { - do_test_async_holder_signatures(true, false); -} - -#[test] -fn test_async_holder_signatures_remote_commitment_anchors() { - do_test_async_holder_signatures(true, true); -} - -#[test] -fn test_closing_signed() { - do_test_closing_signed(false, false); - do_test_closing_signed(true, false); - do_test_closing_signed(false, true); - do_test_closing_signed(true, true); -} - -fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { - // Based off of `expect_channel_shutdown_state`. - // Test that we can asynchronously sign closing transactions. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Avoid extra channel ready message upon reestablish later - send_payment(&nodes[0], &vec![&nodes[1]][..], 8_000_000); - - expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NotShuttingDown); - - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - - expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NotShuttingDown); - - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - - expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); - - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NegotiatingClosingFee); - expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); - - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[0].node.signer_unblocked(None); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[1].node.signer_unblocked(None); - - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - - nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert!(events.is_empty(), "Expected no events, got {:?}", events); - nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); - - if extra_closing_signed { - let node_1_closing_signed_2_bad = { - let mut node_1_closing_signed_2 = node_1_closing_signed.clone(); - let holder_script = nodes[0].keys_manager.get_shutdown_scriptpubkey().unwrap(); - let counterparty_script = nodes[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); - let funding_outpoint = bitcoin::OutPoint { txid: funding_tx.compute_txid(), vout: 0 }; - let closing_tx_2 = ClosingTransaction::new(50000, 0, holder_script.into(), - counterparty_script.into(), funding_outpoint); - - let per_peer_state = nodes[1].node.per_peer_state.read().unwrap(); - let mut chan_lock = per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap(); - let channel = chan_lock.channel_by_id.get_mut(&chan_id).unwrap(); - let (funding, context) = channel.funding_and_context_mut(); - - let signer = context.get_mut_signer().as_mut_ecdsa().unwrap(); - let signature = signer.sign_closing_transaction(&funding.channel_transaction_parameters, &closing_tx_2, &Secp256k1::new()).unwrap(); - node_1_closing_signed_2.signature = signature; - node_1_closing_signed_2 - }; - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed_2_bad); - - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::HandleError { - action: msgs::ErrorAction::SendWarningMessage { .. }, ref node_id - } => { - assert_eq!(node_id, &nodes[1].node.get_our_node_id()); - }, - _ => panic!("Unexpected event: {:?}", events[0]), - }; - } - - if reconnect { - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 8; - *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 8; - - connect_nodes(&nodes[0], &nodes[1]); - let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); - - let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(node_0_msgs.len(), 2); - let node_0_2nd_shutdown = match node_0_msgs[0] { - MessageSendEvent::SendShutdown { ref msg, .. } => { - msg.clone() - }, - _ => panic!(), - }; - let node_0_2nd_closing_signed = match node_0_msgs[1] { - MessageSendEvent::SendClosingSigned { ref msg, .. } => { - msg.clone() - }, - _ => panic!(), - }; - let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - } - - nodes[0].node.signer_unblocked(None); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_closing_signed.is_none()); - - assert!(nodes[0].node.list_channels().is_empty()); - assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); -} - -#[test] -fn test_no_disconnect_while_async_revoke_and_ack_expecting_remote_commitment_signed() { - // Nodes with async signers may be expecting to receive a `commitment_signed` from the - // counterparty even if a `revoke_and_ack` has yet to be sent due to an async signer. Test that - // we don't disconnect the async signer node due to not receiving the `commitment_signed` within - // the timeout while the `revoke_and_ack` is not ready. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - let payment_amount = 1_000_000; - send_payment(&nodes[0], &[&nodes[1]], payment_amount * 4); - - nodes[1].disable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); - - // We'll send a payment from both nodes to each other. - let (route1, payment_hash1, _, payment_secret1) = - get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); - let onion1 = RecipientOnionFields::secret_only(payment_secret1); - let payment_id1 = PaymentId(payment_hash1.0); - nodes[0].node.send_payment_with_route(route1, payment_hash1, onion1, payment_id1).unwrap(); - check_added_monitors(&nodes[0], 1); - - let (route2, payment_hash2, _, payment_secret2) = - get_route_and_payment_hash!(&nodes[1], &nodes[0], payment_amount); - let onion2 = RecipientOnionFields::secret_only(payment_secret2); - let payment_id2 = PaymentId(payment_hash2.0); - nodes[1].node.send_payment_with_route(route2, payment_hash2, onion2, payment_id2).unwrap(); - check_added_monitors(&nodes[1], 1); - - let update = get_htlc_update_msgs!(&nodes[0], node_id_1); - nodes[1].node.handle_update_add_htlc(node_id_0, &update.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &update.commitment_signed); - check_added_monitors(&nodes[1], 1); - - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_update_add_htlc(node_id_1, &update.update_add_htlcs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); - check_added_monitors(&nodes[0], 1); - - // nodes[0] can only respond with a `revoke_and_ack`. The `commitment_signed` that would follow - // is blocked on receiving a counterparty `revoke_and_ack`, which nodes[1] is still pending on. - let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); - nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); - check_added_monitors(&nodes[1], 1); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // nodes[0] will disconnect the counterparty as it's waiting on a `revoke_and_ack`. - // nodes[1] is waiting on a `commitment_signed`, but since it hasn't yet sent its own - // `revoke_and_ack`, it shouldn't disconnect yet. - for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { - nodes[0].node.timer_tick_occurred(); - nodes[1].node.timer_tick_occurred(); - } - let has_disconnect_event = |event| { - matches!( - event, MessageSendEvent::HandleError { action , .. } - if matches!(action, msgs::ErrorAction::DisconnectPeerWithWarning { .. }) - ) - }; - assert!(nodes[0].node.get_and_clear_pending_msg_events().into_iter().any(has_disconnect_event)); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); -} - -#[test] -fn test_no_disconnect_while_async_commitment_signed_expecting_remote_revoke_and_ack() { - // Nodes with async signers may be expecting to receive a `revoke_and_ack` from the - // counterparty even if a `commitment_signed` has yet to be sent due to an async signer. Test - // that we don't disconnect the async signer node due to not receiving the `revoke_and_ack` - // within the timeout while the `commitment_signed` is not ready. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - // Route a payment and attempt to claim it. - let payment_amount = 1_000_000; - let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], payment_amount); - nodes[1].node.claim_funds(preimage); - check_added_monitors(&nodes[1], 1); - - // We'll disable signing counterparty commitments on the payment sender. - nodes[0].disable_channel_signer_op(&node_id_1, &chan_id, SignerOp::SignCounterpartyCommitment); - - // After processing the `update_fulfill`, they'll only be able to send `revoke_and_ack` until - // the `commitment_signed` is no longer pending. - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); - check_added_monitors(&nodes[0], 1); - - let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); - nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); - check_added_monitors(&nodes[1], 1); - - // The payment sender shouldn't disconnect the counterparty due to a missing `revoke_and_ack` - // because the `commitment_signed` isn't ready yet. The payment recipient may disconnect the - // sender because it doesn't have an async signer and it's expecting a timely - // `commitment_signed` response. - for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { - nodes[0].node.timer_tick_occurred(); - nodes[1].node.timer_tick_occurred(); - } - let has_disconnect_event = |event| { - matches!( - event, MessageSendEvent::HandleError { action , .. } - if matches!(action, msgs::ErrorAction::DisconnectPeerWithWarning { .. }) - ) - }; - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().into_iter().any(has_disconnect_event)); - - expect_payment_sent(&nodes[0], preimage, None, false, false); - expect_payment_claimed!(nodes[1], payment_hash, payment_amount); -} +// #![cfg_attr(rustfmt, rustfmt_skip)] + +// // This file is Copyright its original authors, visible in version control +// // history. +// // +// // This file is licensed under the Apache License, Version 2.0 or the MIT license +// // , at your option. +// // You may not use this file except in accordance with one or both of these +// // licenses. + +// //! Tests for asynchronous signing. These tests verify that the channel state machine behaves +// //! properly with a signer implementation that asynchronously derives signatures. + +// use crate::prelude::*; +// use bitcoin::secp256k1::Secp256k1; +// use bitcoin::{Transaction, TxOut, TxIn, Amount}; +// use bitcoin::locktime::absolute::LockTime; +// use bitcoin::transaction::Version; + +// use crate::chain::channelmonitor::LATENCY_GRACE_PERIOD_BLOCKS; +// use crate::chain::ChannelMonitorUpdateStatus; +// use crate::events::bump_transaction::sync::WalletSourceSync; +// use crate::events::{ClosureReason, Event}; +// use crate::ln::chan_utils::ClosingTransaction; +// use crate::ln::channel::DISCONNECT_PEER_AWAITING_RESPONSE_TICKS; +// use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState}; +// use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields}; +// use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent}; +// use crate::ln::{functional_test_utils::*, msgs}; +// use crate::sign::ecdsa::EcdsaChannelSigner; +// use crate::sign::SignerProvider; +// use crate::util::test_channel_signer::SignerOp; +// use crate::util::logger::Logger; + +// #[test] +// fn test_open_channel() { +// do_test_open_channel(false); +// do_test_open_channel(true); +// } + +// fn do_test_open_channel(zero_conf: bool) { +// // Simulate acquiring the commitment point for `open_channel` and `accept_channel` asynchronously. +// let mut manually_accept_config = test_default_channel_config(); +// manually_accept_config.manually_accept_inbound_channels = zero_conf; + +// 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, Some(manually_accept_config)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // Open an outbound channel simulating an async signer. +// let channel_value_satoshis = 100000; +// let user_channel_id = 42; +// nodes[0].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); +// let channel_id_0 = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, 10001, user_channel_id, None, None).unwrap(); + +// { +// let msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// assert!(msgs.is_empty(), "Expected no message events; got {:?}", msgs); +// } + +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &channel_id_0, SignerOp::GetPerCommitmentPoint); +// nodes[0].node.signer_unblocked(None); + +// // nodes[0] --- open_channel --> nodes[1] +// let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// // Handle an inbound channel simulating an async signer. +// nodes[1].disable_next_channel_signer_op(SignerOp::GetPerCommitmentPoint); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + +// if zero_conf { +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); +// match &events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( +// temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) +// .expect("Unable to accept inbound zero-conf channel"); +// }, +// ev => panic!("Expected OpenChannelRequest, not {:?}", ev) +// } +// } else { +// let msgs = nodes[1].node.get_and_clear_pending_msg_events(); +// assert!(msgs.is_empty(), "Expected no message events; got {:?}", msgs); +// } + +// let channel_id_1 = { +// let channels = nodes[1].node.list_channels(); +// assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); +// channels[0].channel_id +// }; + +// nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &channel_id_1, SignerOp::GetPerCommitmentPoint); +// nodes[1].node.signer_unblocked(None); + +// // nodes[0] <-- accept_channel --- nodes[1] +// get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); +// } + +// #[test] +// fn test_funding_created() { +// do_test_funding_created(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); +// do_test_funding_created(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); +// } + +// fn do_test_funding_created(signer_ops: Vec) { +// // Simulate acquiring the signature for `funding_created` asynchronously. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + +// // nodes[0] --- open_channel --> nodes[1] +// let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + +// // nodes[0] <-- accept_channel --- nodes[1] +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + +// // nodes[0] --- funding_created --> nodes[1] +// // +// // But! Let's make node[0]'s signer be unavailable: we should *not* broadcast a funding_created +// // message... +// let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); +// for op in signer_ops.iter() { +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &temporary_channel_id, *op); +// } +// nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); +// check_added_monitors(&nodes[0], 0); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so +// // we have to dig out the real channel ID. +// let chan_id = { +// let channels = nodes[0].node.list_channels(); +// assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); +// channels[0].channel_id +// }; + +// for op in signer_ops.iter() { +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, *op); +// nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); +// } + +// let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); +// check_added_monitors(&nodes[1], 1); +// expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + +// // nodes[0] <-- funding_signed --- nodes[1] +// let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); +// check_added_monitors(&nodes[0], 1); +// expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); +// } + +// #[test] +// fn test_funding_signed() { +// do_test_funding_signed(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); +// do_test_funding_signed(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); +// } + +// fn do_test_funding_signed(signer_ops: Vec) { +// // Simulate acquiring the signature for `funding_signed` asynchronously. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + +// // nodes[0] --- open_channel --> nodes[1] +// let mut open_chan_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_chan_msg); + +// // nodes[0] <-- accept_channel --- nodes[1] +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + +// // nodes[0] --- funding_created --> nodes[1] +// let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); +// nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); +// check_added_monitors(&nodes[0], 0); + +// let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + +// // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should +// // *not* broadcast a `funding_signed`... +// for op in signer_ops.iter() { +// nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); +// } +// nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); +// check_added_monitors(&nodes[1], 1); + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so +// // we have to dig out the real channel ID. +// let chan_id = { +// let channels = nodes[0].node.list_channels(); +// assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); +// channels[0].channel_id +// }; +// for op in signer_ops.iter() { +// nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); +// nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); +// if *op == SignerOp::SignCounterpartyCommitment { +// expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + +// // nodes[0] <-- funding_signed --- nodes[1] +// let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed_msg); +// check_added_monitors(&nodes[0], 1); +// expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); +// } else { +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// } +// } +// } + +// #[test] +// fn test_async_commitment_signature_for_commitment_signed() { +// for i in 0..=8 { +// let enable_signer_op_order = vec![ +// SignerOp::GetPerCommitmentPoint, +// SignerOp::ReleaseCommitmentSecret, +// SignerOp::SignCounterpartyCommitment, +// ].into_iter().filter(|&op| i & (1 << op as u8) != 0).collect(); +// do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order); +// } +// } + +// fn do_test_async_commitment_signature_for_commitment_signed_revoke_and_ack(enable_signer_op_order: Vec) { +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// // Send a payment. +// let src = &nodes[0]; +// let dst = &nodes[1]; +// let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); +// src.node.send_payment_with_route(route, our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); +// check_added_monitors!(src, 1); + +// // Pass the payment along the route. +// let payment_event = { +// let mut events = src.node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// SendEvent::from_event(events.remove(0)) +// }; +// assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); +// assert_eq!(payment_event.msgs.len(), 1); + +// dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); + +// // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a +// // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. +// dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::GetPerCommitmentPoint); +// dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::ReleaseCommitmentSecret); +// dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); +// check_added_monitors(dst, 1); + +// let mut enabled_signer_ops = new_hash_set(); +// log_trace!(dst.logger, "enable_signer_op_order={:?}", enable_signer_op_order); +// for op in enable_signer_op_order { +// enabled_signer_ops.insert(op); +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, op); +// dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); + +// if enabled_signer_ops.contains(&SignerOp::GetPerCommitmentPoint) && enabled_signer_ops.contains(&SignerOp::ReleaseCommitmentSecret) { +// // We are just able to send revoke_and_ack +// if op == SignerOp::GetPerCommitmentPoint || op == SignerOp::ReleaseCommitmentSecret { +// get_event_msg!(dst, MessageSendEvent::SendRevokeAndACK, src.node.get_our_node_id()); +// } +// // We either just sent or previously sent revoke_and_ack +// // and now we are able to send commitment_signed +// if op == SignerOp::SignCounterpartyCommitment { +// get_htlc_update_msgs(dst, &src.node.get_our_node_id()); +// } +// } else { +// // We can't send either message until RAA is unblocked +// let events = dst.node.get_and_clear_pending_msg_events(); +// assert!(events.is_empty(), "expected no message, got {}", events.len()); +// } +// } +// } + +// #[test] +// fn test_funding_signed_0conf() { +// do_test_funding_signed_0conf(vec![SignerOp::GetPerCommitmentPoint, SignerOp::SignCounterpartyCommitment]); +// do_test_funding_signed_0conf(vec![SignerOp::SignCounterpartyCommitment, SignerOp::GetPerCommitmentPoint]); +// } + +// fn do_test_funding_signed_0conf(signer_ops: Vec) { +// // Simulate acquiring the signature for `funding_signed` asynchronously for a zero-conf channel. +// let mut manually_accept_config = test_default_channel_config(); +// manually_accept_config.manually_accept_inbound_channels = true; + +// 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, Some(manually_accept_config)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // nodes[0] --- open_channel --> nodes[1] +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); +// let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + +// { +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1, "Expected one event, got {}", events.len()); +// match &events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( +// temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None) +// .expect("Unable to accept inbound zero-conf channel"); +// }, +// ev => panic!("Expected OpenChannelRequest, not {:?}", ev) +// } +// } + +// // nodes[0] <-- accept_channel --- nodes[1] +// let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); +// assert_eq!(accept_channel.common_fields.minimum_depth, 0, "Expected minimum depth of 0"); +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + +// // nodes[0] --- funding_created --> nodes[1] +// let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); +// nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); +// check_added_monitors(&nodes[0], 0); + +// let mut funding_created_msg = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + +// // Now let's make node[1]'s signer be unavailable while handling the `funding_created`. It should +// // *not* broadcast a `funding_signed`... +// for op in signer_ops.iter() { +// nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &temporary_channel_id, *op); +// } +// nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created_msg); +// check_added_monitors(&nodes[1], 1); + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now re-enable the signer and simulate a retry. The temporary_channel_id won't work anymore so +// // we have to dig out the real channel ID. +// let chan_id = { +// let channels = nodes[0].node.list_channels(); +// assert_eq!(channels.len(), 1, "expected one channel, not {}", channels.len()); +// channels[0].channel_id +// }; + +// // At this point, we basically expect the channel to open like a normal zero-conf channel. +// for op in signer_ops.iter() { +// nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, *op); +// nodes[1].node.signer_unblocked(Some((nodes[0].node.get_our_node_id(), chan_id))); +// } + +// let (funding_signed, channel_ready_1) = { +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 2); +// let funding_signed = match &events[0] { +// MessageSendEvent::SendFundingSigned { msg, .. } => msg.clone(), +// ev => panic!("Expected SendFundingSigned, not {:?}", ev) +// }; +// let channel_ready = match &events[1] { +// MessageSendEvent::SendChannelReady { msg, .. } => msg.clone(), +// ev => panic!("Expected SendChannelReady, not {:?}", ev) +// }; +// (funding_signed, channel_ready) +// }; + +// nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &funding_signed); +// expect_channel_pending_event(&nodes[0], &nodes[1].node.get_our_node_id()); +// expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); +// check_added_monitors(&nodes[0], 1); + +// let channel_ready_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id()); + +// nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &channel_ready_1); +// expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &channel_ready_0); +// expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + +// let channel_update_0 = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); +// let channel_update_1 = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); + +// nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &channel_update_1); +// nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &channel_update_0); + +// assert_eq!(nodes[0].node.list_usable_channels().len(), 1); +// assert_eq!(nodes[1].node.list_usable_channels().len(), 1); +// } + +// #[derive(PartialEq)] +// enum UnblockSignerAcrossDisconnectCase { +// AtEnd, +// BeforeMonitorRestored, +// BeforeReestablish, +// } + +// #[test] +// fn test_async_raa_peer_disconnect() { +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, true); +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd, false); +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, true); +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored, false); +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, true); +// do_test_async_raa_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish, false); +// } + +// fn do_test_async_raa_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase, raa_blocked_by_commit_point: bool) { +// // `raa_blocked_by_commit_point` determines whether we block the RAA by blocking the +// // signer on `GetPerCommitmentPoint` or `ReleaseCommitmentSecret`. +// let block_raa_signer_op = if raa_blocked_by_commit_point { +// SignerOp::GetPerCommitmentPoint +// } else { +// SignerOp::ReleaseCommitmentSecret +// }; +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// // Send a payment. +// let src = &nodes[0]; +// let dst = &nodes[1]; +// let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); +// src.node.send_payment_with_route(route, our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); +// check_added_monitors!(src, 1); + +// // Pass the payment along the route. +// let payment_event = { +// let mut events = src.node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// SendEvent::from_event(events.remove(0)) +// }; +// assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); +// assert_eq!(payment_event.msgs.len(), 1); + +// dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { +// // Fail to persist the monitor update when handling the commitment_signed. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } + +// // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a +// // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. +// dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); +// dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); +// check_added_monitors(dst, 1); + +// let events = dst.node.get_and_clear_pending_msg_events(); +// assert!(events.is_empty(), "expected no message, got {}", events.len()); + +// // Now disconnect and reconnect the peers. +// src.node.peer_disconnected(dst.node.get_our_node_id()); +// dst.node.peer_disconnected(src.node.get_our_node_id()); + +// // do reestablish stuff +// src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { +// features: dst.node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(src, dst); +// assert_eq!(reestablish_1.len(), 1); +// dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { +// features: src.node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(dst, src); +// assert_eq!(reestablish_2.len(), 1); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeReestablish { +// // Reenable the signer before the reestablish. +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); +// } + +// dst.node.handle_channel_reestablish(src.node.get_our_node_id(), &reestablish_1[0]); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); +// dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); +// check_added_monitors!(dst, 0); +// } + +// // Expect the RAA +// let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); +// if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { +// assert!(revoke_and_ack.is_none()); +// assert!(commitment_signed.is_none()); +// } else { +// assert!(revoke_and_ack.is_some()); +// assert!(commitment_signed.is_some()); +// assert!(resend_order == RAACommitmentOrder::RevokeAndACKFirst); +// } + +// // Mark dst's signer as available and retry: we now expect to see dst's RAA + CS. +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, block_raa_signer_op); +// dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); + +// if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { +// let (_, revoke_and_ack, commitment_signed, resend_order) = handle_chan_reestablish_msgs!(dst, src); +// assert!(revoke_and_ack.is_some()); +// assert!(commitment_signed.is_some()); +// assert!(resend_order == RAACommitmentOrder::RevokeAndACKFirst); +// } else { +// // Make sure we don't double send the RAA. +// let (_, revoke_and_ack, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); +// assert!(revoke_and_ack.is_none()); +// assert!(commitment_signed.is_none()); +// } +// } + +// #[test] +// fn test_async_commitment_signature_peer_disconnect() { +// // This tests that if our signer is blocked and gets unblocked +// // after a peer disconnect + channel reestablish, we'll send the right messages. +// do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::AtEnd); +// } + +// #[test] +// fn test_async_commitment_signature_peer_disconnect_signer_restored_before_monitor_completion() { +// // This tests that if we were pending a monitor update completion across a disconnect, +// // and needed to send a CS, that if our signer becomes available before the monitor +// // update completes, then we don't send duplicate messages upon calling `signer_unblocked` +// // after the monitor update completes. +// do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored); +// } + +// #[test] +// fn test_async_commitment_signature_peer_disconnect_signer_restored_before_reestablish() { +// // This tests that if we tried to send a commitment_signed, but our signer was blocked, +// // if we disconnect, reconnect, the signer becomes available, then handle channel_reestablish, +// // that we don't send duplicate messages upon calling `signer_unblocked`. +// do_test_async_commitment_signature_peer_disconnect(UnblockSignerAcrossDisconnectCase::BeforeReestablish); +// } + +// fn do_test_async_commitment_signature_peer_disconnect(test_case: UnblockSignerAcrossDisconnectCase) { +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// // Send a payment. +// let src = &nodes[0]; +// let dst = &nodes[1]; +// let (route, our_payment_hash, _our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(src, dst, 8000000); +// src.node.send_payment_with_route(route, our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); +// check_added_monitors!(src, 1); + +// // Pass the payment along the route. +// let payment_event = { +// let mut events = src.node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// SendEvent::from_event(events.remove(0)) +// }; +// assert_eq!(payment_event.node_id, dst.node.get_our_node_id()); +// assert_eq!(payment_event.msgs.len(), 1); + +// dst.node.handle_update_add_htlc(src.node.get_our_node_id(), &payment_event.msgs[0]); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { +// // Fail to persist the monitor update when handling the commitment_signed. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } + +// // Mark dst's signer as unavailable and handle src's commitment_signed: while dst won't yet have a +// // `commitment_signed` of its own to offer, it should publish a `revoke_and_ack`. +// dst.disable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// dst.node.handle_commitment_signed_batch_test(src.node.get_our_node_id(), &payment_event.commitment_msg); +// check_added_monitors(dst, 1); + +// if test_case != UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { +// get_event_msg!(dst, MessageSendEvent::SendRevokeAndACK, src.node.get_our_node_id()); +// } + +// // Now disconnect and reconnect the peers. +// src.node.peer_disconnected(dst.node.get_our_node_id()); +// dst.node.peer_disconnected(src.node.get_our_node_id()); + +// // do reestablish stuff +// src.node.peer_connected(dst.node.get_our_node_id(), &msgs::Init { +// features: dst.node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(src, dst); +// assert_eq!(reestablish_1.len(), 1); +// dst.node.peer_connected(src.node.get_our_node_id(), &msgs::Init { +// features: src.node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(dst, src); +// assert_eq!(reestablish_2.len(), 1); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeReestablish { +// // Reenable the signer before the reestablish. +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// } + +// dst.node.handle_channel_reestablish(src.node.get_our_node_id(), &reestablish_1[0]); + +// if test_case == UnblockSignerAcrossDisconnectCase::BeforeMonitorRestored { +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = dst.chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); +// dst.chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); +// check_added_monitors!(dst, 0); +// } + +// // Expect the RAA +// let (_, revoke_and_ack, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); +// assert!(revoke_and_ack.is_some()); +// if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { +// assert!(commitment_signed.is_none()); +// } else { +// assert!(commitment_signed.is_some()); +// } + +// // Mark dst's signer as available and retry: we now expect to see dst's `commitment_signed`. +// dst.enable_channel_signer_op(&src.node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// dst.node.signer_unblocked(Some((src.node.get_our_node_id(), chan_id))); + +// if test_case == UnblockSignerAcrossDisconnectCase::AtEnd { +// let (_, _, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); +// assert!(commitment_signed.is_some()); +// } else { +// // Make sure we don't double send the CS. +// let (_, _, commitment_signed, _) = handle_chan_reestablish_msgs!(dst, src); +// assert!(commitment_signed.is_none()); +// } +// } + +// #[test] +// fn test_async_commitment_signature_ordering_reestablish() { +// do_test_async_commitment_signature_ordering(false); +// } + +// #[test] +// fn test_async_commitment_signature_ordering_monitor_restored() { +// do_test_async_commitment_signature_ordering(true); +// } + +// fn do_test_async_commitment_signature_ordering(monitor_update_failure: bool) { +// // Across disconnects we may end up in a situation where we need to send a +// // commitment_signed and then revoke_and_ack. We need to make sure that if +// // the signer is pending for commitment_signed but not revoke_and_ack, we don't +// // screw up the order by sending the revoke_and_ack first. +// // +// // We test this for both the case where we send messages after a channel +// // reestablish, as well as restoring a channel after persisting +// // a monitor update. +// // +// // The set up for this test is based on +// // `test_drop_messages_peer_disconnect_dual_htlc`. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let (_, _, chan_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// let (payment_preimage_1, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// // Start to send the second update_add_htlc + commitment_signed, but don't actually make it +// // to the peer. +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, +// RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); + +// // Send back update_fulfill_htlc + commitment_signed for the first payment. +// nodes[1].node.claim_funds(payment_preimage_1); +// expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); +// check_added_monitors!(nodes[1], 1); + +// // Handle the update_fulfill_htlc, but fail to persist the monitor update when handling the +// // commitment_signed. +// let events_2 = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events_2.len(), 1); +// match events_2[0] { +// MessageSendEvent::UpdateHTLCs { node_id: _, channel_id: _, updates: msgs::CommitmentUpdate { ref update_fulfill_htlcs, ref commitment_signed, .. } } => { +// nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]); +// expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); +// if monitor_update_failure { +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } +// nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), commitment_signed); +// if monitor_update_failure { +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// } else { +// let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); +// } +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[0], 1); +// }, +// _ => panic!("Unexpected event"), +// } + +// // Disconnect and reconnect the peers so that nodes[0] will +// // need to re-send the commitment update *and then* revoke_and_ack. +// nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); +// nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + +// nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { +// features: nodes[1].node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert_eq!(reestablish_1.len(), 1); +// nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { +// features: nodes[0].node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); +// assert_eq!(reestablish_2.len(), 1); + +// // With a fully working signer, here we would send a commitment_signed, +// // and then revoke_and_ack. With commitment_signed disabled, since +// // our ordering is CS then RAA, we should make sure we don't send the RAA. +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &reestablish_2[0]); +// let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert!(as_resp.0.is_none()); +// assert!(as_resp.1.is_none()); +// assert!(as_resp.2.is_none()); + +// if monitor_update_failure { +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); +// check_added_monitors!(nodes[0], 0); +// } + +// // Make sure that on signer_unblocked we have the same behavior (even though RAA is ready, +// // we don't send CS yet). +// nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); +// let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert!(as_resp.0.is_none()); +// assert!(as_resp.1.is_none()); +// assert!(as_resp.2.is_none()); + +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignCounterpartyCommitment); +// nodes[0].node.signer_unblocked(Some((nodes[1].node.get_our_node_id(), chan_id))); + +// let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); +// nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &reestablish_1[0]); +// let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); + +// assert!(as_resp.0.is_none()); +// assert!(bs_resp.0.is_none()); + +// assert!(bs_resp.1.is_none()); +// assert!(bs_resp.2.is_none()); + +// assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst); + +// // Now that everything is restored, get the CS + RAA and handle them. +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed); +// nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap()); +// let (bs_revoke_and_ack, bs_second_commitment_signed) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); +// check_added_monitors!(nodes[1], 2); + +// // The rest of this is boilerplate for resolving the previous state. + +// nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); +// let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); +// check_added_monitors!(nodes[0], 1); + +// nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_second_commitment_signed); +// let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id()); +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[0], 1); + +// nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed); +// let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id()); +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[1], 1); + +// nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &as_revoke_and_ack); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[0], 1); + +// expect_pending_htlcs_forwardable!(nodes[1]); + +// let events_5 = nodes[1].node.get_and_clear_pending_events(); +// check_payment_claimable(&events_5[0], payment_hash_2, payment_secret_2, 1_000_000, None, nodes[1].node.get_our_node_id()); + +// expect_payment_path_successful!(nodes[0]); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } + +// fn do_test_async_holder_signatures(anchors: bool, remote_commitment: bool) { +// // Ensures that we can obtain holder signatures for commitment and HTLC transactions +// // asynchronously by allowing their retrieval to fail and retrying via +// // `ChannelMonitor::signer_unblocked`. +// let mut config = test_default_channel_config(); +// if anchors { +// config.channel_handshake_config.negotiate_anchors_zero_fee_htlc_tx = true; +// config.manually_accept_inbound_channels = true; +// } + +// 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, &[Some(config.clone()), Some(config)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let closing_node = if remote_commitment { &nodes[1] } else { &nodes[0] }; +// let coinbase_tx = Transaction { +// version: Version::TWO, +// lock_time: LockTime::ZERO, +// input: vec![TxIn { ..Default::default() }], +// output: vec![ +// TxOut { +// value: Amount::ONE_BTC, +// script_pubkey: closing_node.wallet_source.get_change_script().unwrap(), +// }, +// ], +// }; +// if anchors { +// *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 2; +// *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 2; +// closing_node.wallet_source.add_utxo(bitcoin::OutPoint { txid: coinbase_tx.compute_txid(), vout: 0 }, coinbase_tx.output[0].value); +// } + +// // Route an HTLC and set the signer as unavailable. +// let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); +// let error_message = "Channel force-closed"; + +// if remote_commitment { +// // Make the counterparty broadcast its latest commitment. +// nodes[1].node.force_close_broadcasting_latest_txn(&chan_id, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); +// check_added_monitors(&nodes[1], 1); +// check_closed_broadcast(&nodes[1], 1, true); +// check_closed_event(&nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, false, &[nodes[0].node.get_our_node_id()], 100_000); +// } else { +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); +// // We'll connect blocks until the sender has to go onchain to time out the HTLC. +// connect_blocks(&nodes[0], TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + 1); + +// // No transaction should be broadcast since the signer is not available yet. +// assert!(nodes[0].tx_broadcaster.txn_broadcast().is_empty()); +// assert!(nodes[0].chain_monitor.chain_monitor.get_and_clear_pending_events().is_empty()); + +// // Mark it as available now, we should see the signed commitment transaction. +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderHtlcTransaction); +// get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); +// } + +// let commitment_tx = { +// let mut txn = closing_node.tx_broadcaster.txn_broadcast(); +// if anchors || remote_commitment { +// assert_eq!(txn.len(), 1); +// check_spends!(txn[0], funding_tx); +// txn.remove(0) +// } else { +// assert_eq!(txn.len(), 2); +// if txn[0].input[0].previous_output.txid == funding_tx.compute_txid() { +// check_spends!(txn[0], funding_tx); +// check_spends!(txn[1], txn[0]); +// txn.remove(0) +// } else { +// check_spends!(txn[1], funding_tx); +// check_spends!(txn[0], txn[1]); +// txn.remove(1) +// } +// } +// }; + +// // Mark it as unavailable again to now test the HTLC transaction. We'll mine the commitment such +// // that the HTLC transaction is retried. +// let sign_htlc_op = if remote_commitment { +// SignerOp::SignCounterpartyHtlcTransaction +// } else { +// SignerOp::SignHolderHtlcTransaction +// }; +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); +// mine_transaction(&nodes[0], &commitment_tx); + +// check_added_monitors(&nodes[0], 1); +// check_closed_broadcast(&nodes[0], 1, true); +// check_closed_event(&nodes[0], 1, ClosureReason::CommitmentTxConfirmed, false, &[nodes[1].node.get_our_node_id()], 100_000); + +// // If the counterparty broadcast its latest commitment, we need to mine enough blocks for the +// // HTLC timeout. +// if remote_commitment { +// connect_blocks(&nodes[0], TEST_FINAL_CLTV); +// } + +// // No HTLC transaction should be broadcast as the signer is not available yet. +// if anchors && !remote_commitment { +// handle_bump_htlc_event(&nodes[0], 1); +// } +// let txn = nodes[0].tx_broadcaster.txn_broadcast(); +// assert!(txn.is_empty(), "expected no transaction to be broadcast, got {:?}", txn); + +// // Mark it as available now, we should see the signed HTLC transaction. +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignHolderCommitment); +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, sign_htlc_op); +// get_monitor!(nodes[0], chan_id).signer_unblocked(nodes[0].tx_broadcaster, nodes[0].fee_estimator, &nodes[0].logger); + +// if anchors && !remote_commitment { +// handle_bump_htlc_event(&nodes[0], 1); +// } +// { +// let txn = nodes[0].tx_broadcaster.txn_broadcast(); +// assert_eq!(txn.len(), 1); +// check_spends!(txn[0], commitment_tx, coinbase_tx); +// } +// } + +// #[test] +// fn test_async_holder_signatures_no_anchors() { +// do_test_async_holder_signatures(false, false); +// } + +// #[test] +// fn test_async_holder_signatures_remote_commitment_no_anchors() { +// do_test_async_holder_signatures(false, true); +// } + +// #[test] +// fn test_async_holder_signatures_anchors() { +// do_test_async_holder_signatures(true, false); +// } + +// #[test] +// fn test_async_holder_signatures_remote_commitment_anchors() { +// do_test_async_holder_signatures(true, true); +// } + +// #[test] +// fn test_closing_signed() { +// do_test_closing_signed(false, false); +// do_test_closing_signed(true, false); +// do_test_closing_signed(false, true); +// do_test_closing_signed(true, true); +// } + +// fn do_test_closing_signed(extra_closing_signed: bool, reconnect: bool) { +// // Based off of `expect_channel_shutdown_state`. +// // Test that we can asynchronously sign closing transactions. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let (_, _, chan_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// // Avoid extra channel ready message upon reestablish later +// send_payment(&nodes[0], &vec![&nodes[1]][..], 8_000_000); + +// expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NotShuttingDown); + +// nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); + +// expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NotShuttingDown); + +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + +// expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); + +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::NegotiatingClosingFee); +// expect_channel_shutdown_state!(nodes[1], chan_id, ChannelShutdownState::NegotiatingClosingFee); + +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert!(events.is_empty(), "Expected no events, got {:?}", events); +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); +// nodes[0].node.signer_unblocked(None); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].disable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); + +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert!(events.is_empty(), "Expected no events, got {:?}", events); +// nodes[1].enable_channel_signer_op(&nodes[0].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); +// nodes[1].node.signer_unblocked(None); + +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); + +// nodes[0].disable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert!(events.is_empty(), "Expected no events, got {:?}", events); +// nodes[0].enable_channel_signer_op(&nodes[1].node.get_our_node_id(), &chan_id, SignerOp::SignClosingTransaction); + +// if extra_closing_signed { +// let node_1_closing_signed_2_bad = { +// let mut node_1_closing_signed_2 = node_1_closing_signed.clone(); +// let holder_script = nodes[0].keys_manager.get_shutdown_scriptpubkey().unwrap(); +// let counterparty_script = nodes[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); +// let funding_outpoint = bitcoin::OutPoint { txid: funding_tx.compute_txid(), vout: 0 }; +// let closing_tx_2 = ClosingTransaction::new(50000, 0, holder_script.into(), +// counterparty_script.into(), funding_outpoint); + +// let per_peer_state = nodes[1].node.per_peer_state.read().unwrap(); +// let mut chan_lock = per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap(); +// let channel = chan_lock.channel_by_id.get_mut(&chan_id).unwrap(); +// let (funding, context) = channel.funding_and_context_mut(); + +// let signer = context.get_mut_signer().as_mut_ecdsa().unwrap(); +// let signature = signer.sign_closing_transaction(&funding.channel_transaction_parameters, &closing_tx_2, &Secp256k1::new()).unwrap(); +// node_1_closing_signed_2.signature = signature; +// node_1_closing_signed_2 +// }; +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed_2_bad); + +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::HandleError { +// action: msgs::ErrorAction::SendWarningMessage { .. }, ref node_id +// } => { +// assert_eq!(node_id, &nodes[1].node.get_our_node_id()); +// }, +// _ => panic!("Unexpected event: {:?}", events[0]), +// }; +// } + +// if reconnect { +// nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); +// nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + +// *nodes[0].fee_estimator.sat_per_kw.lock().unwrap() *= 8; +// *nodes[1].fee_estimator.sat_per_kw.lock().unwrap() *= 8; + +// connect_nodes(&nodes[0], &nodes[1]); +// let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); +// nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); + +// let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(node_0_msgs.len(), 2); +// let node_0_2nd_shutdown = match node_0_msgs[0] { +// MessageSendEvent::SendShutdown { ref msg, .. } => { +// msg.clone() +// }, +// _ => panic!(), +// }; +// let node_0_2nd_closing_signed = match node_0_msgs[1] { +// MessageSendEvent::SendClosingSigned { ref msg, .. } => { +// msg.clone() +// }, +// _ => panic!(), +// }; +// let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// } + +// nodes[0].node.signer_unblocked(None); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_closing_signed.is_none()); + +// assert!(nodes[0].node.list_channels().is_empty()); +// assert!(nodes[1].node.list_channels().is_empty()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn test_no_disconnect_while_async_revoke_and_ack_expecting_remote_commitment_signed() { +// // Nodes with async signers may be expecting to receive a `commitment_signed` from the +// // counterparty even if a `revoke_and_ack` has yet to be sent due to an async signer. Test that +// // we don't disconnect the async signer node due to not receiving the `commitment_signed` within +// // the timeout while the `revoke_and_ack` is not ready. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// let payment_amount = 1_000_000; +// send_payment(&nodes[0], &[&nodes[1]], payment_amount * 4); + +// nodes[1].disable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); + +// // We'll send a payment from both nodes to each other. +// let (route1, payment_hash1, _, payment_secret1) = +// get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); +// let onion1 = RecipientOnionFields::secret_only(payment_secret1); +// let payment_id1 = PaymentId(payment_hash1.0); +// nodes[0].node.send_payment_with_route(route1, payment_hash1, onion1, payment_id1).unwrap(); +// check_added_monitors(&nodes[0], 1); + +// let (route2, payment_hash2, _, payment_secret2) = +// get_route_and_payment_hash!(&nodes[1], &nodes[0], payment_amount); +// let onion2 = RecipientOnionFields::secret_only(payment_secret2); +// let payment_id2 = PaymentId(payment_hash2.0); +// nodes[1].node.send_payment_with_route(route2, payment_hash2, onion2, payment_id2).unwrap(); +// check_added_monitors(&nodes[1], 1); + +// let update = get_htlc_update_msgs!(&nodes[0], node_id_1); +// nodes[1].node.handle_update_add_htlc(node_id_0, &update.update_add_htlcs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &update.commitment_signed); +// check_added_monitors(&nodes[1], 1); + +// let update = get_htlc_update_msgs!(&nodes[1], node_id_0); +// nodes[0].node.handle_update_add_htlc(node_id_1, &update.update_add_htlcs[0]); +// nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); +// check_added_monitors(&nodes[0], 1); + +// // nodes[0] can only respond with a `revoke_and_ack`. The `commitment_signed` that would follow +// // is blocked on receiving a counterparty `revoke_and_ack`, which nodes[1] is still pending on. +// let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); +// nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); +// check_added_monitors(&nodes[1], 1); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // nodes[0] will disconnect the counterparty as it's waiting on a `revoke_and_ack`. +// // nodes[1] is waiting on a `commitment_signed`, but since it hasn't yet sent its own +// // `revoke_and_ack`, it shouldn't disconnect yet. +// for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { +// nodes[0].node.timer_tick_occurred(); +// nodes[1].node.timer_tick_occurred(); +// } +// let has_disconnect_event = |event| { +// matches!( +// event, MessageSendEvent::HandleError { action , .. } +// if matches!(action, msgs::ErrorAction::DisconnectPeerWithWarning { .. }) +// ) +// }; +// assert!(nodes[0].node.get_and_clear_pending_msg_events().into_iter().any(has_disconnect_event)); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// #[test] +// fn test_no_disconnect_while_async_commitment_signed_expecting_remote_revoke_and_ack() { +// // Nodes with async signers may be expecting to receive a `revoke_and_ack` from the +// // counterparty even if a `commitment_signed` has yet to be sent due to an async signer. Test +// // that we don't disconnect the async signer node due to not receiving the `revoke_and_ack` +// // within the timeout while the `commitment_signed` is not ready. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// // Route a payment and attempt to claim it. +// let payment_amount = 1_000_000; +// let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], payment_amount); +// nodes[1].node.claim_funds(preimage); +// check_added_monitors(&nodes[1], 1); + +// // We'll disable signing counterparty commitments on the payment sender. +// nodes[0].disable_channel_signer_op(&node_id_1, &chan_id, SignerOp::SignCounterpartyCommitment); + +// // After processing the `update_fulfill`, they'll only be able to send `revoke_and_ack` until +// // the `commitment_signed` is no longer pending. +// let update = get_htlc_update_msgs!(&nodes[1], node_id_0); +// nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); +// nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); +// check_added_monitors(&nodes[0], 1); + +// let revoke_and_ack = get_event_msg!(&nodes[0], MessageSendEvent::SendRevokeAndACK, node_id_1); +// nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); +// check_added_monitors(&nodes[1], 1); + +// // The payment sender shouldn't disconnect the counterparty due to a missing `revoke_and_ack` +// // because the `commitment_signed` isn't ready yet. The payment recipient may disconnect the +// // sender because it doesn't have an async signer and it's expecting a timely +// // `commitment_signed` response. +// for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { +// nodes[0].node.timer_tick_occurred(); +// nodes[1].node.timer_tick_occurred(); +// } +// let has_disconnect_event = |event| { +// matches!( +// event, MessageSendEvent::HandleError { action , .. } +// if matches!(action, msgs::ErrorAction::DisconnectPeerWithWarning { .. }) +// ) +// }; +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().into_iter().any(has_disconnect_event)); + +// expect_payment_sent(&nodes[0], preimage, None, false, false); +// expect_payment_claimed!(nodes[1], payment_hash, payment_amount); +// } diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs index ef8f256ed5e..75332dd214c 100644 --- a/lightning/src/ln/chanmon_update_fail_tests.rs +++ b/lightning/src/ln/chanmon_update_fail_tests.rs @@ -1,4642 +1,4642 @@ -// This file is Copyright its original authors, visible in version control -// history. -// -// This file is licensed under the Apache License, Version 2.0 or the MIT license -// , at your option. -// You may not use this file except in accordance with one or both of these -// licenses. - -//! Functional tests which test the correct handling of ChannelMonitorUpdateStatus returns from -//! monitor updates. -//! There are a bunch of these as their handling is relatively error-prone so they are split out -//! here. See also the chanmon_fail_consistency fuzz test. - -use crate::chain::channelmonitor::{ChannelMonitor, ANTI_REORG_DELAY}; -use crate::chain::{ChannelMonitorUpdateStatus, Listen, Watch}; -use crate::events::{ClosureReason, Event, HTLCHandlingFailureType, PaymentPurpose}; -use crate::ln::channel::AnnouncementSigsState; -use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields}; -use crate::ln::msgs; -use crate::ln::msgs::{ - BaseMessageHandler, ChannelMessageHandler, MessageSendEvent, RoutingMessageHandler, -}; -use crate::ln::types::ChannelId; -use crate::util::ser::{ReadableArgs, Writeable}; -use crate::util::test_channel_signer::TestChannelSigner; -use crate::util::test_utils::TestBroadcaster; -use bitcoin::constants::genesis_block; -use bitcoin::hash_types::BlockHash; -use bitcoin::network::Network; - -use crate::ln::functional_test_utils::*; - -use crate::util::test_utils; - -use crate::prelude::*; -use crate::sync::{Arc, Mutex}; -use bitcoin::hashes::Hash; - -fn get_latest_mon_update_id<'a, 'b, 'c>( - node: &Node<'a, 'b, 'c>, channel_id: ChannelId, -) -> (u64, u64) { - let monitor_id_state = node.chain_monitor.latest_monitor_update_id.lock().unwrap(); - monitor_id_state.get(&channel_id).unwrap().clone() -} - -#[test] -fn test_monitor_and_persister_update_fail() { - // Test that if both updating the `ChannelMonitor` and persisting the updated - // `ChannelMonitor` fail, then the failure from updating the `ChannelMonitor` - // one that gets returned. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - // Create some initial channel - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Rebalance the network to generate htlc in the two directions - send_payment(&nodes[0], &[&nodes[1]], 10_000_000); - - // Route an HTLC from node 0 to node 1 (but don't settle) - let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 9_000_000); - - // Make a copy of the ChainMonitor so we can capture the error it returns on a - // bogus update. Note that if instead we updated the nodes[0]'s ChainMonitor - // directly, the node would fail to be `Drop`'d at the end because its - // ChannelManager and ChainMonitor would be out of sync. - let chain_source = test_utils::TestChainSource::new(Network::Testnet); - let logger = test_utils::TestLogger::with_id(format!("node {}", 0)); - let persister = test_utils::TestPersister::new(); - let tx_broadcaster = TestBroadcaster { - txn_broadcasted: Mutex::new(Vec::new()), - // Because we will connect a block at height 200 below, we need the TestBroadcaster to know - // that we are at height 200 so that it doesn't think we're violating the time lock - // requirements of transactions broadcasted at that point. - blocks: Arc::new(Mutex::new(vec![(genesis_block(Network::Testnet), 200); 200])), - }; - let chain_mon = { - let new_monitor = { - let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(chan.2).unwrap(); - let (_, new_monitor) = <(BlockHash, ChannelMonitor)>::read( - &mut &monitor.encode()[..], - (nodes[0].keys_manager, nodes[0].keys_manager), - ) - .unwrap(); - assert!(new_monitor == *monitor); - new_monitor - }; - let chain_mon = test_utils::TestChainMonitor::new( - Some(&chain_source), - &tx_broadcaster, - &logger, - &chanmon_cfgs[0].fee_estimator, - &persister, - &node_cfgs[0].keys_manager, - ); - assert_eq!( - chain_mon.watch_channel(chan.2, new_monitor), - Ok(ChannelMonitorUpdateStatus::Completed) - ); - chain_mon - }; - chain_mon - .chain_monitor - .block_connected(&create_dummy_block(BlockHash::all_zeros(), 42, Vec::new()), 200); - - // Try to update ChannelMonitor - nodes[1].node.claim_funds(preimage); - expect_payment_claimed!(nodes[1], payment_hash, 9_000_000); - check_added_monitors!(nodes[1], 1); - - let updates = get_htlc_update_msgs!(nodes[1], node_a_id); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); - - { - let mut per_peer_lock; - let mut peer_state_lock; - let chan_opt = get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, chan.2); - if let Some(channel) = chan_opt.as_funded_mut() { - assert_eq!(updates.commitment_signed.len(), 1); - if let Ok(Some(update)) = - channel.commitment_signed(&updates.commitment_signed[0], &node_cfgs[0].logger) - { - // Check that the persister returns InProgress (and will never actually complete) - // as the monitor update errors. - if let ChannelMonitorUpdateStatus::InProgress = - chain_mon.chain_monitor.update_channel(chan.2, &update) - { - } else { - panic!("Expected monitor paused"); - } - logger.assert_log_regex( - "lightning::chain::chainmonitor", - regex::Regex::new("Failed to update ChannelMonitor for channel [0-9a-f]*.") - .unwrap(), - 1, - ); - - // Apply the monitor update to the original ChainMonitor, ensuring the - // ChannelManager and ChannelMonitor aren't out of sync. - assert_eq!( - nodes[0].chain_monitor.update_channel(chan.2, &update), - ChannelMonitorUpdateStatus::Completed - ); - } else { - assert!(false); - } - } else { - assert!(false); - } - } - - check_added_monitors!(nodes[0], 1); - expect_payment_sent(&nodes[0], preimage, None, false, false); -} - -fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) { - // Test that we can recover from a simple temporary monitor update failure optionally with - // a disconnect in between - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; - - let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(&nodes[0], nodes[1], 1000000); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - let onion = RecipientOnionFields::secret_only(payment_secret_1); - let id = PaymentId(payment_hash_1.0); - nodes[0].node.send_payment_with_route(route, payment_hash_1, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert_eq!(nodes[0].node.list_channels().len(), 1); - - if disconnect { - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]); - reconnect_args.send_channel_ready = (true, true); - reconnect_nodes(reconnect_args); - } - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[0], 0); - - let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events_2.len(), 1); - let payment_event = SendEvent::from_event(events_2.pop().unwrap()); - assert_eq!(payment_event.node_id, node_b_id); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false); - - expect_pending_htlcs_forwardable!(nodes[1]); - - let events_3 = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events_3.len(), 1); - match events_3[0] { - Event::PaymentClaimable { - ref payment_hash, - ref purpose, - amount_msat, - receiver_node_id, - ref via_channel_ids, - .. - } => { - assert_eq!(payment_hash_1, *payment_hash); - assert_eq!(amount_msat, 1_000_000); - assert_eq!(receiver_node_id.unwrap(), node_b_id); - assert_eq!(*via_channel_ids, &[(channel_id, Some(user_channel_id))]); - match &purpose { - PaymentPurpose::Bolt11InvoicePayment { - payment_preimage, payment_secret, .. - } => { - assert!(payment_preimage.is_none()); - assert_eq!(payment_secret_1, *payment_secret); - }, - _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), - } - }, - _ => panic!("Unexpected event"), - } - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); - - // Now set it to failed again... - let (route, payment_hash_2, _, payment_secret_2) = - get_route_and_payment_hash!(&nodes[0], nodes[1], 1000000); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - let onion = RecipientOnionFields::secret_only(payment_secret_2); - let id = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert_eq!(nodes[0].node.list_channels().len(), 1); - - if disconnect { - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); - } - - // ...and make sure we can force-close a frozen channel - let err_msg = "Channel force-closed".to_owned(); - nodes[0].node.force_close_broadcasting_latest_txn(&channel_id, &node_b_id, err_msg).unwrap(); - check_added_monitors!(nodes[0], 1); - check_closed_broadcast!(nodes[0], true); - - // TODO: Once we hit the chain with the failure transaction we should check that we get a - // PaymentPathFailed event - - assert_eq!(nodes[0].node.list_channels().len(), 0); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event!(nodes[0], 1, reason, [node_b_id], 100000); -} - -#[test] -fn test_simple_monitor_temporary_update_fail() { - do_test_simple_monitor_temporary_update_fail(false); - do_test_simple_monitor_temporary_update_fail(true); -} - -fn do_test_monitor_temporary_update_fail(disconnect_count: usize) { - let disconnect_flags = 8 | 16; - - // Test that we can recover from a temporary monitor update failure with some in-flight - // HTLCs going on at the same time potentially with some disconnection thrown in. - // * First we route a payment, then get a temporary monitor update failure when trying to - // route a second payment. We then claim the first payment. - // * If disconnect_count is set, we will disconnect at this point (which is likely as - // InProgress likely indicates net disconnect which resulted in failing to update the - // ChannelMonitor on a watchtower). - // * If !(disconnect_count & 16) we deliver a update_fulfill_htlc/CS for the first payment - // immediately, otherwise we wait disconnect and deliver them via the reconnect - // channel_reestablish processing (ie disconnect_count & 16 makes no sense if - // disconnect_count & !disconnect_flags is 0). - // * We then update the channel monitor, reconnecting if disconnect_count is set and walk - // through message sending, potentially disconnect/reconnecting multiple times based on - // disconnect_count, to get the update_fulfill_htlc through. - // * We then walk through more message exchanges to get the original update_add_htlc - // through, swapping message ordering based on disconnect_count & 8 and optionally - // disconnect/reconnecting based on disconnect_count. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; - - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - // Now try to send a second payment which will fail to send - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let onion = RecipientOnionFields::secret_only(payment_secret_2); - let id = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert_eq!(nodes[0].node.list_channels().len(), 1); - - // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1] - // but nodes[0] won't respond since it is frozen. - nodes[1].node.claim_funds(payment_preimage_1); - check_added_monitors!(nodes[1], 1); - expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); - - let events_2 = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events_2.len(), 1); - let (bs_initial_fulfill, bs_initial_commitment_signed) = match events_2[0] { - MessageSendEvent::UpdateHTLCs { - ref node_id, - channel_id: _, - updates: - msgs::CommitmentUpdate { - ref update_add_htlcs, - ref update_fulfill_htlcs, - ref update_fail_htlcs, - ref update_fail_malformed_htlcs, - ref update_fee, - ref commitment_signed, - }, - } => { - assert_eq!(*node_id, node_a_id); - assert!(update_add_htlcs.is_empty()); - assert_eq!(update_fulfill_htlcs.len(), 1); - assert!(update_fail_htlcs.is_empty()); - assert!(update_fail_malformed_htlcs.is_empty()); - assert!(update_fee.is_none()); - - if (disconnect_count & 16) == 0 { - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_htlcs[0]); - let events_3 = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events_3.len(), 1); - match events_3[0] { - Event::PaymentSent { ref payment_preimage, ref payment_hash, .. } => { - assert_eq!(*payment_preimage, payment_preimage_1); - assert_eq!(*payment_hash, payment_hash_1); - }, - _ => panic!("Unexpected event"), - } - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, commitment_signed); - check_added_monitors!(nodes[0], 1); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - } - - (update_fulfill_htlcs[0].clone(), commitment_signed.clone()) - }, - _ => panic!("Unexpected event"), - }; - - if disconnect_count & !disconnect_flags > 0 { - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - } - - // Now fix monitor updating... - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[0], 0); - - macro_rules! disconnect_reconnect_peers { - () => {{ - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert_eq!(reestablish_1.len(), 1); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); - assert_eq!(reestablish_2.len(), 1); - - nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); - let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); - let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); - - assert!(as_resp.0.is_none()); - assert!(bs_resp.0.is_none()); - - (reestablish_1, reestablish_2, as_resp, bs_resp) - }}; - } - - let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 { - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert_eq!(reestablish_1.len(), 1); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); - assert_eq!(reestablish_2.len(), 1); - - nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); - check_added_monitors!(nodes[0], 0); - let mut as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); - check_added_monitors!(nodes[1], 0); - let mut bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); - - assert!(as_resp.0.is_none()); - assert!(bs_resp.0.is_none()); - - assert!(bs_resp.1.is_none()); - if (disconnect_count & 16) == 0 { - assert!(bs_resp.2.is_none()); - - assert!(as_resp.1.is_some()); - assert!(as_resp.2.is_some()); - assert_eq!(as_resp.3, RAACommitmentOrder::CommitmentFirst); - } else { - assert!(bs_resp.2.as_ref().unwrap().update_add_htlcs.is_empty()); - assert!(bs_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty()); - assert!(bs_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty()); - assert!(bs_resp.2.as_ref().unwrap().update_fee.is_none()); - assert_eq!(bs_resp.2.as_ref().unwrap().update_fulfill_htlcs, [bs_initial_fulfill]); - assert_eq!(bs_resp.2.as_ref().unwrap().commitment_signed, bs_initial_commitment_signed); - - assert!(as_resp.1.is_none()); - - nodes[0].node.handle_update_fulfill_htlc( - node_b_id, - &bs_resp.2.as_ref().unwrap().update_fulfill_htlcs[0], - ); - let events_3 = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events_3.len(), 1); - match events_3[0] { - Event::PaymentSent { ref payment_preimage, ref payment_hash, .. } => { - assert_eq!(*payment_preimage, payment_preimage_1); - assert_eq!(*payment_hash, payment_hash_1); - }, - _ => panic!("Unexpected event"), - } - - nodes[0].node.handle_commitment_signed_batch_test( - node_b_id, - &bs_resp.2.as_ref().unwrap().commitment_signed, - ); - let as_resp_raa = - get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[0], 1); - - as_resp.1 = Some(as_resp_raa); - bs_resp.2 = None; - } - - if disconnect_count & !disconnect_flags > 1 { - let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = - disconnect_reconnect_peers!(); - - if (disconnect_count & 16) == 0 { - assert_eq!(reestablish_1, second_reestablish_1); - assert_eq!(reestablish_2, second_reestablish_2); - } - assert_eq!(as_resp, second_as_resp); - assert_eq!(bs_resp, second_bs_resp); - } - - ( - SendEvent::from_commitment_update(node_b_id, channel_id, as_resp.2.unwrap()), - as_resp.1.unwrap(), - ) - } else { - let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events_4.len(), 2); - ( - SendEvent::from_event(events_4.remove(0)), - match events_4[0] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, node_b_id); - msg.clone() - }, - _ => panic!("Unexpected event"), - }, - ) - }; - - assert_eq!(payment_event.node_id, node_b_id); - - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - // nodes[1] is awaiting an RAA from nodes[0] still so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[1], 1); - - if disconnect_count & !disconnect_flags > 2 { - let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); - - assert_eq!(as_resp.1.unwrap(), initial_revoke_and_ack); - assert_eq!(bs_resp.1.unwrap(), bs_revoke_and_ack); - - assert!(as_resp.2.is_none()); - assert!(bs_resp.2.is_none()); - } - - let as_commitment_update; - let bs_second_commitment_update; - - macro_rules! handle_bs_raa { - () => { - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_revoke_and_ack); - as_commitment_update = get_htlc_update_msgs!(nodes[0], node_b_id); - assert!(as_commitment_update.update_add_htlcs.is_empty()); - assert!(as_commitment_update.update_fulfill_htlcs.is_empty()); - assert!(as_commitment_update.update_fail_htlcs.is_empty()); - assert!(as_commitment_update.update_fail_malformed_htlcs.is_empty()); - assert!(as_commitment_update.update_fee.is_none()); - check_added_monitors!(nodes[0], 1); - }; - } - - macro_rules! handle_initial_raa { - () => { - nodes[1].node.handle_revoke_and_ack(node_a_id, &initial_revoke_and_ack); - bs_second_commitment_update = get_htlc_update_msgs!(nodes[1], node_a_id); - assert!(bs_second_commitment_update.update_add_htlcs.is_empty()); - assert!(bs_second_commitment_update.update_fulfill_htlcs.is_empty()); - assert!(bs_second_commitment_update.update_fail_htlcs.is_empty()); - assert!(bs_second_commitment_update.update_fail_malformed_htlcs.is_empty()); - assert!(bs_second_commitment_update.update_fee.is_none()); - check_added_monitors!(nodes[1], 1); - }; - } - - if (disconnect_count & 8) == 0 { - handle_bs_raa!(); - - if disconnect_count & !disconnect_flags > 3 { - let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); - - assert_eq!(as_resp.1.unwrap(), initial_revoke_and_ack); - assert!(bs_resp.1.is_none()); - - assert_eq!(as_resp.2.unwrap(), as_commitment_update); - assert!(bs_resp.2.is_none()); - - assert_eq!(as_resp.3, RAACommitmentOrder::RevokeAndACKFirst); - } - - handle_initial_raa!(); - - if disconnect_count & !disconnect_flags > 4 { - let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); - - assert!(as_resp.1.is_none()); - assert!(bs_resp.1.is_none()); - - assert_eq!(as_resp.2.unwrap(), as_commitment_update); - assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); - } - } else { - handle_initial_raa!(); - - if disconnect_count & !disconnect_flags > 3 { - let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); - - assert!(as_resp.1.is_none()); - assert_eq!(bs_resp.1.unwrap(), bs_revoke_and_ack); - - assert!(as_resp.2.is_none()); - assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); - - assert_eq!(bs_resp.3, RAACommitmentOrder::RevokeAndACKFirst); - } - - handle_bs_raa!(); - - if disconnect_count & !disconnect_flags > 4 { - let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); - - assert!(as_resp.1.is_none()); - assert!(bs_resp.1.is_none()); - - assert_eq!(as_resp.2.unwrap(), as_commitment_update); - assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); - } - } - - nodes[0].node.handle_commitment_signed_batch_test( - node_b_id, - &bs_second_commitment_update.commitment_signed, - ); - let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[0], 1); - - nodes[1] - .node - .handle_commitment_signed_batch_test(node_a_id, &as_commitment_update.commitment_signed); - let bs_second_revoke_and_ack = - get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - // No commitment_signed so get_event_msg's assert(len == 1) passes - check_added_monitors!(nodes[1], 1); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_revoke_and_ack); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_revoke_and_ack); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[0], 1); - expect_payment_path_successful!(nodes[0]); - - expect_pending_htlcs_forwardable!(nodes[1]); - - let events_5 = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events_5.len(), 1); - match events_5[0] { - Event::PaymentClaimable { - ref payment_hash, - ref purpose, - amount_msat, - receiver_node_id, - ref via_channel_ids, - .. - } => { - assert_eq!(payment_hash_2, *payment_hash); - assert_eq!(amount_msat, 1_000_000); - assert_eq!(receiver_node_id.unwrap(), node_b_id); - assert_eq!(*via_channel_ids, [(channel_id, Some(user_channel_id))]); - match &purpose { - PaymentPurpose::Bolt11InvoicePayment { - payment_preimage, payment_secret, .. - } => { - assert!(payment_preimage.is_none()); - assert_eq!(payment_secret_2, *payment_secret); - }, - _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), - } - }, - _ => panic!("Unexpected event"), - } - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} - -#[test] -fn test_monitor_temporary_update_fail_a() { - do_test_monitor_temporary_update_fail(0); - do_test_monitor_temporary_update_fail(1); - do_test_monitor_temporary_update_fail(2); - do_test_monitor_temporary_update_fail(3); - do_test_monitor_temporary_update_fail(4); - do_test_monitor_temporary_update_fail(5); -} - -#[test] -fn test_monitor_temporary_update_fail_b() { - do_test_monitor_temporary_update_fail(2 | 8); - do_test_monitor_temporary_update_fail(3 | 8); - do_test_monitor_temporary_update_fail(4 | 8); - do_test_monitor_temporary_update_fail(5 | 8); -} - -#[test] -fn test_monitor_temporary_update_fail_c() { - do_test_monitor_temporary_update_fail(1 | 16); - do_test_monitor_temporary_update_fail(2 | 16); - do_test_monitor_temporary_update_fail(3 | 16); - do_test_monitor_temporary_update_fail(2 | 8 | 16); - do_test_monitor_temporary_update_fail(3 | 8 | 16); -} - -#[test] -fn test_monitor_update_fail_cs() { - // Tests handling of a monitor update failure when processing an incoming commitment_signed - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; - - let (route, our_payment_hash, payment_preimage, our_payment_secret) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion = RecipientOnionFields::secret_only(our_payment_secret); - let id = PaymentId(our_payment_hash.0); - nodes[0].node.send_payment_with_route(route, our_payment_hash, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - let send_event = - SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event.commitment_msg); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[1], 0); - let responses = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(responses.len(), 2); - - match responses[0] { - MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => { - assert_eq!(*node_id, node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, &msg); - check_added_monitors!(nodes[0], 1); - }, - _ => panic!("Unexpected event"), - } - match responses[1] { - MessageSendEvent::UpdateHTLCs { ref updates, ref node_id, channel_id: _ } => { - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(*node_id, node_a_id); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0] - .node - .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[0], 1); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - }, - _ => panic!("Unexpected event"), - } - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[0], 0); - - let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &final_raa); - check_added_monitors!(nodes[1], 1); - - expect_pending_htlcs_forwardable!(nodes[1]); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::PaymentClaimable { - payment_hash, - ref purpose, - amount_msat, - receiver_node_id, - ref via_channel_ids, - .. - } => { - assert_eq!(payment_hash, our_payment_hash); - assert_eq!(amount_msat, 1_000_000); - assert_eq!(receiver_node_id.unwrap(), node_b_id); - assert_eq!(*via_channel_ids, [(channel_id, Some(user_channel_id))]); - match &purpose { - PaymentPurpose::Bolt11InvoicePayment { - payment_preimage, payment_secret, .. - } => { - assert!(payment_preimage.is_none()); - assert_eq!(our_payment_secret, *payment_secret); - }, - _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), - } - }, - _ => panic!("Unexpected event"), - }; - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); -} - -#[test] -fn test_monitor_update_fail_no_rebroadcast() { - // Tests handling of a monitor update failure when no message rebroadcasting on - // channel_monitor_updated() is required. Backported from chanmon_fail_consistency - // fuzz tests. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let (route, our_payment_hash, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion = RecipientOnionFields::secret_only(payment_secret_1); - let id = PaymentId(our_payment_hash.0); - nodes[0].node.send_payment_with_route(route, our_payment_hash, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - let send_event = - SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); - let commitment = send_event.commitment_msg; - let bs_raa = commitment_signed_dance!(nodes[1], nodes[0], commitment, false, true, false, true); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_revoke_and_ack(node_a_id, &bs_raa); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 0); - expect_pending_htlcs_forwardable!(nodes[1]); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::PaymentClaimable { payment_hash, .. } => { - assert_eq!(payment_hash, our_payment_hash); - }, - _ => panic!("Unexpected event"), - } - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); -} - -#[test] -fn test_monitor_update_raa_while_paused() { - // Tests handling of an RAA while monitor updating has already been marked failed. - // Backported from chanmon_fail_consistency fuzz tests as this used to be broken. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - send_payment(&nodes[0], &[&nodes[1]], 5000000); - let (route, our_payment_hash_1, payment_preimage_1, our_payment_secret_1) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion = RecipientOnionFields::secret_only(our_payment_secret_1); - let id = PaymentId(our_payment_hash_1.0); - nodes[0].node.send_payment_with_route(route, our_payment_hash_1, onion, id).unwrap(); - - check_added_monitors!(nodes[0], 1); - let send_event_1 = - SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - - let (route, our_payment_hash_2, payment_preimage_2, our_payment_secret_2) = - get_route_and_payment_hash!(nodes[1], nodes[0], 1000000); - let onion_2 = RecipientOnionFields::secret_only(our_payment_secret_2); - let id_2 = PaymentId(our_payment_hash_2.0); - nodes[1].node.send_payment_with_route(route, our_payment_hash_2, onion_2, id_2).unwrap(); - - check_added_monitors!(nodes[1], 1); - let send_event_2 = - SendEvent::from_event(nodes[1].node.get_and_clear_pending_msg_events().remove(0)); - - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event_1.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event_1.commitment_msg); - check_added_monitors!(nodes[1], 1); - let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_update_add_htlc(node_b_id, &send_event_2.msgs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &send_event_2.commitment_msg); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[0], 1); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[0], 1); - - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[0], 0); - - let as_update_raa = get_revoke_commit_msgs!(nodes[0], node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_update_raa.0); - check_added_monitors!(nodes[1], 1); - let bs_cs = get_htlc_update_msgs!(nodes[1], node_a_id); - - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_update_raa.1); - check_added_monitors!(nodes[1], 1); - let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs.commitment_signed); - check_added_monitors!(nodes[0], 1); - let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_raa); - check_added_monitors!(nodes[0], 1); - expect_pending_htlcs_forwardable!(nodes[0]); - expect_payment_claimable!(nodes[0], our_payment_hash_2, our_payment_secret_2, 1000000); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_second_raa); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], our_payment_hash_1, our_payment_secret_1, 1000000); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); - claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2); -} - -fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { - // Tests handling of a monitor update failure when processing an incoming RAA - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - - // Rebalance a bit so that we can send backwards from 2 to 1. - send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); - - // Route a first payment that we'll fail backwards - let (_, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000); - - // Fail the payment backwards, failing the monitor update on nodes[1]'s receipt of the RAA - nodes[2].node.fail_htlc_backwards(&payment_hash_1); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[2], - [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_1 }] - ); - check_added_monitors!(nodes[2], 1); - - let updates = get_htlc_update_msgs!(nodes[2], node_b_id); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert_eq!(updates.update_fail_htlcs.len(), 1); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - nodes[1].node.handle_update_fail_htlc(node_c_id, &updates.update_fail_htlcs[0]); - - let commitment = updates.commitment_signed; - let bs_revoke_and_ack = - commitment_signed_dance!(nodes[1], nodes[2], commitment, false, true, false, true); - check_added_monitors!(nodes[0], 0); - - // While the second channel is AwaitingRAA, forward a second payment to get it into the - // holding cell. - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[0], nodes[2], 1000000); - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[0], 1); - - let mut send_event = - SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false); - - expect_pending_htlcs_forwardable!(nodes[1]); - check_added_monitors!(nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now fail monitor updating. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_revoke_and_ack); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - // Forward a third payment which will also be added to the holding cell, despite the channel - // being paused waiting a monitor update. - let (route, payment_hash_3, _, payment_secret_3) = - get_route_and_payment_hash!(nodes[0], nodes[2], 1000000); - let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); - let id_3 = PaymentId(payment_hash_3.0); - nodes[0].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); - check_added_monitors!(nodes[0], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); // We succeed in updating the monitor for the first channel - send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true); - check_added_monitors!(nodes[1], 0); - - // Call forward_pending_htlcs and check that the new HTLC was simply added to the holding cell - // and not forwarded. - expect_pending_htlcs_forwardable!(nodes[1]); - check_added_monitors!(nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - let (payment_preimage_4, payment_hash_4) = if test_ignore_second_cs { - // Try to route another payment backwards from 2 to make sure 1 holds off on responding - let (route, payment_hash_4, payment_preimage_4, payment_secret_4) = - get_route_and_payment_hash!(nodes[2], nodes[0], 1000000); - let onion_4 = RecipientOnionFields::secret_only(payment_secret_4); - let id_4 = PaymentId(payment_hash_4.0); - nodes[2].node.send_payment_with_route(route, payment_hash_4, onion_4, id_4).unwrap(); - check_added_monitors!(nodes[2], 1); - - send_event = - SendEvent::from_event(nodes[2].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_c_id, &send_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &send_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - (Some(payment_preimage_4), Some(payment_hash_4)) - } else { - (None, None) - }; - - // Restore monitor updating, ensuring we immediately get a fail-back update and a - // update_add update. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_2.2); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_2.2, latest_update); - check_added_monitors!(nodes[1], 0); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[1], - [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_2.2 }] - ); - check_added_monitors!(nodes[1], 1); - - let mut events_3 = nodes[1].node.get_and_clear_pending_msg_events(); - if test_ignore_second_cs { - assert_eq!(events_3.len(), 3); - } else { - assert_eq!(events_3.len(), 2); - } - - // Note that the ordering of the events for different nodes is non-prescriptive, though the - // ordering of the two events that both go to nodes[2] have to stay in the same order. - let nodes_0_event = remove_first_msg_event_to_node(&node_a_id, &mut events_3); - let messages_a = match nodes_0_event { - MessageSendEvent::UpdateHTLCs { node_id, mut updates, channel_id: _ } => { - assert_eq!(node_id, node_a_id); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert_eq!(updates.update_fail_htlcs.len(), 1); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - (updates.update_fail_htlcs.remove(0), updates.commitment_signed) - }, - _ => panic!("Unexpected event type!"), - }; - - let nodes_2_event = remove_first_msg_event_to_node(&node_c_id, &mut events_3); - let send_event_b = SendEvent::from_event(nodes_2_event); - assert_eq!(send_event_b.node_id, node_c_id); - - let raa = if test_ignore_second_cs { - let nodes_2_event = remove_first_msg_event_to_node(&node_c_id, &mut events_3); - match nodes_2_event { - MessageSendEvent::SendRevokeAndACK { node_id, msg } => { - assert_eq!(node_id, node_c_id); - Some(msg.clone()) - }, - _ => panic!("Unexpected event"), - } - } else { - None - }; - - // Now deliver the new messages... - - nodes[0].node.handle_update_fail_htlc(node_b_id, &messages_a.0); - commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false); - expect_payment_failed!(nodes[0], payment_hash_1, true); - - nodes[2].node.handle_update_add_htlc(node_b_id, &send_event_b.msgs[0]); - let as_cs; - if test_ignore_second_cs { - nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &send_event_b.commitment_msg); - check_added_monitors!(nodes[2], 1); - let bs_revoke_and_ack = - get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[2].node.handle_revoke_and_ack(node_b_id, &raa.unwrap()); - check_added_monitors!(nodes[2], 1); - let bs_cs = get_htlc_update_msgs!(nodes[2], node_b_id); - assert!(bs_cs.update_add_htlcs.is_empty()); - assert!(bs_cs.update_fail_htlcs.is_empty()); - assert!(bs_cs.update_fail_malformed_htlcs.is_empty()); - assert!(bs_cs.update_fulfill_htlcs.is_empty()); - assert!(bs_cs.update_fee.is_none()); - - nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_revoke_and_ack); - check_added_monitors!(nodes[1], 1); - as_cs = get_htlc_update_msgs!(nodes[1], node_c_id); - - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &bs_cs.commitment_signed); - check_added_monitors!(nodes[1], 1); - } else { - nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &send_event_b.commitment_msg); - check_added_monitors!(nodes[2], 1); - - let bs_revoke_and_commit = nodes[2].node.get_and_clear_pending_msg_events(); - // As both messages are for nodes[1], they're in order. - assert_eq!(bs_revoke_and_commit.len(), 2); - match bs_revoke_and_commit[0] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_c_id, &msg); - check_added_monitors!(nodes[1], 1); - }, - _ => panic!("Unexpected event"), - } - - as_cs = get_htlc_update_msgs!(nodes[1], node_c_id); - - match bs_revoke_and_commit[1] { - MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { - assert_eq!(*node_id, node_b_id); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - nodes[1] - .node - .handle_commitment_signed_batch_test(node_c_id, &updates.commitment_signed); - check_added_monitors!(nodes[1], 1); - }, - _ => panic!("Unexpected event"), - } - } - - assert_eq!(as_cs.update_add_htlcs.len(), 1); - assert!(as_cs.update_fail_htlcs.is_empty()); - assert!(as_cs.update_fail_malformed_htlcs.is_empty()); - assert!(as_cs.update_fulfill_htlcs.is_empty()); - assert!(as_cs.update_fee.is_none()); - let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_c_id); - - nodes[2].node.handle_update_add_htlc(node_b_id, &as_cs.update_add_htlcs[0]); - nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &as_cs.commitment_signed); - check_added_monitors!(nodes[2], 1); - let bs_second_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[2].node.handle_revoke_and_ack(node_b_id, &as_raa); - check_added_monitors!(nodes[2], 1); - let bs_second_cs = get_htlc_update_msgs!(nodes[2], node_b_id); - - nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_second_raa); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &bs_second_cs.commitment_signed); - check_added_monitors!(nodes[1], 1); - let as_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_c_id); - - nodes[2].node.handle_revoke_and_ack(node_b_id, &as_second_raa); - check_added_monitors!(nodes[2], 1); - assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty()); - - expect_pending_htlcs_forwardable!(nodes[2]); - - let events_6 = nodes[2].node.get_and_clear_pending_events(); - assert_eq!(events_6.len(), 2); - match events_6[0] { - Event::PaymentClaimable { payment_hash, .. } => { - assert_eq!(payment_hash, payment_hash_2); - }, - _ => panic!("Unexpected event"), - }; - match events_6[1] { - Event::PaymentClaimable { payment_hash, .. } => { - assert_eq!(payment_hash, payment_hash_3); - }, - _ => panic!("Unexpected event"), - }; - - if test_ignore_second_cs { - expect_pending_htlcs_forwardable!(nodes[1]); - check_added_monitors!(nodes[1], 1); - - send_event = SendEvent::from_node(&nodes[1]); - assert_eq!(send_event.node_id, node_a_id); - assert_eq!(send_event.msgs.len(), 1); - nodes[0].node.handle_update_add_htlc(node_b_id, &send_event.msgs[0]); - commitment_signed_dance!(nodes[0], nodes[1], send_event.commitment_msg, false); - - expect_pending_htlcs_forwardable!(nodes[0]); - - let events_9 = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events_9.len(), 1); - match events_9[0] { - Event::PaymentClaimable { payment_hash, .. } => { - assert_eq!(payment_hash, payment_hash_4.unwrap()) - }, - _ => panic!("Unexpected event"), - }; - claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap()); - } - - claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2); -} - -#[test] -fn test_monitor_update_fail_raa() { - do_test_monitor_update_fail_raa(false); - do_test_monitor_update_fail_raa(true); -} - -#[test] -fn test_monitor_update_fail_reestablish() { - // Simple test for message retransmission after monitor update failure on - // channel_reestablish generating a monitor update (which comes from freeing holding cell - // HTLCs). - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - create_announced_chan_between_nodes(&nodes, 1, 2); - - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); - - nodes[1].node.peer_disconnected(node_a_id); - nodes[0].node.peer_disconnected(node_b_id); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); - - let mut updates = get_htlc_update_msgs!(nodes[2], node_b_id); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - - let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reestablish); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_reestablish); - - // The "disabled" bit should be unset as we just reconnected - let as_channel_upd = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); - assert_eq!(as_channel_upd.contents.channel_flags & 2, 0); - - nodes[1].node.get_and_clear_pending_msg_events(); // Free the holding cell - check_added_monitors!(nodes[1], 1); - - nodes[1].node.peer_disconnected(node_a_id); - nodes[0].node.peer_disconnected(node_b_id); - - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - - assert_eq!(get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(), as_reestablish); - assert_eq!(get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(), bs_reestablish); - - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reestablish); - - // The "disabled" bit should be unset as we just reconnected - let as_channel_upd = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); - assert_eq!(as_channel_upd.contents.channel_flags & 2, 0); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_reestablish); - check_added_monitors!(nodes[1], 0); - - // The "disabled" bit should be unset as we just reconnected - let bs_channel_upd = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); - assert_eq!(bs_channel_upd.contents.channel_flags & 2, 0); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_1.2); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update); - check_added_monitors!(nodes[1], 0); - - updates = get_htlc_update_msgs!(nodes[1], node_a_id); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); - expect_payment_sent!(nodes[0], payment_preimage); -} - -#[test] -fn raa_no_response_awaiting_raa_state() { - // This is a rather convoluted test which ensures that if handling of an RAA does not happen - // due to a previous monitor update failure, we still set AwaitingRemoteRevoke on the channel - // in question (assuming it intends to respond with a CS after monitor updating is restored). - // Backported from chanmon_fail_consistency fuzz tests as this used to be broken. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let (payment_preimage_2, payment_hash_2, payment_secret_2) = - get_payment_preimage_hash!(nodes[1]); - let (payment_preimage_3, payment_hash_3, payment_secret_3) = - get_payment_preimage_hash!(nodes[1]); - - // Queue up two payments - one will be delivered right away, one immediately goes into the - // holding cell as nodes[0] is AwaitingRAA. Ultimately this allows us to deliver an RAA - // immediately after a CS. By setting failing the monitor update failure from the CS (which - // requires only an RAA response due to AwaitingRAA) we can deliver the RAA and require the CS - // generation during RAA while in monitor-update-failed state. - let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); - let id_1 = PaymentId(payment_hash_1.0); - nodes[0].node.send_payment_with_route(route.clone(), payment_hash_1, onion_1, id_1).unwrap(); - check_added_monitors!(nodes[0], 1); - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route.clone(), payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[0], 0); - - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - - let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); - check_added_monitors!(nodes[0], 1); - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); - check_added_monitors!(nodes[0], 1); - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - // Now we have a CS queued up which adds a new HTLC (which will need a RAA/CS response from - // nodes[1]) followed by an RAA. Fail the monitor updating prior to the CS, deliver the RAA, - // then restore channel monitor updates. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - // nodes[1] should be AwaitingRAA here! - check_added_monitors!(nodes[1], 0); - let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); - - // We send a third payment here, which is somewhat of a redundant test, but the - // chanmon_fail_consistency test required it to actually find the bug (by seeing out-of-sync - // commitment transaction states) whereas here we can explicitly check for it. - let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); - let id_3 = PaymentId(payment_hash_3.0); - nodes[0].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); - check_added_monitors!(nodes[0], 0); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); - check_added_monitors!(nodes[0], 1); - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); - check_added_monitors!(nodes[0], 1); - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - - // Finally deliver the RAA to nodes[1] which results in a CS response to the last update - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); - let bs_update = get_htlc_update_msgs!(nodes[1], node_a_id); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); - check_added_monitors!(nodes[0], 1); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_update.commitment_signed); - check_added_monitors!(nodes[0], 1); - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_3, payment_secret_3, 1000000); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3); -} - -#[test] -fn claim_while_disconnected_monitor_update_fail() { - // Test for claiming a payment while disconnected and then having the resulting - // channel-update-generated monitor update fail. This kind of thing isn't a particularly - // contrived case for nodes with network instability. - // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling - // code introduced a regression in this test (specifically, this caught a removal of the - // channel_reestablish handling ensuring the order was sensical given the messages used). - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - // Forward a payment for B to claim - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - - nodes[1].node.claim_funds(payment_preimage_1); - check_added_monitors!(nodes[1], 1); - expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - - let as_reconnect = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - let bs_reconnect = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reconnect); - let _as_channel_update = - get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); - - // Now deliver a's reestablish, freeing the claim from the holding cell, but fail the monitor - // update. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_reconnect); - let _bs_channel_update = - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Send a second payment from A to B, resulting in a commitment update that gets swallowed with - // the monitor still failed - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[0], 1); - - let as_updates = get_htlc_update_msgs!(nodes[0], node_b_id); - nodes[1].node.handle_update_add_htlc(node_a_id, &as_updates.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_updates.commitment_signed); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - // Note that nodes[1] not updating monitor here is OK - it wont take action on the new HTLC - // until we've channel_monitor_update'd and updated for the new commitment transaction. - - // Now un-fail the monitor, which will result in B sending its original commitment update, - // receiving the commitment update from A, and the resulting commitment dances. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[1], 0); - - let bs_msgs = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_msgs.len(), 2); - - match bs_msgs[0] { - MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { - assert_eq!(*node_id, node_a_id); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); - expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); - nodes[0] - .node - .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed); - check_added_monitors!(nodes[0], 1); - - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - }, - _ => panic!("Unexpected event"), - } - - match bs_msgs[1] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, msg); - check_added_monitors!(nodes[0], 1); - }, - _ => panic!("Unexpected event"), - } - - let as_commitment = get_htlc_update_msgs!(nodes[0], node_b_id); - - let bs_commitment = get_htlc_update_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_commitment.commitment_signed); - check_added_monitors!(nodes[0], 1); - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_commitment.commitment_signed); - check_added_monitors!(nodes[1], 1); - let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); - check_added_monitors!(nodes[0], 1); - expect_payment_path_successful!(nodes[0]); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} - -#[test] -fn monitor_failed_no_reestablish_response() { - // Test for receiving a channel_reestablish after a monitor update failure resulted in no - // response to a commitment_signed. - // Backported from chanmon_fail_consistency fuzz tests as it caught a long-standing - // debug_assert!() failure in channel_reestablish handling. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - { - let mut per_peer_lock; - let mut peer_state_lock; - get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, channel_id) - .context_mut() - .announcement_sigs_state = AnnouncementSigsState::PeerReceived; - } - { - let mut per_peer_lock; - let mut peer_state_lock; - get_channel_ref!(nodes[1], nodes[0], per_peer_lock, peer_state_lock, channel_id) - .context_mut() - .announcement_sigs_state = AnnouncementSigsState::PeerReceived; - } - - // Route the payment and deliver the initial commitment_signed (with a monitor update failure - // on receipt). - let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion = RecipientOnionFields::secret_only(payment_secret_1); - let id = PaymentId(payment_hash_1.0); - nodes[0].node.send_payment_with_route(route, payment_hash_1, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - // Now disconnect and immediately reconnect, delivering the channel_reestablish while nodes[1] - // is still failing to update monitors. - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - - let as_reconnect = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - let bs_reconnect = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_reconnect); - let _bs_channel_update = - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reconnect); - let _as_channel_update = - get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[1], 0); - let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); - check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); - check_added_monitors!(nodes[0], 1); - - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); -} - -#[test] -fn first_message_on_recv_ordering() { - // Test that if the initial generator of a monitor-update-frozen state doesn't generate - // messages, we're willing to flip the order of response messages if neccessary in resposne to - // a commitment_signed which needs to send an RAA first. - // At a high level, our goal is to fail monitor updating in response to an RAA which needs no - // response and then handle a CS while in the failed state, requiring an RAA followed by a CS - // response. To do this, we start routing two payments, with the final RAA for the first being - // delivered while B is in AwaitingRAA, hence when we deliver the CS for the second B will - // have no pending response but will want to send a RAA/CS (with the updates for the second - // payment applied). - // Backported from chanmon_fail_consistency fuzz tests as it caught a bug here. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - // Route the first payment outbound, holding the last RAA for B until we are set up so that we - // can deliver it and fail the monitor update. - let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); - let id_1 = PaymentId(payment_hash_1.0); - nodes[0].node.send_payment_with_route(route, payment_hash_1, onion_1, id_1).unwrap(); - check_added_monitors!(nodes[0], 1); - - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - assert_eq!(payment_event.node_id, node_b_id); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); - check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); - check_added_monitors!(nodes[0], 1); - - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - // Route the second payment, generating an update_add_htlc/commitment_signed - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); - - check_added_monitors!(nodes[0], 1); - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - assert_eq!(payment_event.node_id, node_b_id); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - // Deliver the final RAA for the first payment, which does not require a response. RAAs - // generally require a commitment_signed, so the fact that we're expecting an opposite response - // to the next message also tests resetting the delivery order. - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - // Now deliver the update_add_htlc/commitment_signed for the second payment, which does need an - // RAA/CS response, which should be generated when we call channel_monitor_update (with the - // appropriate HTLC acceptance). - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[1], 0); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); - - let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); - check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); - check_added_monitors!(nodes[0], 1); - - let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} - -#[test] -fn test_monitor_update_fail_claim() { - // Basic test for monitor update failures when processing claim_funds calls. - // We set up a simple 3-node network, sending a payment from A to B and failing B's monitor - // update to claim the payment. We then send two payments C->B->A, which are held at B. - // Finally, we restore the channel monitor updating and claim the payment on B, forwarding - // the payments from C onwards to A. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - create_announced_chan_between_nodes(&nodes, 1, 2); - - // Rebalance a bit so that we can send backwards from 3 to 2. - send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); - - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - // As long as the preimage isn't on-chain, we shouldn't expose the `PaymentClaimed` event to - // users nor send the preimage to peers in the new commitment update. - nodes[1].node.claim_funds(payment_preimage_1); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - - // Note that at this point there is a pending commitment transaction update for A being held by - // B. Even when we go to send the payment from C through B to A, B will not update this - // already-signed commitment transaction and will instead wait for it to resolve before - // forwarding the payment onwards. - - let (route, payment_hash_2, _, payment_secret_2) = - get_route_and_payment_hash!(nodes[2], nodes[0], 1_000_000); - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[2].node.send_payment_with_route(route.clone(), payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[2], 1); - - // Successfully update the monitor on the 1<->2 channel, but the 0<->1 channel should still be - // paused, so forward shouldn't succeed until we call channel_monitor_updated(). - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - - let mut events = nodes[2].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 0); - commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true); - expect_pending_htlcs_forwardable_ignore!(nodes[1]); - - let (_, payment_hash_3, payment_secret_3) = get_payment_preimage_hash!(nodes[0]); - let id_3 = PaymentId(payment_hash_3.0); - let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); - nodes[2].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); - check_added_monitors!(nodes[2], 1); - - let mut events = nodes[2].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 0); - commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true); - - // Now restore monitor updating on the 0<->1 channel and claim the funds on B. - let channel_id = chan_1.2; - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); - check_added_monitors!(nodes[1], 0); - - let bs_fulfill_update = get_htlc_update_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_fulfill_update.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_fulfill_update.commitment_signed, false); - expect_payment_sent!(nodes[0], payment_preimage_1); - - // Get the payment forwards, note that they were batched into one commitment update. - nodes[1].node.process_pending_htlc_forwards(); - check_added_monitors!(nodes[1], 1); - let bs_forward_update = get_htlc_update_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_update_add_htlc(node_b_id, &bs_forward_update.update_add_htlcs[0]); - nodes[0].node.handle_update_add_htlc(node_b_id, &bs_forward_update.update_add_htlcs[1]); - commitment_signed_dance!(nodes[0], nodes[1], bs_forward_update.commitment_signed, false); - expect_pending_htlcs_forwardable!(nodes[0]); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 2); - match events[0] { - Event::PaymentClaimable { - ref payment_hash, - ref purpose, - amount_msat, - receiver_node_id, - ref via_channel_ids, - .. - } => { - assert_eq!(payment_hash_2, *payment_hash); - assert_eq!(1_000_000, amount_msat); - assert_eq!(receiver_node_id.unwrap(), node_a_id); - assert_eq!(*via_channel_ids.last().unwrap(), (channel_id, Some(42))); - match &purpose { - PaymentPurpose::Bolt11InvoicePayment { - payment_preimage, payment_secret, .. - } => { - assert!(payment_preimage.is_none()); - assert_eq!(payment_secret_2, *payment_secret); - }, - _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), - } - }, - _ => panic!("Unexpected event"), - } - match events[1] { - Event::PaymentClaimable { - ref payment_hash, - ref purpose, - amount_msat, - receiver_node_id, - ref via_channel_ids, - .. - } => { - assert_eq!(payment_hash_3, *payment_hash); - assert_eq!(1_000_000, amount_msat); - assert_eq!(receiver_node_id.unwrap(), node_a_id); - assert_eq!(*via_channel_ids, [(channel_id, Some(42))]); - match &purpose { - PaymentPurpose::Bolt11InvoicePayment { - payment_preimage, payment_secret, .. - } => { - assert!(payment_preimage.is_none()); - assert_eq!(payment_secret_3, *payment_secret); - }, - _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), - } - }, - _ => panic!("Unexpected event"), - } -} - -#[test] -fn test_monitor_update_on_pending_forwards() { - // Basic test for monitor update failures when processing pending HTLC fail/add forwards. - // We do this with a simple 3-node network, sending a payment from A to C and one from C to A. - // The payment from A to C will be failed by C and pending a back-fail to A, while the payment - // from C to A will be pending a forward to A. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - - // Rebalance a bit so that we can send backwards from 3 to 1. - send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); - - let (_, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000); - nodes[2].node.fail_htlc_backwards(&payment_hash_1); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[2], - [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_1 }] - ); - check_added_monitors!(nodes[2], 1); - - let cs_fail_update = get_htlc_update_msgs!(nodes[2], node_b_id); - nodes[1].node.handle_update_fail_htlc(node_c_id, &cs_fail_update.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[1], nodes[2], cs_fail_update.commitment_signed, true, true); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[2], nodes[0], 1000000); - let onion = RecipientOnionFields::secret_only(payment_secret_2); - let id = PaymentId(payment_hash_2.0); - nodes[2].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); - check_added_monitors!(nodes[2], 1); - - let mut events = nodes[2].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[1], - [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_2.2 }] - ); - check_added_monitors!(nodes[1], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_1.2); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update); - check_added_monitors!(nodes[1], 0); - - let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_update_fail_htlc(node_b_id, &bs_updates.update_fail_htlcs[0]); - nodes[0].node.handle_update_add_htlc(node_b_id, &bs_updates.update_add_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 3); - if let Event::PaymentPathFailed { payment_hash, payment_failed_permanently, .. } = events[1] { - assert_eq!(payment_hash, payment_hash_1); - assert!(payment_failed_permanently); - } else { - panic!("Unexpected event!"); - } - match events[2] { - Event::PaymentFailed { payment_hash, .. } => { - assert_eq!(payment_hash, Some(payment_hash_1)); - }, - _ => panic!("Unexpected event"), - } - match events[0] { - Event::PendingHTLCsForwardable { .. } => {}, - _ => panic!("Unexpected event"), - }; - nodes[0].node.process_pending_htlc_forwards(); - expect_payment_claimable!(nodes[0], payment_hash_2, payment_secret_2, 1000000); - - claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2); -} - -#[test] -fn monitor_update_claim_fail_no_response() { - // Test for claim_funds resulting in both a monitor update failure and no message response (due - // to channel being AwaitingRAA). - // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling - // code was broken. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - // Forward a payment for B to claim - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - // Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); - let onion = RecipientOnionFields::secret_only(payment_secret_2); - let id = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); - check_added_monitors!(nodes[0], 1); - - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let payment_event = SendEvent::from_event(events.pop().unwrap()); - nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); - let commitment = payment_event.commitment_msg; - let as_raa = commitment_signed_dance!(nodes[1], nodes[0], commitment, false, true, false, true); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.claim_funds(payment_preimage_1); - check_added_monitors!(nodes[1], 1); - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); - check_added_monitors!(nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); - - let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false); - expect_payment_sent!(nodes[0], payment_preimage_1); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} - -// restore_b_before_conf has no meaning if !confirm_a_first -// restore_b_before_lock has no meaning if confirm_a_first -fn do_during_funding_monitor_fail( - confirm_a_first: bool, restore_b_before_conf: bool, restore_b_before_lock: bool, -) { - // Test that if the monitor update generated by funding_transaction_generated fails we continue - // the channel setup happily after the update is restored. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); - nodes[1].node.handle_open_channel( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), - ); - nodes[0].node.handle_accept_channel( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), - ); - - let (temporary_channel_id, funding_tx, funding_output) = - create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); - - nodes[0] - .node - .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) - .unwrap(); - check_added_monitors!(nodes[0], 0); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let funding_created_msg = - get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); - let channel_id = ChannelId::v1_from_funding_txid( - funding_created_msg.funding_txid.as_byte_array(), - funding_created_msg.funding_output_index, - ); - nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); - check_added_monitors!(nodes[1], 1); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_funding_signed( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id), - ); - check_added_monitors!(nodes[0], 1); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[0], 0); - expect_channel_pending_event(&nodes[0], &node_b_id); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 0); - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - assert_eq!( - nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0].compute_txid(), - funding_output.txid - ); - - if confirm_a_first { - confirm_transaction(&nodes[0], &funding_tx); - nodes[1].node.handle_channel_ready( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id), - ); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - } else { - assert!(!restore_b_before_conf); - confirm_transaction(&nodes[1], &funding_tx); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - } - - // Make sure nodes[1] isn't stupid enough to re-send the ChannelReady on reconnect - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]); - reconnect_args.send_channel_ready.1 = confirm_a_first; - reconnect_nodes(reconnect_args); - - // But we want to re-emit ChannelPending - expect_channel_pending_event(&nodes[1], &node_a_id); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - if !restore_b_before_conf { - confirm_transaction(&nodes[1], &funding_tx); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - } - if !confirm_a_first && !restore_b_before_lock { - confirm_transaction(&nodes[0], &funding_tx); - nodes[1].node.handle_channel_ready( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id), - ); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - } - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - check_added_monitors!(nodes[1], 0); - - let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first { - if !restore_b_before_lock { - let (channel_ready, channel_id) = - create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]); - ( - channel_id, - create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready), - ) - } else { - nodes[0].node.handle_channel_ready( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, node_a_id), - ); - confirm_transaction(&nodes[0], &funding_tx); - let (channel_ready, channel_id) = - create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]); - ( - channel_id, - create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready), - ) - } - } else { - if restore_b_before_conf { - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - confirm_transaction(&nodes[1], &funding_tx); - } - let (channel_ready, channel_id) = - create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]); - (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready)) - }; - for (i, node) in nodes.iter().enumerate() { - let counterparty_node_id = nodes[(i + 1) % 2].node.get_our_node_id(); - assert!(node - .gossip_sync - .handle_channel_announcement(Some(counterparty_node_id), &announcement) - .unwrap()); - node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &as_update).unwrap(); - node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap(); - } - - if !restore_b_before_lock { - expect_channel_ready_event(&nodes[1], &node_a_id); - } else { - expect_channel_ready_event(&nodes[0], &node_b_id); - } - - send_payment(&nodes[0], &[&nodes[1]], 8000000); - close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true); - let reason_a = ClosureReason::CounterpartyInitiatedCooperativeClosure; - check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000); - let reason_b = ClosureReason::LocallyInitiatedCooperativeClosure; - check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000); -} - -#[test] -fn during_funding_monitor_fail() { - do_during_funding_monitor_fail(true, true, false); - do_during_funding_monitor_fail(true, false, false); - do_during_funding_monitor_fail(false, false, false); - do_during_funding_monitor_fail(false, false, true); -} - -#[test] -fn test_path_paused_mpp() { - // Simple test of sending a multi-part payment where one path is currently blocked awaiting - // monitor update - 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 mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); - - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1).0.contents.short_channel_id; - let (chan_2_ann, _, chan_2_id, _) = create_announced_chan_between_nodes(&nodes, 0, 2); - let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents.short_channel_id; - let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3).0.contents.short_channel_id; - - let (mut route, payment_hash, payment_preimage, payment_secret) = - get_route_and_payment_hash!(&nodes[0], nodes[3], 100000); - - // Set us up to take multiple routes, one 0 -> 1 -> 3 and one 0 -> 2 -> 3: - let path = route.paths[0].clone(); - route.paths.push(path); - route.paths[0].hops[0].pubkey = node_b_id; - route.paths[0].hops[0].short_channel_id = chan_1_id; - route.paths[0].hops[1].short_channel_id = chan_3_id; - route.paths[1].hops[0].pubkey = node_c_id; - route.paths[1].hops[0].short_channel_id = chan_2_ann.contents.short_channel_id; - route.paths[1].hops[1].short_channel_id = chan_4_id; - - // Set it so that the first monitor update (for the path 0 -> 1 -> 3) succeeds, but the second - // (for the path 0 -> 2 -> 3) fails. - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - // The first path should have succeeded with the second getting a MonitorUpdateInProgress err. - let onion = RecipientOnionFields::secret_only(payment_secret); - let id = PaymentId(payment_hash.0); - nodes[0].node.send_payment_with_route(route, payment_hash, onion, id).unwrap(); - check_added_monitors!(nodes[0], 2); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - - // Pass the first HTLC of the payment along to nodes[3]. - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let path_1 = &[&nodes[1], &nodes[3]]; - let ev = events.pop().unwrap(); - pass_along_path(&nodes[0], path_1, 0, payment_hash, Some(payment_secret), ev, false, None); - - // And check that, after we successfully update the monitor for chan_2 we can pass the second - // HTLC along to nodes[3] and claim the whole payment back to nodes[0]. - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], chan_2_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_2_id, latest_update); - - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - let path_2 = &[&nodes[2], &nodes[3]]; - let ev = events.pop().unwrap(); - pass_along_path(&nodes[0], path_2, 200_000, payment_hash, Some(payment_secret), ev, true, None); - - claim_payment_along_route(ClaimAlongRouteArgs::new( - &nodes[0], - &[path_1, path_2], - payment_preimage, - )); -} - -#[test] -fn test_pending_update_fee_ack_on_reconnect() { - // In early versions of our automated fee update patch, nodes did not correctly use the - // previous channel feerate after sending an undelivered revoke_and_ack when re-sending an - // undelivered commitment_signed. - // - // B sends A new HTLC + CS, not delivered - // A sends B update_fee + CS - // B receives the CS and sends RAA, previously causing B to lock in the new feerate - // reconnect - // B resends initial CS, using the original fee - - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - send_payment(&nodes[0], &[&nodes[1]], 100_000_00); - - let (route, payment_hash, payment_preimage, payment_secret) = - get_route_and_payment_hash!(&nodes[1], nodes[0], 1_000_000); - let onion = RecipientOnionFields::secret_only(payment_secret); - let id = PaymentId(payment_hash.0); - nodes[1].node.send_payment_with_route(route, payment_hash, onion, id).unwrap(); - check_added_monitors!(nodes[1], 1); - let bs_initial_send_msgs = get_htlc_update_msgs!(nodes[1], node_a_id); - // bs_initial_send_msgs are not delivered until they are re-generated after reconnect - - { - let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock *= 2; - } - nodes[0].node.timer_tick_occurred(); - check_added_monitors!(nodes[0], 1); - let as_update_fee_msgs = get_htlc_update_msgs!(nodes[0], node_b_id); - assert!(as_update_fee_msgs.update_fee.is_some()); - - nodes[1].node.handle_update_fee(node_a_id, as_update_fee_msgs.update_fee.as_ref().unwrap()); - nodes[1] - .node - .handle_commitment_signed_batch_test(node_a_id, &as_update_fee_msgs.commitment_signed); - check_added_monitors!(nodes[1], 1); - let bs_first_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - // bs_first_raa is not delivered until it is re-generated after reconnect - - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - let as_connect_msg = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - let bs_connect_msg = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_connect_msg); - let bs_resend_msgs = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_resend_msgs.len(), 3); - if let MessageSendEvent::UpdateHTLCs { ref updates, .. } = bs_resend_msgs[0] { - assert_eq!(*updates, bs_initial_send_msgs); - } else { - panic!(); - } - if let MessageSendEvent::SendRevokeAndACK { ref msg, .. } = bs_resend_msgs[1] { - assert_eq!(*msg, bs_first_raa); - } else { - panic!(); - } - if let MessageSendEvent::SendChannelUpdate { .. } = bs_resend_msgs[2] { - } else { - panic!(); - } - - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_connect_msg); - get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); - - nodes[0].node.handle_update_add_htlc(node_b_id, &bs_initial_send_msgs.update_add_htlcs[0]); - nodes[0] - .node - .handle_commitment_signed_batch_test(node_b_id, &bs_initial_send_msgs.commitment_signed); - check_added_monitors!(nodes[0], 1); - nodes[1].node.handle_revoke_and_ack( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id), - ); - check_added_monitors!(nodes[1], 1); - let bs_second_cs = get_htlc_update_msgs!(nodes[1], node_a_id).commitment_signed; - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_first_raa); - check_added_monitors!(nodes[0], 1); - nodes[1].node.handle_commitment_signed_batch_test( - node_a_id, - &get_htlc_update_msgs!(nodes[0], node_b_id).commitment_signed, - ); - check_added_monitors!(nodes[1], 1); - let bs_third_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_second_cs); - check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_third_raa); - check_added_monitors!(nodes[0], 1); - - nodes[1].node.handle_revoke_and_ack( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id), - ); - check_added_monitors!(nodes[1], 1); - - expect_pending_htlcs_forwardable!(nodes[0]); - expect_payment_claimable!(nodes[0], payment_hash, payment_secret, 1_000_000); - - claim_payment(&nodes[1], &[&nodes[0]], payment_preimage); -} - -#[test] -fn test_fail_htlc_on_broadcast_after_claim() { - // In an earlier version of 7e78fa660cec8a73286c94c1073ee588140e7a01 we'd also fail the inbound - // channel backwards if we received an HTLC failure after a HTLC fulfillment. Here we test a - // specific case of that by having the HTLC failure come from the ChannelMonitor after a dust - // HTLC was not included in a confirmed commitment transaction. - // - // We first forward a payment, then claim it with an update_fulfill_htlc message, closing the - // channel immediately before commitment occurs. After the commitment transaction reaches - // ANTI_REORG_DELAY confirmations, will will try to fail the HTLC which was already fulfilled. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 2000); - - let bs_txn = get_local_commitment_txn!(nodes[2], chan_id_2); - assert_eq!(bs_txn.len(), 1); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 2000); - - let cs_updates = get_htlc_update_msgs!(nodes[2], node_b_id); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); - let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); - check_added_monitors!(nodes[1], 1); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - - mine_transaction(&nodes[1], &bs_txn[0]); - check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_c_id], 100000); - check_closed_broadcast!(nodes[1], true); - connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[1], - [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_id_2 }] - ); - - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); - expect_payment_sent(&nodes[0], payment_preimage, None, false, false); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, true, true); - expect_payment_path_successful!(nodes[0]); -} - -fn do_update_fee_resend_test(deliver_update: bool, parallel_updates: bool) { - // In early versions we did not handle resending of update_fee on reconnect correctly. The - // chanmon_consistency fuzz target, of course, immediately found it, but we test a few cases - // explicitly here. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - send_payment(&nodes[0], &[&nodes[1]], 1000); - - { - let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock += 20; - } - nodes[0].node.timer_tick_occurred(); - check_added_monitors!(nodes[0], 1); - let update_msgs = get_htlc_update_msgs!(nodes[0], node_b_id); - assert!(update_msgs.update_fee.is_some()); - if deliver_update { - nodes[1].node.handle_update_fee(node_a_id, update_msgs.update_fee.as_ref().unwrap()); - } - - if parallel_updates { - { - let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock += 20; - } - nodes[0].node.timer_tick_occurred(); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - } - - nodes[0].node.peer_disconnected(node_b_id); - nodes[1].node.peer_disconnected(node_a_id); - - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - let as_connect_msg = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - let bs_connect_msg = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[1].node.handle_channel_reestablish(node_a_id, &as_connect_msg); - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[0].node.handle_channel_reestablish(node_b_id, &bs_connect_msg); - let mut as_reconnect_msgs = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_reconnect_msgs.len(), 2); - if let MessageSendEvent::SendChannelUpdate { .. } = as_reconnect_msgs.pop().unwrap() { - } else { - panic!(); - } - let update_msgs = - if let MessageSendEvent::UpdateHTLCs { updates, .. } = as_reconnect_msgs.pop().unwrap() { - updates - } else { - panic!(); - }; - assert!(update_msgs.update_fee.is_some()); - nodes[1].node.handle_update_fee(node_a_id, update_msgs.update_fee.as_ref().unwrap()); - if parallel_updates { - nodes[1] - .node - .handle_commitment_signed_batch_test(node_a_id, &update_msgs.commitment_signed); - check_added_monitors!(nodes[1], 1); - let (bs_first_raa, bs_first_cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_first_raa); - check_added_monitors!(nodes[0], 1); - let as_second_update = get_htlc_update_msgs!(nodes[0], node_b_id); - - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_first_cs); - check_added_monitors!(nodes[0], 1); - let as_first_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[1].node.handle_update_fee(node_a_id, as_second_update.update_fee.as_ref().unwrap()); - nodes[1] - .node - .handle_commitment_signed_batch_test(node_a_id, &as_second_update.commitment_signed); - check_added_monitors!(nodes[1], 1); - let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_first_raa); - let bs_second_cs = get_htlc_update_msgs!(nodes[1], node_a_id); - check_added_monitors!(nodes[1], 1); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_raa); - check_added_monitors!(nodes[0], 1); - - nodes[0] - .node - .handle_commitment_signed_batch_test(node_b_id, &bs_second_cs.commitment_signed); - check_added_monitors!(nodes[0], 1); - let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_second_raa); - check_added_monitors!(nodes[1], 1); - } else { - commitment_signed_dance!(nodes[1], nodes[0], update_msgs.commitment_signed, false); - } - - send_payment(&nodes[0], &[&nodes[1]], 1000); -} -#[test] -fn update_fee_resend_test() { - do_update_fee_resend_test(false, false); - do_update_fee_resend_test(true, false); - do_update_fee_resend_test(false, true); - do_update_fee_resend_test(true, true); -} - -fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) { - // Tests that, when we serialize a channel with AddHTLC entries in the holding cell, we - // properly free them on reconnect. We previously failed such HTLCs upon serialization, but - // that behavior was both somewhat unexpected and also broken (there was a debug assertion - // which failed in such a case). - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let persister; - let new_chain_mon; - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); - let nodes_0_reload; - let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let chan_id = - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 15_000_000, 7_000_000_000).2; - let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = - get_route_and_payment_hash!(&nodes[0], nodes[1], 100000); - let (payment_preimage_2, payment_hash_2, payment_secret_2) = - get_payment_preimage_hash!(&nodes[1]); - - // Do a really complicated dance to get an HTLC into the holding cell, with - // MonitorUpdateInProgress set but AwaitingRemoteRevoke unset. When this test was written, any - // attempts to send an HTLC while MonitorUpdateInProgress is set are immediately - // failed-backwards. Thus, the only way to get an AddHTLC into the holding cell is to add it - // while AwaitingRemoteRevoke is set but MonitorUpdateInProgress is unset, and then swap the - // flags. - // - // We do this by: - // a) routing a payment from node B to node A, - // b) sending a payment from node A to node B without delivering any of the generated messages, - // putting node A in AwaitingRemoteRevoke, - // c) sending a second payment from node A to node B, which is immediately placed in the - // holding cell, - // d) claiming the first payment from B, allowing us to fail the monitor update which occurs - // when we try to persist the payment preimage, - // e) delivering A's commitment_signed from (b) and the resulting B revoke_and_ack message, - // clearing AwaitingRemoteRevoke on node A. - // - // Note that because, at the end, MonitorUpdateInProgress is still set, the HTLC generated in - // (c) will not be freed from the holding cell. - let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[1], &[&nodes[0]], 100_000); - - let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); - let id_1 = PaymentId(payment_hash_1.0); - nodes[0].node.send_payment_with_route(route.clone(), payment_hash_1, onion_1, id_1).unwrap(); - check_added_monitors!(nodes[0], 1); - let send = SendEvent::from_node(&nodes[0]); - assert_eq!(send.msgs.len(), 1); - - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[0], 0); - - let chan_0_monitor_serialized = get_monitor!(nodes[0], chan_id).encode(); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.claim_funds(payment_preimage_0); - check_added_monitors!(nodes[0], 1); - - nodes[1].node.handle_update_add_htlc(node_a_id, &send.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send.commitment_msg); - check_added_monitors!(nodes[1], 1); - - let (raa, cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); - - nodes[0].node.handle_revoke_and_ack(node_b_id, &raa); - check_added_monitors!(nodes[0], 1); - - if disconnect { - // Optionally reload nodes[0] entirely through a serialization roundtrip, otherwise just - // disconnect the peers. Note that the fuzzer originally found this issue because - // deserializing a ChannelManager in this state causes an assertion failure. - if reload_a { - let node_ser = nodes[0].node.encode(); - let mons = &[&chan_0_monitor_serialized[..]]; - reload_node!(nodes[0], &node_ser, mons, persister, new_chain_mon, nodes_0_reload); - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } else { - nodes[0].node.peer_disconnected(node_b_id); - } - nodes[1].node.peer_disconnected(node_a_id); - - // Now reconnect the two - let init_msg = msgs::Init { - features: nodes[1].node.init_features(), - networks: None, - remote_network_address: None, - }; - nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); - let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); - assert_eq!(reestablish_1.len(), 1); - nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); - let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); - assert_eq!(reestablish_2.len(), 1); - - nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); - let resp_1 = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); - check_added_monitors!(nodes[1], 0); - - nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); - let resp_0 = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); - - assert!(resp_0.0.is_none()); - assert!(resp_0.1.is_none()); - assert!(resp_0.2.is_none()); - assert!(resp_1.0.is_none()); - assert!(resp_1.1.is_none()); - - // Check that the freshly-generated cs is equal to the original (which we will deliver in a - // moment). - if let Some(pending_cs) = resp_1.2 { - assert!(pending_cs.update_add_htlcs.is_empty()); - assert!(pending_cs.update_fail_htlcs.is_empty()); - assert!(pending_cs.update_fulfill_htlcs.is_empty()); - assert_eq!(pending_cs.commitment_signed, cs); - } else { - panic!(); - } - - if reload_a { - // The two pending monitor updates were replayed (but are still pending). - check_added_monitors(&nodes[0], 2); - } else { - // There should be no monitor updates as we are still pending awaiting a failed one. - check_added_monitors(&nodes[0], 0); - } - check_added_monitors(&nodes[1], 0); - } - - // If we finish updating the monitor, we should free the holding cell right away (this did - // not occur prior to #756). - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (mon_id, _) = get_latest_mon_update_id(&nodes[0], chan_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, mon_id); - expect_payment_claimed!(nodes[0], payment_hash_0, 100_000); - - // New outbound messages should be generated immediately upon a call to - // get_and_clear_pending_msg_events (but not before). - check_added_monitors!(nodes[0], 0); - let mut events = nodes[0].node.get_and_clear_pending_msg_events(); - check_added_monitors!(nodes[0], 1); - assert_eq!(events.len(), 1); - - // Deliver the pending in-flight CS - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &cs); - check_added_monitors!(nodes[0], 1); - - let commitment_msg = match events.pop().unwrap() { - MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } => { - assert_eq!(node_id, node_b_id); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(node_a_id, &updates.update_fulfill_htlcs[0]); - expect_payment_sent(&nodes[1], payment_preimage_0, None, false, false); - assert_eq!(updates.update_add_htlcs.len(), 1); - nodes[1].node.handle_update_add_htlc(node_a_id, &updates.update_add_htlcs[0]); - updates.commitment_signed - }, - _ => panic!("Unexpected event type!"), - }; - - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &commitment_msg); - check_added_monitors!(nodes[1], 1); - - let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_revoke_and_ack); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 100000); - check_added_monitors!(nodes[1], 1); - - commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 2); - match events[0] { - Event::PendingHTLCsForwardable { .. } => {}, - _ => panic!("Unexpected event"), - }; - match events[1] { - Event::PaymentPathSuccessful { .. } => {}, - _ => panic!("Unexpected event"), - }; - - nodes[1].node.process_pending_htlc_forwards(); - expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 100000); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); -} -#[test] -fn channel_holding_cell_serialize() { - do_channel_holding_cell_serialize(true, true); - do_channel_holding_cell_serialize(true, false); - do_channel_holding_cell_serialize(false, true); // last arg doesn't matter -} - -#[derive(PartialEq)] -enum HTLCStatusAtDupClaim { - Received, - HoldingCell, - Cleared, -} -fn do_test_reconnect_dup_htlc_claims(htlc_status: HTLCStatusAtDupClaim, second_fails: bool) { - // When receiving an update_fulfill_htlc message, we immediately forward the claim backwards - // along the payment path before waiting for a full commitment_signed dance. This is great, but - // can cause duplicative claims if a node sends an update_fulfill_htlc message, disconnects, - // reconnects, and then has to re-send its update_fulfill_htlc message again. - // In previous code, we didn't handle the double-claim correctly, spuriously closing the - // channel on which the inbound HTLC was received. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - - let mut as_raa = None; - if htlc_status == HTLCStatusAtDupClaim::HoldingCell { - // In order to get the HTLC claim into the holding cell at nodes[1], we need nodes[1] to be - // awaiting a remote revoke_and_ack from nodes[0]. - let (route, second_payment_hash, _, second_payment_secret) = - get_route_and_payment_hash!(nodes[0], nodes[1], 100_000); - let onion_2 = RecipientOnionFields::secret_only(second_payment_secret); - let id_2 = PaymentId(second_payment_hash.0); - nodes[0].node.send_payment_with_route(route, second_payment_hash, onion_2, id_2).unwrap(); - check_added_monitors!(nodes[0], 1); - - let send_event = - SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event.commitment_msg); - check_added_monitors!(nodes[1], 1); - - let (bs_raa, bs_cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); - nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); - check_added_monitors!(nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); - check_added_monitors!(nodes[0], 1); - - as_raa = Some(get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id)); - } - - let fulfill_msg = - msgs::UpdateFulfillHTLC { channel_id: chan_id_2, htlc_id: 0, payment_preimage }; - if second_fails { - nodes[2].node.fail_htlc_backwards(&payment_hash); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[2], - [HTLCHandlingFailureType::Receive { payment_hash }] - ); - check_added_monitors!(nodes[2], 1); - get_htlc_update_msgs!(nodes[2], node_b_id); - } else { - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 100_000); - - let cs_updates = get_htlc_update_msgs!(nodes[2], node_b_id); - assert_eq!(cs_updates.update_fulfill_htlcs.len(), 1); - // Check that the message we're about to deliver matches the one generated: - assert_eq!(fulfill_msg, cs_updates.update_fulfill_htlcs[0]); - } - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &fulfill_msg); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - check_added_monitors!(nodes[1], 1); - - let mut bs_updates = None; - if htlc_status != HTLCStatusAtDupClaim::HoldingCell { - bs_updates = Some(get_htlc_update_msgs!(nodes[1], node_a_id)); - assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc( - node_b_id, - &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0], - ); - expect_payment_sent(&nodes[0], payment_preimage, None, false, false); - if htlc_status == HTLCStatusAtDupClaim::Cleared { - commitment_signed_dance!( - nodes[0], - nodes[1], - &bs_updates.as_ref().unwrap().commitment_signed, - false - ); - expect_payment_path_successful!(nodes[0]); - } - } else { - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - } - - nodes[1].node.peer_disconnected(node_c_id); - nodes[2].node.peer_disconnected(node_b_id); - - if second_fails { - let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); - reconnect_args.pending_htlc_fails.0 = 1; - reconnect_nodes(reconnect_args); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!( - nodes[1], - [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_id_2 }] - ); - } else { - let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); - reconnect_args.pending_htlc_claims.0 = 1; - reconnect_nodes(reconnect_args); - } - - if htlc_status == HTLCStatusAtDupClaim::HoldingCell { - nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa.unwrap()); - check_added_monitors!(nodes[1], 1); - expect_pending_htlcs_forwardable_ignore!(nodes[1]); // We finally receive the second payment, but don't claim it - - bs_updates = Some(get_htlc_update_msgs!(nodes[1], node_a_id)); - assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc( - node_b_id, - &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0], - ); - expect_payment_sent(&nodes[0], payment_preimage, None, false, false); - } - if htlc_status != HTLCStatusAtDupClaim::Cleared { - commitment_signed_dance!( - nodes[0], - nodes[1], - &bs_updates.as_ref().unwrap().commitment_signed, - false - ); - expect_payment_path_successful!(nodes[0]); - } -} - -#[test] -fn test_reconnect_dup_htlc_claims() { - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Received, false); - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::HoldingCell, false); - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Cleared, false); - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Received, true); - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::HoldingCell, true); - do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Cleared, true); -} - -#[test] -fn test_temporary_error_during_shutdown() { - // Test that temporary failures when updating the monitor's shutdown script delay cooperative - // close. - let mut config = test_default_channel_config(); - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - - 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, &[Some(config.clone()), Some(config)]); - let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - nodes[0].node.close_channel(&channel_id, &node_b_id).unwrap(); - nodes[1].node.handle_shutdown( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id), - ); - check_added_monitors!(nodes[1], 1); - - nodes[0].node.handle_shutdown( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id), - ); - check_added_monitors!(nodes[0], 1); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - - let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - nodes[1].node.handle_closing_signed( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id), - ); - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); - - nodes[0].node.handle_closing_signed( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id), - ); - let (_, closing_signed_a) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); - let txn_a = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - - nodes[1].node.handle_closing_signed(node_a_id, &closing_signed_a.unwrap()); - let (_, none_b) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); - assert!(none_b.is_none()); - let txn_b = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - - assert_eq!(txn_a, txn_b); - assert_eq!(txn_a.len(), 1); - check_spends!(txn_a[0], funding_tx); - let reason_b = ClosureReason::CounterpartyInitiatedCooperativeClosure; - check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000); - let reason_a = ClosureReason::LocallyInitiatedCooperativeClosure; - check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000); -} - -#[test] -fn double_temp_error() { - // Test that it's OK to have multiple `ChainMonitor::update_channel` calls fail in a row. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - let (_, _, channel_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); - - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - let (payment_preimage_2, payment_hash_2, ..) = - route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - // `claim_funds` results in a ChannelMonitorUpdate. - nodes[1].node.claim_funds(payment_preimage_1); - check_added_monitors!(nodes[1], 1); - let (latest_update_1, _) = get_latest_mon_update_id(&nodes[1], channel_id); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - // Previously, this would've panicked due to a double-call to `Channel::monitor_update_failed`, - // which had some asserts that prevented it from being called twice. - nodes[1].node.claim_funds(payment_preimage_2); - check_added_monitors!(nodes[1], 1); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - - let (latest_update_2, _) = get_latest_mon_update_id(&nodes[1], channel_id); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 0); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_2); - - // Complete the first HTLC. Note that as a side-effect we handle the monitor update completions - // and get both PaymentClaimed events at once. - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 2); - match events[0] { - Event::PaymentClaimed { amount_msat: 1_000_000, payment_hash, .. } => { - assert_eq!(payment_hash, payment_hash_1) - }, - _ => panic!("Unexpected Event: {:?}", events[0]), - } - match events[1] { - Event::PaymentClaimed { amount_msat: 1_000_000, payment_hash, .. } => { - assert_eq!(payment_hash, payment_hash_2) - }, - _ => panic!("Unexpected Event: {:?}", events[1]), - } - - assert_eq!(msg_events.len(), 1); - let (update_fulfill_1, commitment_signed_b1, node_id) = { - match &msg_events[0] { - &MessageSendEvent::UpdateHTLCs { - ref node_id, - channel_id: _, - updates: - msgs::CommitmentUpdate { - ref update_add_htlcs, - ref update_fulfill_htlcs, - ref update_fail_htlcs, - ref update_fail_malformed_htlcs, - ref update_fee, - ref commitment_signed, - }, - } => { - assert!(update_add_htlcs.is_empty()); - assert_eq!(update_fulfill_htlcs.len(), 1); - assert!(update_fail_htlcs.is_empty()); - assert!(update_fail_malformed_htlcs.is_empty()); - assert!(update_fee.is_none()); - (update_fulfill_htlcs[0].clone(), commitment_signed.clone(), node_id.clone()) - }, - _ => panic!("Unexpected event"), - } - }; - assert_eq!(node_id, node_a_id); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_1); - check_added_monitors!(nodes[0], 0); - expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); - nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &commitment_signed_b1); - check_added_monitors!(nodes[0], 1); - nodes[0].node.process_pending_htlc_forwards(); - let (raa_a1, commitment_signed_a1) = get_revoke_commit_msgs!(nodes[0], node_b_id); - check_added_monitors!(nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[1].node.handle_revoke_and_ack(node_a_id, &raa_a1); - check_added_monitors!(nodes[1], 1); - nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &commitment_signed_a1); - check_added_monitors!(nodes[1], 1); - - // Complete the second HTLC. - let ((update_fulfill_2, commitment_signed_b2), raa_b2) = { - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 2); - ( - match &events[0] { - MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } => { - assert_eq!(*node_id, node_a_id); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone()) - }, - _ => panic!("Unexpected event"), - }, - match events[1] { - MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { - assert_eq!(*node_id, node_a_id); - (*msg).clone() - }, - _ => panic!("Unexpected event"), - }, - ) - }; - nodes[0].node.handle_revoke_and_ack(node_b_id, &raa_b2); - check_added_monitors!(nodes[0], 1); - expect_payment_path_successful!(nodes[0]); - - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_2); - check_added_monitors!(nodes[0], 0); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - commitment_signed_dance!(nodes[0], nodes[1], commitment_signed_b2, false); - expect_payment_sent!(nodes[0], payment_preimage_2); -} - -fn do_test_outbound_reload_without_init_mon(use_0conf: bool) { - // Test that if the monitor update generated in funding_signed is stored async and we restart - // with the latest ChannelManager but the ChannelMonitor persistence never completed we happily - // drop the channel and move on. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - - let persister; - let new_chain_monitor; - - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - chan_config.channel_handshake_limits.trust_own_funding_0conf = true; - - let node_chanmgrs = - create_node_chanmgrs(2, &node_cfgs, &[Some(chan_config.clone()), Some(chan_config)]); - let node_a_reload; - - let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); - nodes[1].node.handle_open_channel( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), - ); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::OpenChannelRequest { temporary_channel_id: chan_id, .. } => { - if use_0conf { - nodes[1] - .node - .accept_inbound_channel_from_trusted_peer_0conf(&chan_id, &node_a_id, 0, None) - .unwrap(); - } else { - nodes[1].node.accept_inbound_channel(&chan_id, &node_a_id, 0, None).unwrap(); - } - }, - _ => panic!("Unexpected event"), - }; - - nodes[0].node.handle_accept_channel( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), - ); - - let (temporary_channel_id, funding_tx, ..) = - create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); - - nodes[0] - .node - .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) - .unwrap(); - check_added_monitors!(nodes[0], 0); - - let funding_created_msg = - get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); - nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); - check_added_monitors!(nodes[1], 1); - expect_channel_pending_event(&nodes[1], &node_a_id); - - let bs_signed_locked = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_signed_locked.len(), if use_0conf { 2 } else { 1 }); - match &bs_signed_locked[0] { - MessageSendEvent::SendFundingSigned { msg, .. } => { - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - nodes[0].node.handle_funding_signed(node_b_id, &msg); - check_added_monitors!(nodes[0], 1); - }, - _ => panic!("Unexpected event"), - } - if use_0conf { - match &bs_signed_locked[1] { - MessageSendEvent::SendChannelReady { msg, .. } => { - nodes[0].node.handle_channel_ready(node_b_id, &msg); - }, - _ => panic!("Unexpected event"), - } - } - - assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); - - // nodes[0] is now waiting on the first ChannelMonitor persistence to complete in order to - // broadcast the funding transaction. If nodes[0] restarts at this point with the - // ChannelMonitor lost, we should simply discard the channel. - - // The test framework checks that watched_txn/outputs match the monitor set, which they will - // not, so we have to clear them here. - nodes[0].chain_source.watched_txn.lock().unwrap().clear(); - nodes[0].chain_source.watched_outputs.lock().unwrap().clear(); - - let node_a_ser = nodes[0].node.encode(); - reload_node!(nodes[0], &node_a_ser, &[], persister, new_chain_monitor, node_a_reload); - check_closed_event!(nodes[0], 1, ClosureReason::DisconnectedPeer, [node_b_id], 100000); - assert!(nodes[0].node.list_channels().is_empty()); -} - -#[test] -fn test_outbound_reload_without_init_mon() { - do_test_outbound_reload_without_init_mon(true); - do_test_outbound_reload_without_init_mon(false); -} - -fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: bool) { - // Test that if the monitor update generated by funding_transaction_generated is stored async - // and we restart with the latest ChannelManager but the ChannelMonitor persistence never - // completed we happily drop the channel and move on. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - - let persister; - let new_chain_monitor; - - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - chan_config.channel_handshake_limits.trust_own_funding_0conf = true; - - let node_chanmgrs = - create_node_chanmgrs(2, &node_cfgs, &[Some(chan_config.clone()), Some(chan_config)]); - let node_b_reload; - - let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); - nodes[1].node.handle_open_channel( - node_a_id, - &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), - ); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::OpenChannelRequest { temporary_channel_id: chan_id, .. } => { - if use_0conf { - nodes[1] - .node - .accept_inbound_channel_from_trusted_peer_0conf(&chan_id, &node_a_id, 0, None) - .unwrap(); - } else { - nodes[1].node.accept_inbound_channel(&chan_id, &node_a_id, 0, None).unwrap(); - } - }, - _ => panic!("Unexpected event"), - }; - - nodes[0].node.handle_accept_channel( - node_b_id, - &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), - ); - - let (temporary_channel_id, funding_tx, ..) = - create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); - - nodes[0] - .node - .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) - .unwrap(); - check_added_monitors!(nodes[0], 0); - - let funding_created_msg = - get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); - check_added_monitors!(nodes[1], 1); - - // nodes[1] happily sends its funding_signed even though its awaiting the persistence of the - // initial ChannelMonitor, but it will decline to send its channel_ready even if the funding - // transaction is confirmed. - let funding_signed_msg = - get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); - - nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); - check_added_monitors!(nodes[0], 1); - expect_channel_pending_event(&nodes[0], &node_b_id); - - let as_funding_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - if lock_commitment { - confirm_transaction(&nodes[0], &as_funding_tx[0]); - confirm_transaction(&nodes[1], &as_funding_tx[0]); - } - if use_0conf || lock_commitment { - let as_ready = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id); - nodes[1].node.handle_channel_ready(node_a_id, &as_ready); - } - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // nodes[1] is now waiting on the first ChannelMonitor persistence to complete in order to - // move the channel to ready (or is waiting on the funding transaction to confirm). If nodes[1] - // restarts at this point with the ChannelMonitor lost, we should simply discard the channel. - - // The test framework checks that watched_txn/outputs match the monitor set, which they will - // not, so we have to clear them here. - nodes[1].chain_source.watched_txn.lock().unwrap().clear(); - nodes[1].chain_source.watched_outputs.lock().unwrap().clear(); - - let node_b_ser = nodes[1].node.encode(); - reload_node!(nodes[1], &node_b_ser, &[], persister, new_chain_monitor, node_b_reload); - - check_closed_event!(nodes[1], 1, ClosureReason::DisconnectedPeer, [node_a_id], 100000); - assert!(nodes[1].node.list_channels().is_empty()); -} - -#[test] -fn test_inbound_reload_without_init_mon() { - do_test_inbound_reload_without_init_mon(true, true); - do_test_inbound_reload_without_init_mon(true, false); - do_test_inbound_reload_without_init_mon(false, true); - do_test_inbound_reload_without_init_mon(false, false); -} - -#[test] -fn test_blocked_chan_preimage_release() { - // Test that even if a channel's `ChannelMonitorUpdate` flow is blocked waiting on an event to - // be handled HTLC preimage `ChannelMonitorUpdate`s will still go out. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5_000_000); - - // Tee up two payments in opposite directions across nodes[1], one it sent to generate a - // PaymentSent event and one it forwards. - let (payment_preimage_1, payment_hash_1, ..) = - route_payment(&nodes[1], &[&nodes[2]], 1_000_000); - let (payment_preimage_2, payment_hash_2, ..) = - route_payment(&nodes[2], &[&nodes[1], &nodes[0]], 1_000_000); - - // Claim the first payment to get a `PaymentSent` event (but don't handle it yet). - nodes[2].node.claim_funds(payment_preimage_1); - check_added_monitors(&nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash_1, 1_000_000); - - let cs_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[2], node_b_id); - nodes[1] - .node - .handle_update_fulfill_htlc(node_c_id, &cs_htlc_fulfill_updates.update_fulfill_htlcs[0]); - let commitment = cs_htlc_fulfill_updates.commitment_signed; - do_commitment_signed_dance(&nodes[1], &nodes[2], &commitment, false, false); - check_added_monitors(&nodes[1], 0); - - // Now claim the second payment on nodes[0], which will ultimately result in nodes[1] trying to - // claim an HTLC on its channel with nodes[2], but that channel is blocked on the above - // `PaymentSent` event. - nodes[0].node.claim_funds(payment_preimage_2); - check_added_monitors(&nodes[0], 1); - expect_payment_claimed!(nodes[0], payment_hash_2, 1_000_000); - - let as_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[0], node_b_id); - nodes[1] - .node - .handle_update_fulfill_htlc(node_a_id, &as_htlc_fulfill_updates.update_fulfill_htlcs[0]); - check_added_monitors(&nodes[1], 1); // We generate only a preimage monitor update - assert!(get_monitor!(nodes[1], chan_id_2).get_stored_preimages().contains_key(&payment_hash_2)); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Finish the CS dance between nodes[0] and nodes[1]. Note that until the event handling, the - // update_fulfill_htlc + CS is held, even though the preimage is already on disk for the - // channel. - nodes[1] - .node - .handle_commitment_signed_batch_test(node_a_id, &as_htlc_fulfill_updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - let (a, raa) = do_main_commitment_signed_dance(&nodes[1], &nodes[0], false); - assert!(a.is_none()); - - nodes[1].node.handle_revoke_and_ack(node_a_id, &raa); - check_added_monitors(&nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 3); - if let Event::PaymentSent { .. } = events[0] { - } else { - panic!(); - } - if let Event::PaymentPathSuccessful { .. } = events[2] { - } else { - panic!(); - } - if let Event::PaymentForwarded { .. } = events[1] { - } else { - panic!(); - } - - // The event processing should release the last RAA updates on both channels. - check_added_monitors(&nodes[1], 2); - - // When we fetch the next update the message getter will generate the next update for nodes[2], - // generating a further monitor update. - let bs_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[1], node_c_id); - check_added_monitors(&nodes[1], 1); - - nodes[2] - .node - .handle_update_fulfill_htlc(node_b_id, &bs_htlc_fulfill_updates.update_fulfill_htlcs[0]); - let commitment = bs_htlc_fulfill_updates.commitment_signed; - do_commitment_signed_dance(&nodes[2], &nodes[1], &commitment, false, false); - expect_payment_sent(&nodes[2], payment_preimage_2, None, true, true); -} - -fn do_test_inverted_mon_completion_order( - with_latest_manager: bool, complete_bc_commitment_dance: bool, -) { - // When we forward a payment and receive `update_fulfill_htlc`+`commitment_signed` messages - // from the downstream channel, we immediately claim the HTLC on the upstream channel, before - // even doing a `commitment_signed` dance on the downstream channel. This implies that our - // `ChannelMonitorUpdate`s are generated in the right order - first we ensure we'll get our - // money, then we write the update that resolves the downstream node claiming their money. This - // is safe as long as `ChannelMonitorUpdate`s complete in the order in which they are - // generated, but of course this may not be the case. For asynchronous update writes, we have - // to ensure monitor updates can block each other, preventing the inversion all together. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - - let persister; - let chain_mon; - let node_b_reload; - - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - // Route a payment from A, through B, to C, then claim it on C. Once we pass B the - // `update_fulfill_htlc` we have a monitor update for both of B's channels. We complete the one - // on the B<->C channel but leave the A<->B monitor update pending, then reload B. - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - - let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); - let mut manager_b = Vec::new(); - if !with_latest_manager { - manager_b = nodes[1].node.encode(); - } - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors(&nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 100_000); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); - - // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages - // for it since the monitor update is marked in-progress. - check_added_monitors(&nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now step the Commitment Signed Dance between B and C forward a bit (or fully), ensuring we - // won't get the preimage when the nodes reconnect and we have to get it from the - // ChannelMonitor. - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - if complete_bc_commitment_dance { - let (bs_revoke_and_ack, bs_commitment_signed) = - get_revoke_commit_msgs!(nodes[1], node_c_id); - nodes[2].node.handle_revoke_and_ack(node_b_id, &bs_revoke_and_ack); - check_added_monitors(&nodes[2], 1); - nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &bs_commitment_signed); - check_added_monitors(&nodes[2], 1); - let cs_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); - - // At this point node B still hasn't persisted the `ChannelMonitorUpdate` with the - // preimage in the A <-> B channel, which will prevent it from persisting the - // `ChannelMonitorUpdate` for the B<->C channel here to avoid "losing" the preimage. - nodes[1].node.handle_revoke_and_ack(node_c_id, &cs_raa); - check_added_monitors(&nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - } - - // Now reload node B - if with_latest_manager { - manager_b = nodes[1].node.encode(); - } - - let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); - reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); - - nodes[0].node.peer_disconnected(node_b_id); - nodes[2].node.peer_disconnected(node_b_id); - - if with_latest_manager { - // If we used the latest ChannelManager to reload from, we should have both channels still - // live. The B <-> C channel's final RAA ChannelMonitorUpdate must still be blocked as - // before - the ChannelMonitorUpdate for the A <-> B channel hasn't completed. - // When we call `timer_tick_occurred` we will get that monitor update back, which we'll - // complete after reconnecting to our peers. - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.timer_tick_occurred(); - check_added_monitors(&nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now reconnect B to both A and C. If the B <-> C commitment signed dance wasn't run to - // the end go ahead and do that, though the - // `pending_responding_commitment_signed_dup_monitor` in `reconnect_args` indicates that we - // expect to *not* receive the final RAA ChannelMonitorUpdate. - if complete_bc_commitment_dance { - reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2])); - } else { - let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); - reconnect_args.pending_responding_commitment_signed.1 = true; - reconnect_args.pending_responding_commitment_signed_dup_monitor.1 = true; - reconnect_args.pending_raa = (false, true); - reconnect_nodes(reconnect_args); - } - - reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); - - // (Finally) complete the A <-> B ChannelMonitorUpdate, ensuring the preimage is durably on - // disk in the proper ChannelMonitor, unblocking the B <-> C ChannelMonitor updating - // process. - let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); - nodes[1] - .chain_monitor - .chain_monitor - .channel_monitor_updated(chan_id_ab, ab_update_id) - .unwrap(); - - // When we fetch B's HTLC update messages next (now that the ChannelMonitorUpdate has - // completed), it will also release the final RAA ChannelMonitorUpdate on the B <-> C - // channel. - } else { - // If the ChannelManager used in the reload was stale, check that the B <-> C channel was - // closed. - // - // Note that this will also process the ChannelMonitorUpdates which were queued up when we - // reloaded the ChannelManager. This will re-emit the A<->B preimage as well as the B<->C - // force-closure ChannelMonitorUpdate. Once the A<->B preimage update completes, the claim - // commitment update will be allowed to go out. - check_added_monitors(&nodes[1], 0); - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let reason = ClosureReason::OutdatedChannelManager; - check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100_000); - check_added_monitors(&nodes[1], 2); - - nodes[1].node.timer_tick_occurred(); - check_added_monitors(&nodes[1], 0); - - // Don't bother to reconnect B to C - that channel has been closed. We don't need to - // exchange any messages here even though there's a pending commitment update because the - // ChannelMonitorUpdate hasn't yet completed. - reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); - - let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); - nodes[1] - .chain_monitor - .chain_monitor - .channel_monitor_updated(chan_id_ab, ab_update_id) - .unwrap(); - - // The ChannelMonitorUpdate which was completed prior to the reconnect only contained the - // preimage (as it was a replay of the original ChannelMonitorUpdate from before we - // restarted). When we go to fetch the commitment transaction updates we'll poll the - // ChannelMonitorUpdate completion, then generate (and complete) a new ChannelMonitorUpdate - // with the actual commitment transaction, which will allow us to fulfill the HTLC with - // node A. - } - - let bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id); - check_added_monitors(&nodes[1], 1); - - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); - do_commitment_signed_dance(&nodes[0], &nodes[1], &bs_updates.commitment_signed, false, false); - - expect_payment_forwarded!( - nodes[1], - &nodes[0], - &nodes[2], - Some(1_000), - false, - !with_latest_manager - ); - - // Finally, check that the payment was, ultimately, seen as sent by node A. - expect_payment_sent(&nodes[0], payment_preimage, None, true, true); -} - -#[test] -fn test_inverted_mon_completion_order() { - do_test_inverted_mon_completion_order(true, true); - do_test_inverted_mon_completion_order(true, false); - do_test_inverted_mon_completion_order(false, true); - do_test_inverted_mon_completion_order(false, false); -} - -fn do_test_durable_preimages_on_closed_channel( - close_chans_before_reload: bool, close_only_a: bool, hold_post_reload_mon_update: bool, -) { - // Test that we can apply a `ChannelMonitorUpdate` with a payment preimage even if the channel - // is force-closed between when we generate the update on reload and when we go to handle the - // update or prior to generating the update at all. - - if !close_chans_before_reload && close_only_a { - // If we're not closing, it makes no sense to "only close A" - panic!(); - } - - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - - let persister; - let chain_mon; - let node_b_reload; - - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - // Route a payment from A, through B, to C, then claim it on C. Once we pass B the - // `update_fulfill_htlc` we have a monitor update for both of B's channels. We complete the one - // on the B<->C channel but leave the A<->B monitor update pending, then reload B. - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); - - let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors(&nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); - - // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages - // for it since the monitor update is marked in-progress. - check_added_monitors(&nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now step the Commitment Signed Dance between B and C forward a bit, ensuring we won't get - // the preimage when the nodes reconnect, at which point we have to ensure we get it from the - // ChannelMonitor. - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - let _ = get_revoke_commit_msgs!(nodes[1], node_c_id); - - let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); - let err_msg = "Channel force-closed".to_owned(); - - if close_chans_before_reload { - if !close_only_a { - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1] - .node - .force_close_broadcasting_latest_txn(&chan_id_bc, &node_c_id, err_msg.clone()) - .unwrap(); - check_closed_broadcast(&nodes[1], 1, true); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100000); - } - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1] - .node - .force_close_broadcasting_latest_txn(&chan_id_ab, &node_a_id, err_msg) - .unwrap(); - check_closed_broadcast(&nodes[1], 1, true); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000); - } - - // Now reload node B - let manager_b = nodes[1].node.encode(); - reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); - - nodes[0].node.peer_disconnected(node_b_id); - nodes[2].node.peer_disconnected(node_b_id); - - if close_chans_before_reload { - // If the channels were already closed, B will rebroadcast its closing transactions here. - let bs_close_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - if close_only_a { - assert_eq!(bs_close_txn.len(), 2); - } else { - assert_eq!(bs_close_txn.len(), 3); - } - } - - let err_msg = "Channel force-closed".to_owned(); - nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, err_msg).unwrap(); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100000); - let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(as_closing_tx.len(), 1); - - // In order to give A's closing transaction to B without processing background events first, - // use the _without_consistency_checks utility method. This is similar to connecting blocks - // during startup prior to the node being full initialized. - mine_transaction_without_consistency_checks(&nodes[1], &as_closing_tx[0]); - - // After a timer tick a payment preimage ChannelMonitorUpdate is applied to the A<->B - // ChannelMonitor (possible twice), even though the channel has since been closed. - check_added_monitors(&nodes[1], 0); - let mons_added = if close_chans_before_reload { - if !close_only_a { - 4 - } else { - 3 - } - } else { - 2 - }; - if hold_post_reload_mon_update { - for _ in 0..mons_added { - persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } - } - nodes[1].node.timer_tick_occurred(); - check_added_monitors(&nodes[1], mons_added); - - // Finally, check that B created a payment preimage transaction and close out the payment. - let bs_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(bs_txn.len(), if close_chans_before_reload && !close_only_a { 2 } else { 1 }); - let bs_preimage_tx = bs_txn - .iter() - .find(|tx| tx.input[0].previous_output.txid == as_closing_tx[0].compute_txid()) - .unwrap(); - check_spends!(bs_preimage_tx, as_closing_tx[0]); - - if !close_chans_before_reload { - check_closed_broadcast(&nodes[1], 1, true); - let reason = ClosureReason::CommitmentTxConfirmed; - check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000); - } - - mine_transactions(&nodes[0], &[&as_closing_tx[0], bs_preimage_tx]); - check_closed_broadcast(&nodes[0], 1, true); - expect_payment_sent(&nodes[0], payment_preimage, None, true, true); - - if !close_chans_before_reload || close_only_a { - // Make sure the B<->C channel is still alive and well by sending a payment over it. - let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); - reconnect_args.pending_responding_commitment_signed.1 = true; - // The B<->C `ChannelMonitorUpdate` shouldn't be allowed to complete, which is the - // equivalent to the responding `commitment_signed` being a duplicate for node B, thus we - // need to set the `pending_responding_commitment_signed_dup` flag. - reconnect_args.pending_responding_commitment_signed_dup_monitor.1 = true; - reconnect_args.pending_raa.1 = true; - - reconnect_nodes(reconnect_args); - } - - // Once the blocked `ChannelMonitorUpdate` *finally* completes, the pending - // `PaymentForwarded` event will finally be released. - let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); - nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id_ab, ab_update_id); - - // If the A<->B channel was closed before we reload, we'll replay the claim against it on - // reload, causing the `PaymentForwarded` event to get replayed. - let evs = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(evs.len(), if close_chans_before_reload { 2 } else { 1 }); - for ev in evs { - if let Event::PaymentForwarded { .. } = ev { - } else { - panic!(); - } - } - - if !close_chans_before_reload || close_only_a { - // Once we call `process_pending_events` the final `ChannelMonitor` for the B<->C channel - // will fly, removing the payment preimage from it. - check_added_monitors(&nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - send_payment(&nodes[1], &[&nodes[2]], 100_000); - } -} - -#[test] -fn test_durable_preimages_on_closed_channel() { - do_test_durable_preimages_on_closed_channel(true, true, true); - do_test_durable_preimages_on_closed_channel(true, true, false); - do_test_durable_preimages_on_closed_channel(true, false, true); - do_test_durable_preimages_on_closed_channel(true, false, false); - do_test_durable_preimages_on_closed_channel(false, false, true); - do_test_durable_preimages_on_closed_channel(false, false, false); -} - -fn do_test_reload_mon_update_completion_actions(close_during_reload: bool) { - // Test that if a `ChannelMonitorUpdate` completes but a `ChannelManager` isn't serialized - // before restart we run the monitor update completion action on startup. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - - let persister; - let chain_mon; - let node_b_reload; - - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - // Route a payment from A, through B, to C, then claim it on C. Once we pass B the - // `update_fulfill_htlc`+`commitment_signed` we have a monitor update for both of B's channels. - // We complete the commitment signed dance on the B<->C channel but leave the A<->B monitor - // update pending, then reload B. At that point, the final monitor update on the B<->C channel - // is still pending because it can't fly until the preimage is persisted on the A<->B monitor. - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors(&nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); - - // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages - // for it since the monitor update is marked in-progress. - check_added_monitors(&nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Now step the Commitment Signed Dance between B and C and check that after the final RAA B - // doesn't let the preimage-removing monitor update fly. - nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - let (bs_raa, bs_cs) = get_revoke_commit_msgs!(nodes[1], node_c_id); - - nodes[2].node.handle_revoke_and_ack(node_b_id, &bs_raa); - check_added_monitors(&nodes[2], 1); - nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); - check_added_monitors(&nodes[2], 1); - - let cs_final_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); - nodes[1].node.handle_revoke_and_ack(node_c_id, &cs_final_raa); - check_added_monitors(&nodes[1], 0); - - // Finally, reload node B and check that after we call `process_pending_events` once we realize - // we've completed the A<->B preimage-including monitor update and so can release the B<->C - // preimage-removing monitor update. - let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); - let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); - let manager_b = nodes[1].node.encode(); - reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); - - let msg = "Channel force-closed".to_owned(); - if close_during_reload { - // Test that we still free the B<->C channel if the A<->B channel closed while we reloaded - // (as learned about during the on-reload block connection). - nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, msg).unwrap(); - check_added_monitors!(nodes[0], 1); - check_closed_broadcast!(nodes[0], true); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100_000); - let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - mine_transaction_without_consistency_checks(&nodes[1], &as_closing_tx[0]); - } - - let (_, bc_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_bc); - let mut events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), if close_during_reload { 2 } else { 1 }); - expect_payment_forwarded( - events.pop().unwrap(), - &nodes[1], - &nodes[0], - &nodes[2], - Some(1000), - None, - close_during_reload, - false, - false, - ); - if close_during_reload { - match events[0] { - Event::ChannelClosed { .. } => {}, - _ => panic!(), - } - check_closed_broadcast!(nodes[1], true); - } - - // Once we run event processing the monitor should free, check that it was indeed the B<->C - // channel which was updated. - check_added_monitors(&nodes[1], if close_during_reload { 2 } else { 1 }); - let (_, post_ev_bc_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_bc); - assert!(bc_update_id != post_ev_bc_update_id); - - // Finally, check that there's nothing left to do on B<->C reconnect and the channel operates - // fine. - nodes[2].node.peer_disconnected(node_b_id); - reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2])); - send_payment(&nodes[1], &[&nodes[2]], 100_000); -} - -#[test] -fn test_reload_mon_update_completion_actions() { - do_test_reload_mon_update_completion_actions(true); - do_test_reload_mon_update_completion_actions(false); -} - -fn do_test_glacial_peer_cant_hang(hold_chan_a: bool) { - // Test that if a peer manages to send an `update_fulfill_htlc` message without a - // `commitment_signed`, disconnects, then replays the `update_fulfill_htlc` message it doesn't - // result in a channel hang. This was previously broken as the `DuplicateClaim` case wasn't - // handled when claiming an HTLC and handling wasn't added when completion actions were added - // (which must always complete at some point). - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; - let _chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; - - // Route a payment from A, through B, to C, then claim it on C. Replay the - // `update_fulfill_htlc` twice on B to check that B doesn't hang. - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors(&nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); - - let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); - if hold_chan_a { - // The first update will be on the A <-> B channel, which we optionally allow to complete. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - } - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); - check_added_monitors(&nodes[1], 1); - - if !hold_chan_a { - let bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id); - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false); - expect_payment_sent!(&nodes[0], payment_preimage); - } - - nodes[1].node.peer_disconnected(node_c_id); - nodes[2].node.peer_disconnected(node_b_id); - - let mut reconnect = ReconnectArgs::new(&nodes[1], &nodes[2]); - reconnect.pending_htlc_claims = (1, 0); - reconnect_nodes(reconnect); - - if !hold_chan_a { - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - } else { - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = - get_route_and_payment_hash!(&nodes[1], nodes[2], 1_000_000); - - // With the A<->B preimage persistence not yet complete, the B<->C channel is stuck - // waiting. - let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); - let id_2 = PaymentId(payment_hash_2.0); - nodes[1].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); - check_added_monitors(&nodes[1], 0); - - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // ...but once we complete the A<->B channel preimage persistence, the B<->C channel - // unlocks and we send both peers commitment updates. - let (ab_update_id, _) = get_latest_mon_update_id(&nodes[1], chan_id_ab); - assert!(nodes[1] - .chain_monitor - .chain_monitor - .channel_monitor_updated(chan_id_ab, ab_update_id) - .is_ok()); - - let mut msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(msg_events.len(), 2); - check_added_monitors(&nodes[1], 2); - - let mut c_update = msg_events - .iter() - .filter( - |ev| matches!(ev, MessageSendEvent::UpdateHTLCs { node_id, .. } if *node_id == node_c_id), - ) - .cloned() - .collect::>(); - let a_filtermap = |ev| { - if let MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } = ev { - if node_id == node_a_id { - Some(updates) - } else { - None - } - } else { - None - } - }; - let a_update = msg_events.drain(..).filter_map(|ev| a_filtermap(ev)).collect::>(); - - assert_eq!(a_update.len(), 1); - assert_eq!(c_update.len(), 1); - - nodes[0].node.handle_update_fulfill_htlc(node_b_id, &a_update[0].update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], a_update[0].commitment_signed, false); - expect_payment_sent(&nodes[0], payment_preimage, None, true, true); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - - pass_along_path( - &nodes[1], - &[&nodes[2]], - 1_000_000, - payment_hash_2, - Some(payment_secret_2), - c_update.pop().unwrap(), - true, - None, - ); - claim_payment(&nodes[1], &[&nodes[2]], payment_preimage_2); - } -} - -#[test] -fn test_glacial_peer_cant_hang() { - do_test_glacial_peer_cant_hang(false); - do_test_glacial_peer_cant_hang(true); -} - -#[test] -fn test_partial_claim_mon_update_compl_actions() { - // Test that if we have an MPP claim that we ensure the preimage for the claim is retained in - // all the `ChannelMonitor`s until the preimage reaches every `ChannelMonitor` for a channel - // which was a part of the MPP. - 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 mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - let node_d_id = nodes[3].node.get_our_node_id(); - - let chan_1_scid = create_announced_chan_between_nodes(&nodes, 0, 1).0.contents.short_channel_id; - let chan_2_scid = create_announced_chan_between_nodes(&nodes, 0, 2).0.contents.short_channel_id; - let (chan_3_update, _, chan_3_id, ..) = create_announced_chan_between_nodes(&nodes, 1, 3); - let chan_3_scid = chan_3_update.contents.short_channel_id; - let (chan_4_update, _, chan_4_id, ..) = create_announced_chan_between_nodes(&nodes, 2, 3); - let chan_4_scid = chan_4_update.contents.short_channel_id; - - let (mut route, payment_hash, preimage, payment_secret) = - get_route_and_payment_hash!(&nodes[0], nodes[3], 100000); - let path = route.paths[0].clone(); - route.paths.push(path); - route.paths[0].hops[0].pubkey = node_b_id; - route.paths[0].hops[0].short_channel_id = chan_1_scid; - route.paths[0].hops[1].short_channel_id = chan_3_scid; - route.paths[1].hops[0].pubkey = node_c_id; - route.paths[1].hops[0].short_channel_id = chan_2_scid; - route.paths[1].hops[1].short_channel_id = chan_4_scid; - let paths = &[&[&nodes[1], &nodes[3]][..], &[&nodes[2], &nodes[3]][..]]; - send_along_route_with_secret(&nodes[0], route, paths, 200_000, payment_hash, payment_secret); - - // Claim along both paths, but only complete one of the two monitor updates. - chanmon_cfgs[3].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - chanmon_cfgs[3].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[3].node.claim_funds(preimage); - assert_eq!(nodes[3].node.get_and_clear_pending_msg_events(), Vec::new()); - assert_eq!(nodes[3].node.get_and_clear_pending_events(), Vec::new()); - check_added_monitors(&nodes[3], 2); - - // Complete the 1<->3 monitor update and play the commitment_signed dance forward until it - // blocks. - nodes[3].chain_monitor.complete_sole_pending_chan_update(&chan_3_id); - expect_payment_claimed!(&nodes[3], payment_hash, 200_000); - let updates = get_htlc_update_msgs(&nodes[3], &node_b_id); - - nodes[1].node.handle_update_fulfill_htlc(node_d_id, &updates.update_fulfill_htlcs[0]); - check_added_monitors(&nodes[1], 1); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[3], Some(1000), false, false); - let _bs_updates_for_a = get_htlc_update_msgs(&nodes[1], &node_a_id); - - nodes[1].node.handle_commitment_signed_batch_test(node_d_id, &updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &node_d_id); - - nodes[3].node.handle_revoke_and_ack(node_b_id, &bs_raa); - check_added_monitors(&nodes[3], 0); - - nodes[3].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); - check_added_monitors(&nodes[3], 0); - assert!(nodes[3].node.get_and_clear_pending_msg_events().is_empty()); - - // Now double-check that the preimage is still in the 1<->3 channel and complete the pending - // monitor update, allowing node 3 to claim the payment on the 2<->3 channel. This also - // unblocks the 1<->3 channel, allowing node 3 to release the two blocked monitor updates and - // respond to the final commitment_signed. - assert!(get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); - - nodes[3].chain_monitor.complete_sole_pending_chan_update(&chan_4_id); - let mut ds_msgs = nodes[3].node.get_and_clear_pending_msg_events(); - assert_eq!(ds_msgs.len(), 2); - check_added_monitors(&nodes[3], 2); - - match remove_first_msg_event_to_node(&node_b_id, &mut ds_msgs) { - MessageSendEvent::SendRevokeAndACK { msg, .. } => { - nodes[1].node.handle_revoke_and_ack(node_d_id, &msg); - check_added_monitors(&nodes[1], 1); - }, - _ => panic!(), - } - - match remove_first_msg_event_to_node(&node_c_id, &mut ds_msgs) { - MessageSendEvent::UpdateHTLCs { updates, .. } => { - nodes[2].node.handle_update_fulfill_htlc(node_d_id, &updates.update_fulfill_htlcs[0]); - check_added_monitors(&nodes[2], 1); - expect_payment_forwarded!(nodes[2], nodes[0], nodes[3], Some(1000), false, false); - let _cs_updates_for_a = get_htlc_update_msgs(&nodes[2], &node_a_id); - - nodes[2] - .node - .handle_commitment_signed_batch_test(node_d_id, &updates.commitment_signed); - check_added_monitors(&nodes[2], 1); - }, - _ => panic!(), - } - - let (cs_raa, cs_cs) = get_revoke_commit_msgs(&nodes[2], &node_d_id); - - nodes[3].node.handle_revoke_and_ack(node_c_id, &cs_raa); - check_added_monitors(&nodes[3], 1); - - nodes[3].node.handle_commitment_signed_batch_test(node_c_id, &cs_cs); - check_added_monitors(&nodes[3], 1); - - let ds_raa = get_event_msg!(nodes[3], MessageSendEvent::SendRevokeAndACK, node_c_id); - nodes[2].node.handle_revoke_and_ack(node_d_id, &ds_raa); - check_added_monitors(&nodes[2], 1); - - // Our current `ChannelMonitor`s store preimages one RAA longer than they need to. That's nice - // for safety, but means we have to send one more payment here to wipe the preimage. - assert!(get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); - assert!(get_monitor!(nodes[3], chan_4_id).get_stored_preimages().contains_key(&payment_hash)); - - send_payment(&nodes[1], &[&nodes[3]], 100_000); - assert!(!get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); - - send_payment(&nodes[2], &[&nodes[3]], 100_000); - assert!(!get_monitor!(nodes[3], chan_4_id).get_stored_preimages().contains_key(&payment_hash)); -} - -#[test] -fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() { - // One of the last features for async persistence we implemented was the correct blocking of - // RAA(s) which remove a preimage from an outbound channel for a forwarded payment until the - // preimage write makes it durably to the closed inbound channel. - // This tests that behavior. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - // First open channels, route a payment, and force-close the first hop. - let chan_a = - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); - let chan_b = - create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000); - - let (payment_preimage, payment_hash, ..) = - route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); - - nodes[0] - .node - .force_close_broadcasting_latest_txn(&chan_a.2, &node_b_id, String::new()) - .unwrap(); - check_added_monitors!(nodes[0], 1); - let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000); - check_closed_broadcast!(nodes[0], true); - - let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(as_commit_tx.len(), 1); - - mine_transaction(&nodes[1], &as_commit_tx[0]); - check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000); - check_closed_broadcast!(nodes[1], true); - - // Now that B has a pending forwarded payment across it with the inbound edge on-chain, claim - // the payment on C and give B the preimage for it. - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); - - let updates = get_htlc_update_msgs!(nodes[2], node_b_id); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); - check_added_monitors!(nodes[1], 1); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); - - // At this point nodes[1] has the preimage and is waiting for the `ChannelMonitorUpdate` for - // channel A to hit disk. Until it does so, it shouldn't ever let the preimage dissapear from - // channel B's `ChannelMonitor` - assert!(get_monitor!(nodes[1], chan_b.2) - .get_all_current_outbound_htlcs() - .iter() - .any(|(_, (_, preimage))| *preimage == Some(payment_preimage))); - - // Once we complete the `ChannelMonitorUpdate` on channel A, and the `ChannelManager` processes - // background events (via `get_and_clear_pending_msg_events`), the final `ChannelMonitorUpdate` - // will fly and we'll drop the preimage from channel B's `ChannelMonitor`. We'll also release - // the `Event::PaymentForwarded`. - check_added_monitors!(nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - nodes[1].chain_monitor.complete_sole_pending_chan_update(&chan_a.2); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - check_added_monitors!(nodes[1], 1); - assert!(!get_monitor!(nodes[1], chan_b.2) - .get_all_current_outbound_htlcs() - .iter() - .any(|(_, (_, preimage))| *preimage == Some(payment_preimage))); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, false); -} - -#[test] -fn test_claim_to_closed_channel_blocks_claimed_event() { - // One of the last features for async persistence we implemented was the correct blocking of - // event(s) until the preimage for a claimed HTLC is durably on disk in a ChannelMonitor for a - // closed channel. - // This tests that behavior. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - - // First open channels, route a payment, and force-close the first hop. - let chan_a = - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); - - let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - nodes[0] - .node - .force_close_broadcasting_latest_txn(&chan_a.2, &node_b_id, String::new()) - .unwrap(); - check_added_monitors!(nodes[0], 1); - let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000); - check_closed_broadcast!(nodes[0], true); - - let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(as_commit_tx.len(), 1); - - mine_transaction(&nodes[1], &as_commit_tx[0]); - check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000); - check_closed_broadcast!(nodes[1], true); - - // Now that B has a pending payment with the inbound HTLC on a closed channel, claim the - // payment on disk, but don't let the `ChannelMonitorUpdate` complete. This should prevent the - // `Event::PaymentClaimed` from being generated. - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - // Once we complete the `ChannelMonitorUpdate` the `Event::PaymentClaimed` will become - // available. - nodes[1].chain_monitor.complete_sole_pending_chan_update(&chan_a.2); - expect_payment_claimed!(nodes[1], payment_hash, 1_000_000); -} - -#[test] -#[cfg(all(feature = "std", not(target_os = "windows")))] -fn test_single_channel_multiple_mpp() { - use std::sync::atomic::{AtomicBool, Ordering}; - - // Test what happens when we attempt to claim an MPP with many parts that came to us through - // the same channel with a synchronous persistence interface which has very high latency. - // - // Previously, if a `revoke_and_ack` came in while we were still running in - // `ChannelManager::claim_payment` we'd end up hanging waiting to apply a - // `ChannelMonitorUpdate` until after it completed. See the commit which introduced this test - // for more info. - let chanmon_cfgs = create_chanmon_cfgs(9); - let node_cfgs = create_node_cfgs(9, &chanmon_cfgs); - let configs = [None, None, None, None, None, None, None, None, None]; - let node_chanmgrs = create_node_chanmgrs(9, &node_cfgs, &configs); - let mut nodes = create_network(9, &node_cfgs, &node_chanmgrs); - - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - let node_d_id = nodes[3].node.get_our_node_id(); - let node_e_id = nodes[4].node.get_our_node_id(); - let node_f_id = nodes[5].node.get_our_node_id(); - let node_g_id = nodes[6].node.get_our_node_id(); - let node_h_id = nodes[7].node.get_our_node_id(); - let node_i_id = nodes[8].node.get_our_node_id(); - - // Send an MPP payment in six parts along the path shown from top to bottom - // 0 - // 1 2 3 4 5 6 - // 7 - // 8 - // - // We can in theory reproduce this issue with fewer channels/HTLCs, but getting this test - // robust is rather challenging. We rely on having the main test thread wait on locks held in - // the background `claim_funds` thread and unlocking when the `claim_funds` thread completes a - // single `ChannelMonitorUpdate`. - // This thread calls `get_and_clear_pending_msg_events()` and `handle_revoke_and_ack()`, both - // of which require `ChannelManager` locks, but we have to make sure this thread gets a chance - // to be blocked on the mutexes before we let the background thread wake `claim_funds` so that - // the mutex can switch to this main thread. - // This relies on our locks being fair, but also on our threads getting runtime during the test - // run, which can be pretty competitive. Thus we do a dumb dance to be as conservative as - // possible - we have a background thread which completes a `ChannelMonitorUpdate` (by sending - // into the `write_blocker` mpsc) but it doesn't run until a mpsc channel sends from this main - // thread to the background thread, and then we let it sleep a while before we send the - // `ChannelMonitorUpdate` unblocker. - // Further, we give ourselves two chances each time, needing 4 HTLCs just to unlock our two - // `ChannelManager` calls. We then need a few remaining HTLCs to actually trigger the bug, so - // we use 6 HTLCs. - // Finaly, we do not run this test on Winblowz because it, somehow, in 2025, does not implement - // actual preemptive multitasking and thinks that cooperative multitasking somehow is - // acceptable in the 21st century, let alone a quarter of the way into it. - const MAX_THREAD_INIT_TIME: std::time::Duration = std::time::Duration::from_secs(1); - - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 0, 3, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 0, 4, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 0, 5, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 0, 6, 100_000, 0); - - create_announced_chan_between_nodes_with_value(&nodes, 1, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 2, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 3, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 4, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 5, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 6, 7, 100_000, 0); - create_announced_chan_between_nodes_with_value(&nodes, 7, 8, 1_000_000, 0); - - let (mut route, payment_hash, payment_preimage, payment_secret) = - get_route_and_payment_hash!(&nodes[0], nodes[8], 50_000_000); - - send_along_route_with_secret( - &nodes[0], - route, - &[ - &[&nodes[1], &nodes[7], &nodes[8]], - &[&nodes[2], &nodes[7], &nodes[8]], - &[&nodes[3], &nodes[7], &nodes[8]], - &[&nodes[4], &nodes[7], &nodes[8]], - &[&nodes[5], &nodes[7], &nodes[8]], - &[&nodes[6], &nodes[7], &nodes[8]], - ], - 50_000_000, - payment_hash, - payment_secret, - ); - - let (do_a_write, blocker) = std::sync::mpsc::sync_channel(0); - *nodes[8].chain_monitor.write_blocker.lock().unwrap() = Some(blocker); - - // Until we have std::thread::scoped we have to unsafe { turn off the borrow checker }. - // We do this by casting a pointer to a `TestChannelManager` to a pointer to a - // `TestChannelManager` with different (in this case 'static) lifetime. - // This is even suggested in the second example at - // https://doc.rust-lang.org/std/mem/fn.transmute.html#examples - let claim_node: &'static TestChannelManager<'static, 'static> = - unsafe { std::mem::transmute(nodes[8].node as &TestChannelManager) }; - let thrd = std::thread::spawn(move || { - // Initiate the claim in a background thread as it will immediately block waiting on the - // `write_blocker` we set above. - claim_node.claim_funds(payment_preimage); - }); - - // First unlock one monitor so that we have a pending - // `update_fulfill_htlc`/`commitment_signed` pair to pass to our counterparty. - do_a_write.send(()).unwrap(); - - // Then fetch the `update_fulfill_htlc`/`commitment_signed`. Note that the - // `get_and_clear_pending_msg_events` will immediately hang trying to take a peer lock which - // `claim_funds` is holding. Thus, we release a second write after a small sleep in the - // background to give `claim_funds` a chance to step forward, unblocking - // `get_and_clear_pending_msg_events`. - let do_a_write_background = do_a_write.clone(); - let block_thrd2 = AtomicBool::new(true); - let block_thrd2_read: &'static AtomicBool = unsafe { std::mem::transmute(&block_thrd2) }; - let thrd2 = std::thread::spawn(move || { - while block_thrd2_read.load(Ordering::Acquire) { - std::thread::yield_now(); - } - std::thread::sleep(MAX_THREAD_INIT_TIME); - do_a_write_background.send(()).unwrap(); - std::thread::sleep(MAX_THREAD_INIT_TIME); - do_a_write_background.send(()).unwrap(); - }); - block_thrd2.store(false, Ordering::Release); - let first_updates = get_htlc_update_msgs(&nodes[8], &node_h_id); - thrd2.join().unwrap(); - - // Disconnect node 6 from all its peers so it doesn't bother to fail the HTLCs back - nodes[7].node.peer_disconnected(node_b_id); - nodes[7].node.peer_disconnected(node_c_id); - nodes[7].node.peer_disconnected(node_d_id); - nodes[7].node.peer_disconnected(node_e_id); - nodes[7].node.peer_disconnected(node_f_id); - nodes[7].node.peer_disconnected(node_g_id); - - nodes[7].node.handle_update_fulfill_htlc(node_i_id, &first_updates.update_fulfill_htlcs[0]); - check_added_monitors(&nodes[7], 1); - expect_payment_forwarded!(nodes[7], nodes[1], nodes[8], Some(1000), false, false); - nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &first_updates.commitment_signed); - check_added_monitors(&nodes[7], 1); - let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); - - // Now, handle the `revoke_and_ack` from node 5. Note that `claim_funds` is still blocked on - // our peer lock, so we have to release a write to let it process. - // After this call completes, the channel previously would be locked up and should not be able - // to make further progress. - let do_a_write_background = do_a_write.clone(); - let block_thrd3 = AtomicBool::new(true); - let block_thrd3_read: &'static AtomicBool = unsafe { std::mem::transmute(&block_thrd3) }; - let thrd3 = std::thread::spawn(move || { - while block_thrd3_read.load(Ordering::Acquire) { - std::thread::yield_now(); - } - std::thread::sleep(MAX_THREAD_INIT_TIME); - do_a_write_background.send(()).unwrap(); - std::thread::sleep(MAX_THREAD_INIT_TIME); - do_a_write_background.send(()).unwrap(); - }); - block_thrd3.store(false, Ordering::Release); - nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); - thrd3.join().unwrap(); - assert!(!thrd.is_finished()); - - let thrd4 = std::thread::spawn(move || { - do_a_write.send(()).unwrap(); - do_a_write.send(()).unwrap(); - }); - - thrd4.join().unwrap(); - thrd.join().unwrap(); - - expect_payment_claimed!(nodes[8], payment_hash, 50_000_000); - - // At the end, we should have 7 ChannelMonitorUpdates - 6 for HTLC claims, and one for the - // above `revoke_and_ack`. - check_added_monitors(&nodes[8], 7); - - // Now drive everything to the end, at least as far as node 7 is concerned... - *nodes[8].chain_monitor.write_blocker.lock().unwrap() = None; - nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); - check_added_monitors(&nodes[8], 1); - - let (updates, raa) = get_updates_and_revoke(&nodes[8], &node_h_id); - - nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[7], nodes[2], nodes[8], Some(1000), false, false); - nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[1]); - expect_payment_forwarded!(nodes[7], nodes[3], nodes[8], Some(1000), false, false); - let mut next_source = 4; - if let Some(update) = updates.update_fulfill_htlcs.get(2) { - nodes[7].node.handle_update_fulfill_htlc(node_i_id, update); - expect_payment_forwarded!(nodes[7], nodes[4], nodes[8], Some(1000), false, false); - next_source += 1; - } - - nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &updates.commitment_signed); - nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); - if updates.update_fulfill_htlcs.get(2).is_some() { - check_added_monitors(&nodes[7], 5); - } else { - check_added_monitors(&nodes[7], 4); - } - - let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); - - nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); - nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); - check_added_monitors(&nodes[8], 2); - - let (updates, raa) = get_updates_and_revoke(&nodes[8], &node_h_id); - - nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); - next_source += 1; - nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[1]); - expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); - next_source += 1; - if let Some(update) = updates.update_fulfill_htlcs.get(2) { - nodes[7].node.handle_update_fulfill_htlc(node_i_id, update); - expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); - } - - nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &updates.commitment_signed); - nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); - if updates.update_fulfill_htlcs.get(2).is_some() { - check_added_monitors(&nodes[7], 5); - } else { - check_added_monitors(&nodes[7], 4); - } - - let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); - nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); - nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); - check_added_monitors(&nodes[8], 2); - - let raa = get_event_msg!(nodes[8], MessageSendEvent::SendRevokeAndACK, node_h_id); - nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); - check_added_monitors(&nodes[7], 1); -} +// // This file is Copyright its original authors, visible in version control +// // history. +// // +// // This file is licensed under the Apache License, Version 2.0 or the MIT license +// // , at your option. +// // You may not use this file except in accordance with one or both of these +// // licenses. + +// //! Functional tests which test the correct handling of ChannelMonitorUpdateStatus returns from +// //! monitor updates. +// //! There are a bunch of these as their handling is relatively error-prone so they are split out +// //! here. See also the chanmon_fail_consistency fuzz test. + +// use crate::chain::channelmonitor::{ChannelMonitor, ANTI_REORG_DELAY}; +// use crate::chain::{ChannelMonitorUpdateStatus, Listen, Watch}; +// use crate::events::{ClosureReason, Event, HTLCHandlingFailureType, PaymentPurpose}; +// use crate::ln::channel::AnnouncementSigsState; +// use crate::ln::channelmanager::{PaymentId, RAACommitmentOrder, RecipientOnionFields}; +// use crate::ln::msgs; +// use crate::ln::msgs::{ +// BaseMessageHandler, ChannelMessageHandler, MessageSendEvent, RoutingMessageHandler, +// }; +// use crate::ln::types::ChannelId; +// use crate::util::ser::{ReadableArgs, Writeable}; +// use crate::util::test_channel_signer::TestChannelSigner; +// use crate::util::test_utils::TestBroadcaster; +// use bitcoin::constants::genesis_block; +// use bitcoin::hash_types::BlockHash; +// use bitcoin::network::Network; + +// use crate::ln::functional_test_utils::*; + +// use crate::util::test_utils; + +// use crate::prelude::*; +// use crate::sync::{Arc, Mutex}; +// use bitcoin::hashes::Hash; + +// fn get_latest_mon_update_id<'a, 'b, 'c>( +// node: &Node<'a, 'b, 'c>, channel_id: ChannelId, +// ) -> (u64, u64) { +// let monitor_id_state = node.chain_monitor.latest_monitor_update_id.lock().unwrap(); +// monitor_id_state.get(&channel_id).unwrap().clone() +// } + +// #[test] +// fn test_monitor_and_persister_update_fail() { +// // Test that if both updating the `ChannelMonitor` and persisting the updated +// // `ChannelMonitor` fail, then the failure from updating the `ChannelMonitor` +// // one that gets returned. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// // Create some initial channel +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + +// // Rebalance the network to generate htlc in the two directions +// send_payment(&nodes[0], &[&nodes[1]], 10_000_000); + +// // Route an HTLC from node 0 to node 1 (but don't settle) +// let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 9_000_000); + +// // Make a copy of the ChainMonitor so we can capture the error it returns on a +// // bogus update. Note that if instead we updated the nodes[0]'s ChainMonitor +// // directly, the node would fail to be `Drop`'d at the end because its +// // ChannelManager and ChainMonitor would be out of sync. +// let chain_source = test_utils::TestChainSource::new(Network::Testnet); +// let logger = test_utils::TestLogger::with_id(format!("node {}", 0)); +// let persister = test_utils::TestPersister::new(); +// let tx_broadcaster = TestBroadcaster { +// txn_broadcasted: Mutex::new(Vec::new()), +// // Because we will connect a block at height 200 below, we need the TestBroadcaster to know +// // that we are at height 200 so that it doesn't think we're violating the time lock +// // requirements of transactions broadcasted at that point. +// blocks: Arc::new(Mutex::new(vec![(genesis_block(Network::Testnet), 200); 200])), +// }; +// let chain_mon = { +// let new_monitor = { +// let monitor = nodes[0].chain_monitor.chain_monitor.get_monitor(chan.2).unwrap(); +// let (_, new_monitor) = <(BlockHash, ChannelMonitor)>::read( +// &mut &monitor.encode()[..], +// (nodes[0].keys_manager, nodes[0].keys_manager), +// ) +// .unwrap(); +// assert!(new_monitor == *monitor); +// new_monitor +// }; +// let chain_mon = test_utils::TestChainMonitor::new( +// Some(&chain_source), +// &tx_broadcaster, +// &logger, +// &chanmon_cfgs[0].fee_estimator, +// &persister, +// &node_cfgs[0].keys_manager, +// ); +// assert_eq!( +// chain_mon.watch_channel(chan.2, new_monitor), +// Ok(ChannelMonitorUpdateStatus::Completed) +// ); +// chain_mon +// }; +// chain_mon +// .chain_monitor +// .block_connected(&create_dummy_block(BlockHash::all_zeros(), 42, Vec::new()), 200); + +// // Try to update ChannelMonitor +// nodes[1].node.claim_funds(preimage); +// expect_payment_claimed!(nodes[1], payment_hash, 9_000_000); +// check_added_monitors!(nodes[1], 1); + +// let updates = get_htlc_update_msgs!(nodes[1], node_a_id); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); + +// { +// let mut per_peer_lock; +// let mut peer_state_lock; +// let chan_opt = get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, chan.2); +// if let Some(channel) = chan_opt.as_funded_mut() { +// assert_eq!(updates.commitment_signed.len(), 1); +// if let Ok(Some(update)) = +// channel.commitment_signed(&updates.commitment_signed[0], &node_cfgs[0].logger) +// { +// // Check that the persister returns InProgress (and will never actually complete) +// // as the monitor update errors. +// if let ChannelMonitorUpdateStatus::InProgress = +// chain_mon.chain_monitor.update_channel(chan.2, &update) +// { +// } else { +// panic!("Expected monitor paused"); +// } +// logger.assert_log_regex( +// "lightning::chain::chainmonitor", +// regex::Regex::new("Failed to update ChannelMonitor for channel [0-9a-f]*.") +// .unwrap(), +// 1, +// ); + +// // Apply the monitor update to the original ChainMonitor, ensuring the +// // ChannelManager and ChannelMonitor aren't out of sync. +// assert_eq!( +// nodes[0].chain_monitor.update_channel(chan.2, &update), +// ChannelMonitorUpdateStatus::Completed +// ); +// } else { +// assert!(false); +// } +// } else { +// assert!(false); +// } +// } + +// check_added_monitors!(nodes[0], 1); +// expect_payment_sent(&nodes[0], preimage, None, false, false); +// } + +// fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) { +// // Test that we can recover from a simple temporary monitor update failure optionally with +// // a disconnect in between +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; + +// let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(&nodes[0], nodes[1], 1000000); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// let onion = RecipientOnionFields::secret_only(payment_secret_1); +// let id = PaymentId(payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_1, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert_eq!(nodes[0].node.list_channels().len(), 1); + +// if disconnect { +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); +// let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]); +// reconnect_args.send_channel_ready = (true, true); +// reconnect_nodes(reconnect_args); +// } + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[0], 0); + +// let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events_2.len(), 1); +// let payment_event = SendEvent::from_event(events_2.pop().unwrap()); +// assert_eq!(payment_event.node_id, node_b_id); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false); + +// expect_pending_htlcs_forwardable!(nodes[1]); + +// let events_3 = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events_3.len(), 1); +// match events_3[0] { +// Event::PaymentClaimable { +// ref payment_hash, +// ref purpose, +// amount_msat, +// receiver_node_id, +// ref via_channel_ids, +// .. +// } => { +// assert_eq!(payment_hash_1, *payment_hash); +// assert_eq!(amount_msat, 1_000_000); +// assert_eq!(receiver_node_id.unwrap(), node_b_id); +// assert_eq!(*via_channel_ids, &[(channel_id, Some(user_channel_id))]); +// match &purpose { +// PaymentPurpose::Bolt11InvoicePayment { +// payment_preimage, payment_secret, .. +// } => { +// assert!(payment_preimage.is_none()); +// assert_eq!(payment_secret_1, *payment_secret); +// }, +// _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), +// } +// }, +// _ => panic!("Unexpected event"), +// } + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); + +// // Now set it to failed again... +// let (route, payment_hash_2, _, payment_secret_2) = +// get_route_and_payment_hash!(&nodes[0], nodes[1], 1000000); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// let onion = RecipientOnionFields::secret_only(payment_secret_2); +// let id = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert_eq!(nodes[0].node.list_channels().len(), 1); + +// if disconnect { +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); +// reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); +// } + +// // ...and make sure we can force-close a frozen channel +// let err_msg = "Channel force-closed".to_owned(); +// nodes[0].node.force_close_broadcasting_latest_txn(&channel_id, &node_b_id, err_msg).unwrap(); +// check_added_monitors!(nodes[0], 1); +// check_closed_broadcast!(nodes[0], true); + +// // TODO: Once we hit the chain with the failure transaction we should check that we get a +// // PaymentPathFailed event + +// assert_eq!(nodes[0].node.list_channels().len(), 0); +// let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event!(nodes[0], 1, reason, [node_b_id], 100000); +// } + +// #[test] +// fn test_simple_monitor_temporary_update_fail() { +// do_test_simple_monitor_temporary_update_fail(false); +// do_test_simple_monitor_temporary_update_fail(true); +// } + +// fn do_test_monitor_temporary_update_fail(disconnect_count: usize) { +// let disconnect_flags = 8 | 16; + +// // Test that we can recover from a temporary monitor update failure with some in-flight +// // HTLCs going on at the same time potentially with some disconnection thrown in. +// // * First we route a payment, then get a temporary monitor update failure when trying to +// // route a second payment. We then claim the first payment. +// // * If disconnect_count is set, we will disconnect at this point (which is likely as +// // InProgress likely indicates net disconnect which resulted in failing to update the +// // ChannelMonitor on a watchtower). +// // * If !(disconnect_count & 16) we deliver a update_fulfill_htlc/CS for the first payment +// // immediately, otherwise we wait disconnect and deliver them via the reconnect +// // channel_reestablish processing (ie disconnect_count & 16 makes no sense if +// // disconnect_count & !disconnect_flags is 0). +// // * We then update the channel monitor, reconnecting if disconnect_count is set and walk +// // through message sending, potentially disconnect/reconnecting multiple times based on +// // disconnect_count, to get the update_fulfill_htlc through. +// // * We then walk through more message exchanges to get the original update_add_htlc +// // through, swapping message ordering based on disconnect_count & 8 and optionally +// // disconnect/reconnecting based on disconnect_count. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; + +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// // Now try to send a second payment which will fail to send +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let onion = RecipientOnionFields::secret_only(payment_secret_2); +// let id = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert_eq!(nodes[0].node.list_channels().len(), 1); + +// // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1] +// // but nodes[0] won't respond since it is frozen. +// nodes[1].node.claim_funds(payment_preimage_1); +// check_added_monitors!(nodes[1], 1); +// expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); + +// let events_2 = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events_2.len(), 1); +// let (bs_initial_fulfill, bs_initial_commitment_signed) = match events_2[0] { +// MessageSendEvent::UpdateHTLCs { +// ref node_id, +// channel_id: _, +// updates: +// msgs::CommitmentUpdate { +// ref update_add_htlcs, +// ref update_fulfill_htlcs, +// ref update_fail_htlcs, +// ref update_fail_malformed_htlcs, +// ref update_fee, +// ref commitment_signed, +// }, +// } => { +// assert_eq!(*node_id, node_a_id); +// assert!(update_add_htlcs.is_empty()); +// assert_eq!(update_fulfill_htlcs.len(), 1); +// assert!(update_fail_htlcs.is_empty()); +// assert!(update_fail_malformed_htlcs.is_empty()); +// assert!(update_fee.is_none()); + +// if (disconnect_count & 16) == 0 { +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_htlcs[0]); +// let events_3 = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events_3.len(), 1); +// match events_3[0] { +// Event::PaymentSent { ref payment_preimage, ref payment_hash, .. } => { +// assert_eq!(*payment_preimage, payment_preimage_1); +// assert_eq!(*payment_hash, payment_hash_1); +// }, +// _ => panic!("Unexpected event"), +// } + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, commitment_signed); +// check_added_monitors!(nodes[0], 1); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// (update_fulfill_htlcs[0].clone(), commitment_signed.clone()) +// }, +// _ => panic!("Unexpected event"), +// }; + +// if disconnect_count & !disconnect_flags > 0 { +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); +// } + +// // Now fix monitor updating... +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[0], 0); + +// macro_rules! disconnect_reconnect_peers { +// () => {{ +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; + +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert_eq!(reestablish_1.len(), 1); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); +// assert_eq!(reestablish_2.len(), 1); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); +// let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); +// nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); +// let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); + +// assert!(as_resp.0.is_none()); +// assert!(bs_resp.0.is_none()); + +// (reestablish_1, reestablish_2, as_resp, bs_resp) +// }}; +// } + +// let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 { +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert_eq!(reestablish_1.len(), 1); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); +// assert_eq!(reestablish_2.len(), 1); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); +// check_added_monitors!(nodes[0], 0); +// let mut as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); +// nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); +// check_added_monitors!(nodes[1], 0); +// let mut bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); + +// assert!(as_resp.0.is_none()); +// assert!(bs_resp.0.is_none()); + +// assert!(bs_resp.1.is_none()); +// if (disconnect_count & 16) == 0 { +// assert!(bs_resp.2.is_none()); + +// assert!(as_resp.1.is_some()); +// assert!(as_resp.2.is_some()); +// assert_eq!(as_resp.3, RAACommitmentOrder::CommitmentFirst); +// } else { +// assert!(bs_resp.2.as_ref().unwrap().update_add_htlcs.is_empty()); +// assert!(bs_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty()); +// assert!(bs_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty()); +// assert!(bs_resp.2.as_ref().unwrap().update_fee.is_none()); +// assert_eq!(bs_resp.2.as_ref().unwrap().update_fulfill_htlcs, [bs_initial_fulfill]); +// assert_eq!(bs_resp.2.as_ref().unwrap().commitment_signed, bs_initial_commitment_signed); + +// assert!(as_resp.1.is_none()); + +// nodes[0].node.handle_update_fulfill_htlc( +// node_b_id, +// &bs_resp.2.as_ref().unwrap().update_fulfill_htlcs[0], +// ); +// let events_3 = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events_3.len(), 1); +// match events_3[0] { +// Event::PaymentSent { ref payment_preimage, ref payment_hash, .. } => { +// assert_eq!(*payment_preimage, payment_preimage_1); +// assert_eq!(*payment_hash, payment_hash_1); +// }, +// _ => panic!("Unexpected event"), +// } + +// nodes[0].node.handle_commitment_signed_batch_test( +// node_b_id, +// &bs_resp.2.as_ref().unwrap().commitment_signed, +// ); +// let as_resp_raa = +// get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[0], 1); + +// as_resp.1 = Some(as_resp_raa); +// bs_resp.2 = None; +// } + +// if disconnect_count & !disconnect_flags > 1 { +// let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = +// disconnect_reconnect_peers!(); + +// if (disconnect_count & 16) == 0 { +// assert_eq!(reestablish_1, second_reestablish_1); +// assert_eq!(reestablish_2, second_reestablish_2); +// } +// assert_eq!(as_resp, second_as_resp); +// assert_eq!(bs_resp, second_bs_resp); +// } + +// ( +// SendEvent::from_commitment_update(node_b_id, channel_id, as_resp.2.unwrap()), +// as_resp.1.unwrap(), +// ) +// } else { +// let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events_4.len(), 2); +// ( +// SendEvent::from_event(events_4.remove(0)), +// match events_4[0] { +// MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { +// assert_eq!(*node_id, node_b_id); +// msg.clone() +// }, +// _ => panic!("Unexpected event"), +// }, +// ) +// }; + +// assert_eq!(payment_event.node_id, node_b_id); + +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); +// // nodes[1] is awaiting an RAA from nodes[0] still so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[1], 1); + +// if disconnect_count & !disconnect_flags > 2 { +// let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); + +// assert_eq!(as_resp.1.unwrap(), initial_revoke_and_ack); +// assert_eq!(bs_resp.1.unwrap(), bs_revoke_and_ack); + +// assert!(as_resp.2.is_none()); +// assert!(bs_resp.2.is_none()); +// } + +// let as_commitment_update; +// let bs_second_commitment_update; + +// macro_rules! handle_bs_raa { +// () => { +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_revoke_and_ack); +// as_commitment_update = get_htlc_update_msgs!(nodes[0], node_b_id); +// assert!(as_commitment_update.update_add_htlcs.is_empty()); +// assert!(as_commitment_update.update_fulfill_htlcs.is_empty()); +// assert!(as_commitment_update.update_fail_htlcs.is_empty()); +// assert!(as_commitment_update.update_fail_malformed_htlcs.is_empty()); +// assert!(as_commitment_update.update_fee.is_none()); +// check_added_monitors!(nodes[0], 1); +// }; +// } + +// macro_rules! handle_initial_raa { +// () => { +// nodes[1].node.handle_revoke_and_ack(node_a_id, &initial_revoke_and_ack); +// bs_second_commitment_update = get_htlc_update_msgs!(nodes[1], node_a_id); +// assert!(bs_second_commitment_update.update_add_htlcs.is_empty()); +// assert!(bs_second_commitment_update.update_fulfill_htlcs.is_empty()); +// assert!(bs_second_commitment_update.update_fail_htlcs.is_empty()); +// assert!(bs_second_commitment_update.update_fail_malformed_htlcs.is_empty()); +// assert!(bs_second_commitment_update.update_fee.is_none()); +// check_added_monitors!(nodes[1], 1); +// }; +// } + +// if (disconnect_count & 8) == 0 { +// handle_bs_raa!(); + +// if disconnect_count & !disconnect_flags > 3 { +// let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); + +// assert_eq!(as_resp.1.unwrap(), initial_revoke_and_ack); +// assert!(bs_resp.1.is_none()); + +// assert_eq!(as_resp.2.unwrap(), as_commitment_update); +// assert!(bs_resp.2.is_none()); + +// assert_eq!(as_resp.3, RAACommitmentOrder::RevokeAndACKFirst); +// } + +// handle_initial_raa!(); + +// if disconnect_count & !disconnect_flags > 4 { +// let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); + +// assert!(as_resp.1.is_none()); +// assert!(bs_resp.1.is_none()); + +// assert_eq!(as_resp.2.unwrap(), as_commitment_update); +// assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); +// } +// } else { +// handle_initial_raa!(); + +// if disconnect_count & !disconnect_flags > 3 { +// let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); + +// assert!(as_resp.1.is_none()); +// assert_eq!(bs_resp.1.unwrap(), bs_revoke_and_ack); + +// assert!(as_resp.2.is_none()); +// assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); + +// assert_eq!(bs_resp.3, RAACommitmentOrder::RevokeAndACKFirst); +// } + +// handle_bs_raa!(); + +// if disconnect_count & !disconnect_flags > 4 { +// let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!(); + +// assert!(as_resp.1.is_none()); +// assert!(bs_resp.1.is_none()); + +// assert_eq!(as_resp.2.unwrap(), as_commitment_update); +// assert_eq!(bs_resp.2.unwrap(), bs_second_commitment_update); +// } +// } + +// nodes[0].node.handle_commitment_signed_batch_test( +// node_b_id, +// &bs_second_commitment_update.commitment_signed, +// ); +// let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[0], 1); + +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_a_id, &as_commitment_update.commitment_signed); +// let bs_second_revoke_and_ack = +// get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); +// // No commitment_signed so get_event_msg's assert(len == 1) passes +// check_added_monitors!(nodes[1], 1); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_revoke_and_ack); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_revoke_and_ack); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[0], 1); +// expect_payment_path_successful!(nodes[0]); + +// expect_pending_htlcs_forwardable!(nodes[1]); + +// let events_5 = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events_5.len(), 1); +// match events_5[0] { +// Event::PaymentClaimable { +// ref payment_hash, +// ref purpose, +// amount_msat, +// receiver_node_id, +// ref via_channel_ids, +// .. +// } => { +// assert_eq!(payment_hash_2, *payment_hash); +// assert_eq!(amount_msat, 1_000_000); +// assert_eq!(receiver_node_id.unwrap(), node_b_id); +// assert_eq!(*via_channel_ids, [(channel_id, Some(user_channel_id))]); +// match &purpose { +// PaymentPurpose::Bolt11InvoicePayment { +// payment_preimage, payment_secret, .. +// } => { +// assert!(payment_preimage.is_none()); +// assert_eq!(payment_secret_2, *payment_secret); +// }, +// _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), +// } +// }, +// _ => panic!("Unexpected event"), +// } + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } + +// #[test] +// fn test_monitor_temporary_update_fail_a() { +// do_test_monitor_temporary_update_fail(0); +// do_test_monitor_temporary_update_fail(1); +// do_test_monitor_temporary_update_fail(2); +// do_test_monitor_temporary_update_fail(3); +// do_test_monitor_temporary_update_fail(4); +// do_test_monitor_temporary_update_fail(5); +// } + +// #[test] +// fn test_monitor_temporary_update_fail_b() { +// do_test_monitor_temporary_update_fail(2 | 8); +// do_test_monitor_temporary_update_fail(3 | 8); +// do_test_monitor_temporary_update_fail(4 | 8); +// do_test_monitor_temporary_update_fail(5 | 8); +// } + +// #[test] +// fn test_monitor_temporary_update_fail_c() { +// do_test_monitor_temporary_update_fail(1 | 16); +// do_test_monitor_temporary_update_fail(2 | 16); +// do_test_monitor_temporary_update_fail(3 | 16); +// do_test_monitor_temporary_update_fail(2 | 8 | 16); +// do_test_monitor_temporary_update_fail(3 | 8 | 16); +// } + +// #[test] +// fn test_monitor_update_fail_cs() { +// // Tests handling of a monitor update failure when processing an incoming commitment_signed +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let user_channel_id = nodes[1].node.list_channels()[0].user_channel_id; + +// let (route, our_payment_hash, payment_preimage, our_payment_secret) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion = RecipientOnionFields::secret_only(our_payment_secret); +// let id = PaymentId(our_payment_hash.0); +// nodes[0].node.send_payment_with_route(route, our_payment_hash, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let send_event = +// SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event.commitment_msg); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[1], 0); +// let responses = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(responses.len(), 2); + +// match responses[0] { +// MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => { +// assert_eq!(*node_id, node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &msg); +// check_added_monitors!(nodes[0], 1); +// }, +// _ => panic!("Unexpected event"), +// } +// match responses[1] { +// MessageSendEvent::UpdateHTLCs { ref updates, ref node_id, channel_id: _ } => { +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fulfill_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(*node_id, node_a_id); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0] +// .node +// .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[0], 1); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// }, +// _ => panic!("Unexpected event"), +// } + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[0], 0); + +// let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &final_raa); +// check_added_monitors!(nodes[1], 1); + +// expect_pending_htlcs_forwardable!(nodes[1]); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::PaymentClaimable { +// payment_hash, +// ref purpose, +// amount_msat, +// receiver_node_id, +// ref via_channel_ids, +// .. +// } => { +// assert_eq!(payment_hash, our_payment_hash); +// assert_eq!(amount_msat, 1_000_000); +// assert_eq!(receiver_node_id.unwrap(), node_b_id); +// assert_eq!(*via_channel_ids, [(channel_id, Some(user_channel_id))]); +// match &purpose { +// PaymentPurpose::Bolt11InvoicePayment { +// payment_preimage, payment_secret, .. +// } => { +// assert!(payment_preimage.is_none()); +// assert_eq!(our_payment_secret, *payment_secret); +// }, +// _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), +// } +// }, +// _ => panic!("Unexpected event"), +// }; + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); +// } + +// #[test] +// fn test_monitor_update_fail_no_rebroadcast() { +// // Tests handling of a monitor update failure when no message rebroadcasting on +// // channel_monitor_updated() is required. Backported from chanmon_fail_consistency +// // fuzz tests. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let (route, our_payment_hash, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion = RecipientOnionFields::secret_only(payment_secret_1); +// let id = PaymentId(our_payment_hash.0); +// nodes[0].node.send_payment_with_route(route, our_payment_hash, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let send_event = +// SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); +// let commitment = send_event.commitment_msg; +// let bs_raa = commitment_signed_dance!(nodes[1], nodes[0], commitment, false, true, false, true); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &bs_raa); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 0); +// expect_pending_htlcs_forwardable!(nodes[1]); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::PaymentClaimable { payment_hash, .. } => { +// assert_eq!(payment_hash, our_payment_hash); +// }, +// _ => panic!("Unexpected event"), +// } + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// } + +// #[test] +// fn test_monitor_update_raa_while_paused() { +// // Tests handling of an RAA while monitor updating has already been marked failed. +// // Backported from chanmon_fail_consistency fuzz tests as this used to be broken. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// send_payment(&nodes[0], &[&nodes[1]], 5000000); +// let (route, our_payment_hash_1, payment_preimage_1, our_payment_secret_1) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion = RecipientOnionFields::secret_only(our_payment_secret_1); +// let id = PaymentId(our_payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route, our_payment_hash_1, onion, id).unwrap(); + +// check_added_monitors!(nodes[0], 1); +// let send_event_1 = +// SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); + +// let (route, our_payment_hash_2, payment_preimage_2, our_payment_secret_2) = +// get_route_and_payment_hash!(nodes[1], nodes[0], 1000000); +// let onion_2 = RecipientOnionFields::secret_only(our_payment_secret_2); +// let id_2 = PaymentId(our_payment_hash_2.0); +// nodes[1].node.send_payment_with_route(route, our_payment_hash_2, onion_2, id_2).unwrap(); + +// check_added_monitors!(nodes[1], 1); +// let send_event_2 = +// SendEvent::from_event(nodes[1].node.get_and_clear_pending_msg_events().remove(0)); + +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event_1.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event_1.commitment_msg); +// check_added_monitors!(nodes[1], 1); +// let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.handle_update_add_htlc(node_b_id, &send_event_2.msgs[0]); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &send_event_2.commitment_msg); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[0], 1); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[0], 1); + +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[0], 0); + +// let as_update_raa = get_revoke_commit_msgs!(nodes[0], node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_update_raa.0); +// check_added_monitors!(nodes[1], 1); +// let bs_cs = get_htlc_update_msgs!(nodes[1], node_a_id); + +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_update_raa.1); +// check_added_monitors!(nodes[1], 1); +// let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs.commitment_signed); +// check_added_monitors!(nodes[0], 1); +// let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_raa); +// check_added_monitors!(nodes[0], 1); +// expect_pending_htlcs_forwardable!(nodes[0]); +// expect_payment_claimable!(nodes[0], our_payment_hash_2, our_payment_secret_2, 1000000); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_second_raa); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], our_payment_hash_1, our_payment_secret_1, 1000000); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2); +// } + +// fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { +// // Tests handling of a monitor update failure when processing an incoming RAA +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + +// // Rebalance a bit so that we can send backwards from 2 to 1. +// send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); + +// // Route a first payment that we'll fail backwards +// let (_, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000); + +// // Fail the payment backwards, failing the monitor update on nodes[1]'s receipt of the RAA +// nodes[2].node.fail_htlc_backwards(&payment_hash_1); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[2], +// [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_1 }] +// ); +// check_added_monitors!(nodes[2], 1); + +// let updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fulfill_htlcs.is_empty()); +// assert_eq!(updates.update_fail_htlcs.len(), 1); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// nodes[1].node.handle_update_fail_htlc(node_c_id, &updates.update_fail_htlcs[0]); + +// let commitment = updates.commitment_signed; +// let bs_revoke_and_ack = +// commitment_signed_dance!(nodes[1], nodes[2], commitment, false, true, false, true); +// check_added_monitors!(nodes[0], 0); + +// // While the second channel is AwaitingRAA, forward a second payment to get it into the +// // holding cell. +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[0], nodes[2], 1000000); +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let mut send_event = +// SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// check_added_monitors!(nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now fail monitor updating. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_revoke_and_ack); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// // Forward a third payment which will also be added to the holding cell, despite the channel +// // being paused waiting a monitor update. +// let (route, payment_hash_3, _, payment_secret_3) = +// get_route_and_payment_hash!(nodes[0], nodes[2], 1000000); +// let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); +// let id_3 = PaymentId(payment_hash_3.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); // We succeed in updating the monitor for the first channel +// send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true); +// check_added_monitors!(nodes[1], 0); + +// // Call forward_pending_htlcs and check that the new HTLC was simply added to the holding cell +// // and not forwarded. +// expect_pending_htlcs_forwardable!(nodes[1]); +// check_added_monitors!(nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// let (payment_preimage_4, payment_hash_4) = if test_ignore_second_cs { +// // Try to route another payment backwards from 2 to make sure 1 holds off on responding +// let (route, payment_hash_4, payment_preimage_4, payment_secret_4) = +// get_route_and_payment_hash!(nodes[2], nodes[0], 1000000); +// let onion_4 = RecipientOnionFields::secret_only(payment_secret_4); +// let id_4 = PaymentId(payment_hash_4.0); +// nodes[2].node.send_payment_with_route(route, payment_hash_4, onion_4, id_4).unwrap(); +// check_added_monitors!(nodes[2], 1); + +// send_event = +// SendEvent::from_event(nodes[2].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_c_id, &send_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &send_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// (Some(payment_preimage_4), Some(payment_hash_4)) +// } else { +// (None, None) +// }; + +// // Restore monitor updating, ensuring we immediately get a fail-back update and a +// // update_add update. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_2.2); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_2.2, latest_update); +// check_added_monitors!(nodes[1], 0); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[1], +// [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_2.2 }] +// ); +// check_added_monitors!(nodes[1], 1); + +// let mut events_3 = nodes[1].node.get_and_clear_pending_msg_events(); +// if test_ignore_second_cs { +// assert_eq!(events_3.len(), 3); +// } else { +// assert_eq!(events_3.len(), 2); +// } + +// // Note that the ordering of the events for different nodes is non-prescriptive, though the +// // ordering of the two events that both go to nodes[2] have to stay in the same order. +// let nodes_0_event = remove_first_msg_event_to_node(&node_a_id, &mut events_3); +// let messages_a = match nodes_0_event { +// MessageSendEvent::UpdateHTLCs { node_id, mut updates, channel_id: _ } => { +// assert_eq!(node_id, node_a_id); +// assert!(updates.update_fulfill_htlcs.is_empty()); +// assert_eq!(updates.update_fail_htlcs.len(), 1); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// (updates.update_fail_htlcs.remove(0), updates.commitment_signed) +// }, +// _ => panic!("Unexpected event type!"), +// }; + +// let nodes_2_event = remove_first_msg_event_to_node(&node_c_id, &mut events_3); +// let send_event_b = SendEvent::from_event(nodes_2_event); +// assert_eq!(send_event_b.node_id, node_c_id); + +// let raa = if test_ignore_second_cs { +// let nodes_2_event = remove_first_msg_event_to_node(&node_c_id, &mut events_3); +// match nodes_2_event { +// MessageSendEvent::SendRevokeAndACK { node_id, msg } => { +// assert_eq!(node_id, node_c_id); +// Some(msg.clone()) +// }, +// _ => panic!("Unexpected event"), +// } +// } else { +// None +// }; + +// // Now deliver the new messages... + +// nodes[0].node.handle_update_fail_htlc(node_b_id, &messages_a.0); +// commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false); +// expect_payment_failed!(nodes[0], payment_hash_1, true); + +// nodes[2].node.handle_update_add_htlc(node_b_id, &send_event_b.msgs[0]); +// let as_cs; +// if test_ignore_second_cs { +// nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &send_event_b.commitment_msg); +// check_added_monitors!(nodes[2], 1); +// let bs_revoke_and_ack = +// get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[2].node.handle_revoke_and_ack(node_b_id, &raa.unwrap()); +// check_added_monitors!(nodes[2], 1); +// let bs_cs = get_htlc_update_msgs!(nodes[2], node_b_id); +// assert!(bs_cs.update_add_htlcs.is_empty()); +// assert!(bs_cs.update_fail_htlcs.is_empty()); +// assert!(bs_cs.update_fail_malformed_htlcs.is_empty()); +// assert!(bs_cs.update_fulfill_htlcs.is_empty()); +// assert!(bs_cs.update_fee.is_none()); + +// nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_revoke_and_ack); +// check_added_monitors!(nodes[1], 1); +// as_cs = get_htlc_update_msgs!(nodes[1], node_c_id); + +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &bs_cs.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// } else { +// nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &send_event_b.commitment_msg); +// check_added_monitors!(nodes[2], 1); + +// let bs_revoke_and_commit = nodes[2].node.get_and_clear_pending_msg_events(); +// // As both messages are for nodes[1], they're in order. +// assert_eq!(bs_revoke_and_commit.len(), 2); +// match bs_revoke_and_commit[0] { +// MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { +// assert_eq!(*node_id, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_c_id, &msg); +// check_added_monitors!(nodes[1], 1); +// }, +// _ => panic!("Unexpected event"), +// } + +// as_cs = get_htlc_update_msgs!(nodes[1], node_c_id); + +// match bs_revoke_and_commit[1] { +// MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { +// assert_eq!(*node_id, node_b_id); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fulfill_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_c_id, &updates.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// }, +// _ => panic!("Unexpected event"), +// } +// } + +// assert_eq!(as_cs.update_add_htlcs.len(), 1); +// assert!(as_cs.update_fail_htlcs.is_empty()); +// assert!(as_cs.update_fail_malformed_htlcs.is_empty()); +// assert!(as_cs.update_fulfill_htlcs.is_empty()); +// assert!(as_cs.update_fee.is_none()); +// let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_c_id); + +// nodes[2].node.handle_update_add_htlc(node_b_id, &as_cs.update_add_htlcs[0]); +// nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &as_cs.commitment_signed); +// check_added_monitors!(nodes[2], 1); +// let bs_second_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[2].node.handle_revoke_and_ack(node_b_id, &as_raa); +// check_added_monitors!(nodes[2], 1); +// let bs_second_cs = get_htlc_update_msgs!(nodes[2], node_b_id); + +// nodes[1].node.handle_revoke_and_ack(node_c_id, &bs_second_raa); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &bs_second_cs.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// let as_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_c_id); + +// nodes[2].node.handle_revoke_and_ack(node_b_id, &as_second_raa); +// check_added_monitors!(nodes[2], 1); +// assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty()); + +// expect_pending_htlcs_forwardable!(nodes[2]); + +// let events_6 = nodes[2].node.get_and_clear_pending_events(); +// assert_eq!(events_6.len(), 2); +// match events_6[0] { +// Event::PaymentClaimable { payment_hash, .. } => { +// assert_eq!(payment_hash, payment_hash_2); +// }, +// _ => panic!("Unexpected event"), +// }; +// match events_6[1] { +// Event::PaymentClaimable { payment_hash, .. } => { +// assert_eq!(payment_hash, payment_hash_3); +// }, +// _ => panic!("Unexpected event"), +// }; + +// if test_ignore_second_cs { +// expect_pending_htlcs_forwardable!(nodes[1]); +// check_added_monitors!(nodes[1], 1); + +// send_event = SendEvent::from_node(&nodes[1]); +// assert_eq!(send_event.node_id, node_a_id); +// assert_eq!(send_event.msgs.len(), 1); +// nodes[0].node.handle_update_add_htlc(node_b_id, &send_event.msgs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], send_event.commitment_msg, false); + +// expect_pending_htlcs_forwardable!(nodes[0]); + +// let events_9 = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events_9.len(), 1); +// match events_9[0] { +// Event::PaymentClaimable { payment_hash, .. } => { +// assert_eq!(payment_hash, payment_hash_4.unwrap()) +// }, +// _ => panic!("Unexpected event"), +// }; +// claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap()); +// } + +// claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2); +// } + +// #[test] +// fn test_monitor_update_fail_raa() { +// do_test_monitor_update_fail_raa(false); +// do_test_monitor_update_fail_raa(true); +// } + +// #[test] +// fn test_monitor_update_fail_reestablish() { +// // Simple test for message retransmission after monitor update failure on +// // channel_reestablish generating a monitor update (which comes from freeing holding cell +// // HTLCs). +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// create_announced_chan_between_nodes(&nodes, 1, 2); + +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); + +// nodes[1].node.peer_disconnected(node_a_id); +// nodes[0].node.peer_disconnected(node_b_id); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); + +// let mut updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); + +// let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reestablish); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_reestablish); + +// // The "disabled" bit should be unset as we just reconnected +// let as_channel_upd = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); +// assert_eq!(as_channel_upd.contents.channel_flags & 2, 0); + +// nodes[1].node.get_and_clear_pending_msg_events(); // Free the holding cell +// check_added_monitors!(nodes[1], 1); + +// nodes[1].node.peer_disconnected(node_a_id); +// nodes[0].node.peer_disconnected(node_b_id); + +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); + +// assert_eq!(get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(), as_reestablish); +// assert_eq!(get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(), bs_reestablish); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reestablish); + +// // The "disabled" bit should be unset as we just reconnected +// let as_channel_upd = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); +// assert_eq!(as_channel_upd.contents.channel_flags & 2, 0); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_reestablish); +// check_added_monitors!(nodes[1], 0); + +// // The "disabled" bit should be unset as we just reconnected +// let bs_channel_upd = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); +// assert_eq!(bs_channel_upd.contents.channel_flags & 2, 0); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_1.2); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update); +// check_added_monitors!(nodes[1], 0); + +// updates = get_htlc_update_msgs!(nodes[1], node_a_id); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); +// expect_payment_sent!(nodes[0], payment_preimage); +// } + +// #[test] +// fn raa_no_response_awaiting_raa_state() { +// // This is a rather convoluted test which ensures that if handling of an RAA does not happen +// // due to a previous monitor update failure, we still set AwaitingRemoteRevoke on the channel +// // in question (assuming it intends to respond with a CS after monitor updating is restored). +// // Backported from chanmon_fail_consistency fuzz tests as this used to be broken. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let (payment_preimage_2, payment_hash_2, payment_secret_2) = +// get_payment_preimage_hash!(nodes[1]); +// let (payment_preimage_3, payment_hash_3, payment_secret_3) = +// get_payment_preimage_hash!(nodes[1]); + +// // Queue up two payments - one will be delivered right away, one immediately goes into the +// // holding cell as nodes[0] is AwaitingRAA. Ultimately this allows us to deliver an RAA +// // immediately after a CS. By setting failing the monitor update failure from the CS (which +// // requires only an RAA response due to AwaitingRAA) we can deliver the RAA and require the CS +// // generation during RAA while in monitor-update-failed state. +// let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); +// let id_1 = PaymentId(payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route.clone(), payment_hash_1, onion_1, id_1).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route.clone(), payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[0], 0); + +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); + +// let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); +// check_added_monitors!(nodes[0], 1); +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); +// check_added_monitors!(nodes[0], 1); +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// // Now we have a CS queued up which adds a new HTLC (which will need a RAA/CS response from +// // nodes[1]) followed by an RAA. Fail the monitor updating prior to the CS, deliver the RAA, +// // then restore channel monitor updates. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// // nodes[1] should be AwaitingRAA here! +// check_added_monitors!(nodes[1], 0); +// let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); + +// // We send a third payment here, which is somewhat of a redundant test, but the +// // chanmon_fail_consistency test required it to actually find the bug (by seeing out-of-sync +// // commitment transaction states) whereas here we can explicitly check for it. +// let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); +// let id_3 = PaymentId(payment_hash_3.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); +// check_added_monitors!(nodes[0], 0); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); +// check_added_monitors!(nodes[0], 1); +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); +// check_added_monitors!(nodes[0], 1); +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); +// let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); + +// // Finally deliver the RAA to nodes[1] which results in a CS response to the last update +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); +// let bs_update = get_htlc_update_msgs!(nodes[1], node_a_id); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// check_added_monitors!(nodes[0], 1); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_update.commitment_signed); +// check_added_monitors!(nodes[0], 1); +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_3, payment_secret_3, 1000000); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3); +// } + +// #[test] +// fn claim_while_disconnected_monitor_update_fail() { +// // Test for claiming a payment while disconnected and then having the resulting +// // channel-update-generated monitor update fail. This kind of thing isn't a particularly +// // contrived case for nodes with network instability. +// // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling +// // code introduced a regression in this test (specifically, this caught a removal of the +// // channel_reestablish handling ensuring the order was sensical given the messages used). +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// // Forward a payment for B to claim +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); + +// nodes[1].node.claim_funds(payment_preimage_1); +// check_added_monitors!(nodes[1], 1); +// expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); + +// let as_reconnect = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// let bs_reconnect = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reconnect); +// let _as_channel_update = +// get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); + +// // Now deliver a's reestablish, freeing the claim from the holding cell, but fail the monitor +// // update. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_reconnect); +// let _bs_channel_update = +// get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Send a second payment from A to B, resulting in a commitment update that gets swallowed with +// // the monitor still failed +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let as_updates = get_htlc_update_msgs!(nodes[0], node_b_id); +// nodes[1].node.handle_update_add_htlc(node_a_id, &as_updates.update_add_htlcs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_updates.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// // Note that nodes[1] not updating monitor here is OK - it wont take action on the new HTLC +// // until we've channel_monitor_update'd and updated for the new commitment transaction. + +// // Now un-fail the monitor, which will result in B sending its original commitment update, +// // receiving the commitment update from A, and the resulting commitment dances. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[1], 0); + +// let bs_msgs = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_msgs.len(), 2); + +// match bs_msgs[0] { +// MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { +// assert_eq!(*node_id, node_a_id); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &updates.update_fulfill_htlcs[0]); +// expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); +// nodes[0] +// .node +// .handle_commitment_signed_batch_test(node_b_id, &updates.commitment_signed); +// check_added_monitors!(nodes[0], 1); + +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); +// }, +// _ => panic!("Unexpected event"), +// } + +// match bs_msgs[1] { +// MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { +// assert_eq!(*node_id, node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, msg); +// check_added_monitors!(nodes[0], 1); +// }, +// _ => panic!("Unexpected event"), +// } + +// let as_commitment = get_htlc_update_msgs!(nodes[0], node_b_id); + +// let bs_commitment = get_htlc_update_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_commitment.commitment_signed); +// check_added_monitors!(nodes[0], 1); +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &as_commitment.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// check_added_monitors!(nodes[0], 1); +// expect_payment_path_successful!(nodes[0]); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } + +// #[test] +// fn monitor_failed_no_reestablish_response() { +// // Test for receiving a channel_reestablish after a monitor update failure resulted in no +// // response to a commitment_signed. +// // Backported from chanmon_fail_consistency fuzz tests as it caught a long-standing +// // debug_assert!() failure in channel_reestablish handling. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// { +// let mut per_peer_lock; +// let mut peer_state_lock; +// get_channel_ref!(nodes[0], nodes[1], per_peer_lock, peer_state_lock, channel_id) +// .context_mut() +// .announcement_sigs_state = AnnouncementSigsState::PeerReceived; +// } +// { +// let mut per_peer_lock; +// let mut peer_state_lock; +// get_channel_ref!(nodes[1], nodes[0], per_peer_lock, peer_state_lock, channel_id) +// .context_mut() +// .announcement_sigs_state = AnnouncementSigsState::PeerReceived; +// } + +// // Route the payment and deliver the initial commitment_signed (with a monitor update failure +// // on receipt). +// let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion = RecipientOnionFields::secret_only(payment_secret_1); +// let id = PaymentId(payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_1, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// // Now disconnect and immediately reconnect, delivering the channel_reestablish while nodes[1] +// // is still failing to update monitors. +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); + +// let as_reconnect = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// let bs_reconnect = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_reconnect); +// let _bs_channel_update = +// get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_reconnect); +// let _as_channel_update = +// get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[1], 0); +// let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); +// check_added_monitors!(nodes[0], 1); + +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// } + +// #[test] +// fn first_message_on_recv_ordering() { +// // Test that if the initial generator of a monitor-update-frozen state doesn't generate +// // messages, we're willing to flip the order of response messages if neccessary in resposne to +// // a commitment_signed which needs to send an RAA first. +// // At a high level, our goal is to fail monitor updating in response to an RAA which needs no +// // response and then handle a CS while in the failed state, requiring an RAA followed by a CS +// // response. To do this, we start routing two payments, with the final RAA for the first being +// // delivered while B is in AwaitingRAA, hence when we deliver the CS for the second B will +// // have no pending response but will want to send a RAA/CS (with the updates for the second +// // payment applied). +// // Backported from chanmon_fail_consistency fuzz tests as it caught a bug here. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// // Route the first payment outbound, holding the last RAA for B until we are set up so that we +// // can deliver it and fail the monitor update. +// let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); +// let id_1 = PaymentId(payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_1, onion_1, id_1).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// assert_eq!(payment_event.node_id, node_b_id); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); +// let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); +// check_added_monitors!(nodes[0], 1); + +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// // Route the second payment, generating an update_add_htlc/commitment_signed +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); + +// check_added_monitors!(nodes[0], 1); +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// assert_eq!(payment_event.node_id, node_b_id); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// // Deliver the final RAA for the first payment, which does not require a response. RAAs +// // generally require a commitment_signed, so the fact that we're expecting an opposite response +// // to the next message also tests resetting the delivery order. +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// // Now deliver the update_add_htlc/commitment_signed for the second payment, which does need an +// // RAA/CS response, which should be generated when we call channel_monitor_update (with the +// // appropriate HTLC acceptance). +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &payment_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[1], 0); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 1000000); + +// let bs_responses = get_revoke_commit_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_responses.0); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_responses.1); +// check_added_monitors!(nodes[0], 1); + +// let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } + +// #[test] +// fn test_monitor_update_fail_claim() { +// // Basic test for monitor update failures when processing claim_funds calls. +// // We set up a simple 3-node network, sending a payment from A to B and failing B's monitor +// // update to claim the payment. We then send two payments C->B->A, which are held at B. +// // Finally, we restore the channel monitor updating and claim the payment on B, forwarding +// // the payments from C onwards to A. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// create_announced_chan_between_nodes(&nodes, 1, 2); + +// // Rebalance a bit so that we can send backwards from 3 to 2. +// send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); + +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// // As long as the preimage isn't on-chain, we shouldn't expose the `PaymentClaimed` event to +// // users nor send the preimage to peers in the new commitment update. +// nodes[1].node.claim_funds(payment_preimage_1); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); + +// // Note that at this point there is a pending commitment transaction update for A being held by +// // B. Even when we go to send the payment from C through B to A, B will not update this +// // already-signed commitment transaction and will instead wait for it to resolve before +// // forwarding the payment onwards. + +// let (route, payment_hash_2, _, payment_secret_2) = +// get_route_and_payment_hash!(nodes[2], nodes[0], 1_000_000); +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[2].node.send_payment_with_route(route.clone(), payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[2], 1); + +// // Successfully update the monitor on the 1<->2 channel, but the 0<->1 channel should still be +// // paused, so forward shouldn't succeed until we call channel_monitor_updated(). +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); + +// let mut events = nodes[2].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 0); +// commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true); +// expect_pending_htlcs_forwardable_ignore!(nodes[1]); + +// let (_, payment_hash_3, payment_secret_3) = get_payment_preimage_hash!(nodes[0]); +// let id_3 = PaymentId(payment_hash_3.0); +// let onion_3 = RecipientOnionFields::secret_only(payment_secret_3); +// nodes[2].node.send_payment_with_route(route, payment_hash_3, onion_3, id_3).unwrap(); +// check_added_monitors!(nodes[2], 1); + +// let mut events = nodes[2].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 0); +// commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true); + +// // Now restore monitor updating on the 0<->1 channel and claim the funds on B. +// let channel_id = chan_1.2; +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); +// check_added_monitors!(nodes[1], 0); + +// let bs_fulfill_update = get_htlc_update_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_fulfill_update.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_fulfill_update.commitment_signed, false); +// expect_payment_sent!(nodes[0], payment_preimage_1); + +// // Get the payment forwards, note that they were batched into one commitment update. +// nodes[1].node.process_pending_htlc_forwards(); +// check_added_monitors!(nodes[1], 1); +// let bs_forward_update = get_htlc_update_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_update_add_htlc(node_b_id, &bs_forward_update.update_add_htlcs[0]); +// nodes[0].node.handle_update_add_htlc(node_b_id, &bs_forward_update.update_add_htlcs[1]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_forward_update.commitment_signed, false); +// expect_pending_htlcs_forwardable!(nodes[0]); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// Event::PaymentClaimable { +// ref payment_hash, +// ref purpose, +// amount_msat, +// receiver_node_id, +// ref via_channel_ids, +// .. +// } => { +// assert_eq!(payment_hash_2, *payment_hash); +// assert_eq!(1_000_000, amount_msat); +// assert_eq!(receiver_node_id.unwrap(), node_a_id); +// assert_eq!(*via_channel_ids.last().unwrap(), (channel_id, Some(42))); +// match &purpose { +// PaymentPurpose::Bolt11InvoicePayment { +// payment_preimage, payment_secret, .. +// } => { +// assert!(payment_preimage.is_none()); +// assert_eq!(payment_secret_2, *payment_secret); +// }, +// _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), +// } +// }, +// _ => panic!("Unexpected event"), +// } +// match events[1] { +// Event::PaymentClaimable { +// ref payment_hash, +// ref purpose, +// amount_msat, +// receiver_node_id, +// ref via_channel_ids, +// .. +// } => { +// assert_eq!(payment_hash_3, *payment_hash); +// assert_eq!(1_000_000, amount_msat); +// assert_eq!(receiver_node_id.unwrap(), node_a_id); +// assert_eq!(*via_channel_ids, [(channel_id, Some(42))]); +// match &purpose { +// PaymentPurpose::Bolt11InvoicePayment { +// payment_preimage, payment_secret, .. +// } => { +// assert!(payment_preimage.is_none()); +// assert_eq!(payment_secret_3, *payment_secret); +// }, +// _ => panic!("expected PaymentPurpose::Bolt11InvoicePayment"), +// } +// }, +// _ => panic!("Unexpected event"), +// } +// } + +// #[test] +// fn test_monitor_update_on_pending_forwards() { +// // Basic test for monitor update failures when processing pending HTLC fail/add forwards. +// // We do this with a simple 3-node network, sending a payment from A to C and one from C to A. +// // The payment from A to C will be failed by C and pending a back-fail to A, while the payment +// // from C to A will be pending a forward to A. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + +// // Rebalance a bit so that we can send backwards from 3 to 1. +// send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000); + +// let (_, payment_hash_1, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000); +// nodes[2].node.fail_htlc_backwards(&payment_hash_1); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[2], +// [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_1 }] +// ); +// check_added_monitors!(nodes[2], 1); + +// let cs_fail_update = get_htlc_update_msgs!(nodes[2], node_b_id); +// nodes[1].node.handle_update_fail_htlc(node_c_id, &cs_fail_update.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[1], nodes[2], cs_fail_update.commitment_signed, true, true); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[2], nodes[0], 1000000); +// let onion = RecipientOnionFields::secret_only(payment_secret_2); +// let id = PaymentId(payment_hash_2.0); +// nodes[2].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); +// check_added_monitors!(nodes[2], 1); + +// let mut events = nodes[2].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_c_id, &payment_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[1], +// [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_2.2 }] +// ); +// check_added_monitors!(nodes[1], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], chan_1.2); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_1.2, latest_update); +// check_added_monitors!(nodes[1], 0); + +// let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_update_fail_htlc(node_b_id, &bs_updates.update_fail_htlcs[0]); +// nodes[0].node.handle_update_add_htlc(node_b_id, &bs_updates.update_add_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 3); +// if let Event::PaymentPathFailed { payment_hash, payment_failed_permanently, .. } = events[1] { +// assert_eq!(payment_hash, payment_hash_1); +// assert!(payment_failed_permanently); +// } else { +// panic!("Unexpected event!"); +// } +// match events[2] { +// Event::PaymentFailed { payment_hash, .. } => { +// assert_eq!(payment_hash, Some(payment_hash_1)); +// }, +// _ => panic!("Unexpected event"), +// } +// match events[0] { +// Event::PendingHTLCsForwardable { .. } => {}, +// _ => panic!("Unexpected event"), +// }; +// nodes[0].node.process_pending_htlc_forwards(); +// expect_payment_claimable!(nodes[0], payment_hash_2, payment_secret_2, 1000000); + +// claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2); +// } + +// #[test] +// fn monitor_update_claim_fail_no_response() { +// // Test for claim_funds resulting in both a monitor update failure and no message response (due +// // to channel being AwaitingRAA). +// // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling +// // code was broken. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// // Forward a payment for B to claim +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// // Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 1000000); +// let onion = RecipientOnionFields::secret_only(payment_secret_2); +// let id = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let payment_event = SendEvent::from_event(events.pop().unwrap()); +// nodes[1].node.handle_update_add_htlc(node_a_id, &payment_event.msgs[0]); +// let commitment = payment_event.commitment_msg; +// let as_raa = commitment_signed_dance!(nodes[1], nodes[0], commitment, false, true, false, true); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.claim_funds(payment_preimage_1); +// check_added_monitors!(nodes[1], 1); + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// expect_payment_claimed!(nodes[1], payment_hash_1, 1_000_000); +// check_added_monitors!(nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 1000000); + +// let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false); +// expect_payment_sent!(nodes[0], payment_preimage_1); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } + +// // restore_b_before_conf has no meaning if !confirm_a_first +// // restore_b_before_lock has no meaning if confirm_a_first +// fn do_during_funding_monitor_fail( +// confirm_a_first: bool, restore_b_before_conf: bool, restore_b_before_lock: bool, +// ) { +// // Test that if the monitor update generated by funding_transaction_generated fails we continue +// // the channel setup happily after the update is restored. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); +// nodes[1].node.handle_open_channel( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), +// ); +// nodes[0].node.handle_accept_channel( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), +// ); + +// let (temporary_channel_id, funding_tx, funding_output) = +// create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); + +// nodes[0] +// .node +// .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) +// .unwrap(); +// check_added_monitors!(nodes[0], 0); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let funding_created_msg = +// get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); +// let channel_id = ChannelId::v1_from_funding_txid( +// funding_created_msg.funding_txid.as_byte_array(), +// funding_created_msg.funding_output_index, +// ); +// nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); +// check_added_monitors!(nodes[1], 1); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.handle_funding_signed( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id), +// ); +// check_added_monitors!(nodes[0], 1); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[0], 0); +// expect_channel_pending_event(&nodes[0], &node_b_id); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 0); +// assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// assert_eq!( +// nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0].compute_txid(), +// funding_output.txid +// ); + +// if confirm_a_first { +// confirm_transaction(&nodes[0], &funding_tx); +// nodes[1].node.handle_channel_ready( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id), +// ); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// } else { +// assert!(!restore_b_before_conf); +// confirm_transaction(&nodes[1], &funding_tx); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// // Make sure nodes[1] isn't stupid enough to re-send the ChannelReady on reconnect +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); +// let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]); +// reconnect_args.send_channel_ready.1 = confirm_a_first; +// reconnect_nodes(reconnect_args); + +// // But we want to re-emit ChannelPending +// expect_channel_pending_event(&nodes[1], &node_a_id); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// if !restore_b_before_conf { +// confirm_transaction(&nodes[1], &funding_tx); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// } +// if !confirm_a_first && !restore_b_before_lock { +// confirm_transaction(&nodes[0], &funding_tx); +// nodes[1].node.handle_channel_ready( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id), +// ); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// } + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// check_added_monitors!(nodes[1], 0); + +// let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first { +// if !restore_b_before_lock { +// let (channel_ready, channel_id) = +// create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]); +// ( +// channel_id, +// create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready), +// ) +// } else { +// nodes[0].node.handle_channel_ready( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, node_a_id), +// ); +// confirm_transaction(&nodes[0], &funding_tx); +// let (channel_ready, channel_id) = +// create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]); +// ( +// channel_id, +// create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready), +// ) +// } +// } else { +// if restore_b_before_conf { +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// confirm_transaction(&nodes[1], &funding_tx); +// } +// let (channel_ready, channel_id) = +// create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]); +// (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &channel_ready)) +// }; +// for (i, node) in nodes.iter().enumerate() { +// let counterparty_node_id = nodes[(i + 1) % 2].node.get_our_node_id(); +// assert!(node +// .gossip_sync +// .handle_channel_announcement(Some(counterparty_node_id), &announcement) +// .unwrap()); +// node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &as_update).unwrap(); +// node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap(); +// } + +// if !restore_b_before_lock { +// expect_channel_ready_event(&nodes[1], &node_a_id); +// } else { +// expect_channel_ready_event(&nodes[0], &node_b_id); +// } + +// send_payment(&nodes[0], &[&nodes[1]], 8000000); +// close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true); +// let reason_a = ClosureReason::CounterpartyInitiatedCooperativeClosure; +// check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000); +// let reason_b = ClosureReason::LocallyInitiatedCooperativeClosure; +// check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000); +// } + +// #[test] +// fn during_funding_monitor_fail() { +// do_during_funding_monitor_fail(true, true, false); +// do_during_funding_monitor_fail(true, false, false); +// do_during_funding_monitor_fail(false, false, false); +// do_during_funding_monitor_fail(false, false, true); +// } + +// #[test] +// fn test_path_paused_mpp() { +// // Simple test of sending a multi-part payment where one path is currently blocked awaiting +// // monitor update +// 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 mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); + +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1).0.contents.short_channel_id; +// let (chan_2_ann, _, chan_2_id, _) = create_announced_chan_between_nodes(&nodes, 0, 2); +// let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3).0.contents.short_channel_id; +// let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3).0.contents.short_channel_id; + +// let (mut route, payment_hash, payment_preimage, payment_secret) = +// get_route_and_payment_hash!(&nodes[0], nodes[3], 100000); + +// // Set us up to take multiple routes, one 0 -> 1 -> 3 and one 0 -> 2 -> 3: +// let path = route.paths[0].clone(); +// route.paths.push(path); +// route.paths[0].hops[0].pubkey = node_b_id; +// route.paths[0].hops[0].short_channel_id = chan_1_id; +// route.paths[0].hops[1].short_channel_id = chan_3_id; +// route.paths[1].hops[0].pubkey = node_c_id; +// route.paths[1].hops[0].short_channel_id = chan_2_ann.contents.short_channel_id; +// route.paths[1].hops[1].short_channel_id = chan_4_id; + +// // Set it so that the first monitor update (for the path 0 -> 1 -> 3) succeeds, but the second +// // (for the path 0 -> 2 -> 3) fails. +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// // The first path should have succeeded with the second getting a MonitorUpdateInProgress err. +// let onion = RecipientOnionFields::secret_only(payment_secret); +// let id = PaymentId(payment_hash.0); +// nodes[0].node.send_payment_with_route(route, payment_hash, onion, id).unwrap(); +// check_added_monitors!(nodes[0], 2); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); + +// // Pass the first HTLC of the payment along to nodes[3]. +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let path_1 = &[&nodes[1], &nodes[3]]; +// let ev = events.pop().unwrap(); +// pass_along_path(&nodes[0], path_1, 0, payment_hash, Some(payment_secret), ev, false, None); + +// // And check that, after we successfully update the monitor for chan_2 we can pass the second +// // HTLC along to nodes[3] and claim the whole payment back to nodes[0]. +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], chan_2_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_2_id, latest_update); + +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// let path_2 = &[&nodes[2], &nodes[3]]; +// let ev = events.pop().unwrap(); +// pass_along_path(&nodes[0], path_2, 200_000, payment_hash, Some(payment_secret), ev, true, None); + +// claim_payment_along_route(ClaimAlongRouteArgs::new( +// &nodes[0], +// &[path_1, path_2], +// payment_preimage, +// )); +// } + +// #[test] +// fn test_pending_update_fee_ack_on_reconnect() { +// // In early versions of our automated fee update patch, nodes did not correctly use the +// // previous channel feerate after sending an undelivered revoke_and_ack when re-sending an +// // undelivered commitment_signed. +// // +// // B sends A new HTLC + CS, not delivered +// // A sends B update_fee + CS +// // B receives the CS and sends RAA, previously causing B to lock in the new feerate +// // reconnect +// // B resends initial CS, using the original fee + +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// send_payment(&nodes[0], &[&nodes[1]], 100_000_00); + +// let (route, payment_hash, payment_preimage, payment_secret) = +// get_route_and_payment_hash!(&nodes[1], nodes[0], 1_000_000); +// let onion = RecipientOnionFields::secret_only(payment_secret); +// let id = PaymentId(payment_hash.0); +// nodes[1].node.send_payment_with_route(route, payment_hash, onion, id).unwrap(); +// check_added_monitors!(nodes[1], 1); +// let bs_initial_send_msgs = get_htlc_update_msgs!(nodes[1], node_a_id); +// // bs_initial_send_msgs are not delivered until they are re-generated after reconnect + +// { +// let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock *= 2; +// } +// nodes[0].node.timer_tick_occurred(); +// check_added_monitors!(nodes[0], 1); +// let as_update_fee_msgs = get_htlc_update_msgs!(nodes[0], node_b_id); +// assert!(as_update_fee_msgs.update_fee.is_some()); + +// nodes[1].node.handle_update_fee(node_a_id, as_update_fee_msgs.update_fee.as_ref().unwrap()); +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_a_id, &as_update_fee_msgs.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// let bs_first_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); +// // bs_first_raa is not delivered until it is re-generated after reconnect + +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// let as_connect_msg = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); +// let bs_connect_msg = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_connect_msg); +// let bs_resend_msgs = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_resend_msgs.len(), 3); +// if let MessageSendEvent::UpdateHTLCs { ref updates, .. } = bs_resend_msgs[0] { +// assert_eq!(*updates, bs_initial_send_msgs); +// } else { +// panic!(); +// } +// if let MessageSendEvent::SendRevokeAndACK { ref msg, .. } = bs_resend_msgs[1] { +// assert_eq!(*msg, bs_first_raa); +// } else { +// panic!(); +// } +// if let MessageSendEvent::SendChannelUpdate { .. } = bs_resend_msgs[2] { +// } else { +// panic!(); +// } + +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_connect_msg); +// get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, node_b_id); + +// nodes[0].node.handle_update_add_htlc(node_b_id, &bs_initial_send_msgs.update_add_htlcs[0]); +// nodes[0] +// .node +// .handle_commitment_signed_batch_test(node_b_id, &bs_initial_send_msgs.commitment_signed); +// check_added_monitors!(nodes[0], 1); +// nodes[1].node.handle_revoke_and_ack( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id), +// ); +// check_added_monitors!(nodes[1], 1); +// let bs_second_cs = get_htlc_update_msgs!(nodes[1], node_a_id).commitment_signed; + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_first_raa); +// check_added_monitors!(nodes[0], 1); +// nodes[1].node.handle_commitment_signed_batch_test( +// node_a_id, +// &get_htlc_update_msgs!(nodes[0], node_b_id).commitment_signed, +// ); +// check_added_monitors!(nodes[1], 1); +// let bs_third_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_second_cs); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_third_raa); +// check_added_monitors!(nodes[0], 1); + +// nodes[1].node.handle_revoke_and_ack( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id), +// ); +// check_added_monitors!(nodes[1], 1); + +// expect_pending_htlcs_forwardable!(nodes[0]); +// expect_payment_claimable!(nodes[0], payment_hash, payment_secret, 1_000_000); + +// claim_payment(&nodes[1], &[&nodes[0]], payment_preimage); +// } + +// #[test] +// fn test_fail_htlc_on_broadcast_after_claim() { +// // In an earlier version of 7e78fa660cec8a73286c94c1073ee588140e7a01 we'd also fail the inbound +// // channel backwards if we received an HTLC failure after a HTLC fulfillment. Here we test a +// // specific case of that by having the HTLC failure come from the ChannelMonitor after a dust +// // HTLC was not included in a confirmed commitment transaction. +// // +// // We first forward a payment, then claim it with an update_fulfill_htlc message, closing the +// // channel immediately before commitment occurs. After the commitment transaction reaches +// // ANTI_REORG_DELAY confirmations, will will try to fail the HTLC which was already fulfilled. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 2000); + +// let bs_txn = get_local_commitment_txn!(nodes[2], chan_id_2); +// assert_eq!(bs_txn.len(), 1); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 2000); + +// let cs_updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); +// let bs_updates = get_htlc_update_msgs!(nodes[1], node_a_id); +// check_added_monitors!(nodes[1], 1); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); + +// mine_transaction(&nodes[1], &bs_txn[0]); +// check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_c_id], 100000); +// check_closed_broadcast!(nodes[1], true); +// connect_blocks(&nodes[1], ANTI_REORG_DELAY - 1); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[1], +// [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_id_2 }] +// ); + +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); +// expect_payment_sent(&nodes[0], payment_preimage, None, false, false); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, true, true); +// expect_payment_path_successful!(nodes[0]); +// } + +// fn do_update_fee_resend_test(deliver_update: bool, parallel_updates: bool) { +// // In early versions we did not handle resending of update_fee on reconnect correctly. The +// // chanmon_consistency fuzz target, of course, immediately found it, but we test a few cases +// // explicitly here. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// send_payment(&nodes[0], &[&nodes[1]], 1000); + +// { +// let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock += 20; +// } +// nodes[0].node.timer_tick_occurred(); +// check_added_monitors!(nodes[0], 1); +// let update_msgs = get_htlc_update_msgs!(nodes[0], node_b_id); +// assert!(update_msgs.update_fee.is_some()); +// if deliver_update { +// nodes[1].node.handle_update_fee(node_a_id, update_msgs.update_fee.as_ref().unwrap()); +// } + +// if parallel_updates { +// { +// let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock += 20; +// } +// nodes[0].node.timer_tick_occurred(); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[1].node.peer_disconnected(node_a_id); + +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// let as_connect_msg = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); +// let bs_connect_msg = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &as_connect_msg); +// get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, node_a_id); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &bs_connect_msg); +// let mut as_reconnect_msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_reconnect_msgs.len(), 2); +// if let MessageSendEvent::SendChannelUpdate { .. } = as_reconnect_msgs.pop().unwrap() { +// } else { +// panic!(); +// } +// let update_msgs = +// if let MessageSendEvent::UpdateHTLCs { updates, .. } = as_reconnect_msgs.pop().unwrap() { +// updates +// } else { +// panic!(); +// }; +// assert!(update_msgs.update_fee.is_some()); +// nodes[1].node.handle_update_fee(node_a_id, update_msgs.update_fee.as_ref().unwrap()); +// if parallel_updates { +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_a_id, &update_msgs.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// let (bs_first_raa, bs_first_cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_first_raa); +// check_added_monitors!(nodes[0], 1); +// let as_second_update = get_htlc_update_msgs!(nodes[0], node_b_id); + +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_first_cs); +// check_added_monitors!(nodes[0], 1); +// let as_first_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[1].node.handle_update_fee(node_a_id, as_second_update.update_fee.as_ref().unwrap()); +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_a_id, &as_second_update.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, node_a_id); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_first_raa); +// let bs_second_cs = get_htlc_update_msgs!(nodes[1], node_a_id); +// check_added_monitors!(nodes[1], 1); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_second_raa); +// check_added_monitors!(nodes[0], 1); + +// nodes[0] +// .node +// .handle_commitment_signed_batch_test(node_b_id, &bs_second_cs.commitment_signed); +// check_added_monitors!(nodes[0], 1); +// let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_second_raa); +// check_added_monitors!(nodes[1], 1); +// } else { +// commitment_signed_dance!(nodes[1], nodes[0], update_msgs.commitment_signed, false); +// } + +// send_payment(&nodes[0], &[&nodes[1]], 1000); +// } +// #[test] +// fn update_fee_resend_test() { +// do_update_fee_resend_test(false, false); +// do_update_fee_resend_test(true, false); +// do_update_fee_resend_test(false, true); +// do_update_fee_resend_test(true, true); +// } + +// fn do_channel_holding_cell_serialize(disconnect: bool, reload_a: bool) { +// // Tests that, when we serialize a channel with AddHTLC entries in the holding cell, we +// // properly free them on reconnect. We previously failed such HTLCs upon serialization, but +// // that behavior was both somewhat unexpected and also broken (there was a debug assertion +// // which failed in such a case). +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let persister; +// let new_chain_mon; +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); +// let nodes_0_reload; +// let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let chan_id = +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 15_000_000, 7_000_000_000).2; +// let (route, payment_hash_1, payment_preimage_1, payment_secret_1) = +// get_route_and_payment_hash!(&nodes[0], nodes[1], 100000); +// let (payment_preimage_2, payment_hash_2, payment_secret_2) = +// get_payment_preimage_hash!(&nodes[1]); + +// // Do a really complicated dance to get an HTLC into the holding cell, with +// // MonitorUpdateInProgress set but AwaitingRemoteRevoke unset. When this test was written, any +// // attempts to send an HTLC while MonitorUpdateInProgress is set are immediately +// // failed-backwards. Thus, the only way to get an AddHTLC into the holding cell is to add it +// // while AwaitingRemoteRevoke is set but MonitorUpdateInProgress is unset, and then swap the +// // flags. +// // +// // We do this by: +// // a) routing a payment from node B to node A, +// // b) sending a payment from node A to node B without delivering any of the generated messages, +// // putting node A in AwaitingRemoteRevoke, +// // c) sending a second payment from node A to node B, which is immediately placed in the +// // holding cell, +// // d) claiming the first payment from B, allowing us to fail the monitor update which occurs +// // when we try to persist the payment preimage, +// // e) delivering A's commitment_signed from (b) and the resulting B revoke_and_ack message, +// // clearing AwaitingRemoteRevoke on node A. +// // +// // Note that because, at the end, MonitorUpdateInProgress is still set, the HTLC generated in +// // (c) will not be freed from the holding cell. +// let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[1], &[&nodes[0]], 100_000); + +// let onion_1 = RecipientOnionFields::secret_only(payment_secret_1); +// let id_1 = PaymentId(payment_hash_1.0); +// nodes[0].node.send_payment_with_route(route.clone(), payment_hash_1, onion_1, id_1).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let send = SendEvent::from_node(&nodes[0]); +// assert_eq!(send.msgs.len(), 1); + +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[0].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[0], 0); + +// let chan_0_monitor_serialized = get_monitor!(nodes[0], chan_id).encode(); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.claim_funds(payment_preimage_0); +// check_added_monitors!(nodes[0], 1); + +// nodes[1].node.handle_update_add_htlc(node_a_id, &send.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send.commitment_msg); +// check_added_monitors!(nodes[1], 1); + +// let (raa, cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); + +// nodes[0].node.handle_revoke_and_ack(node_b_id, &raa); +// check_added_monitors!(nodes[0], 1); + +// if disconnect { +// // Optionally reload nodes[0] entirely through a serialization roundtrip, otherwise just +// // disconnect the peers. Note that the fuzzer originally found this issue because +// // deserializing a ChannelManager in this state causes an assertion failure. +// if reload_a { +// let node_ser = nodes[0].node.encode(); +// let mons = &[&chan_0_monitor_serialized[..]]; +// reload_node!(nodes[0], &node_ser, mons, persister, new_chain_mon, nodes_0_reload); +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } else { +// nodes[0].node.peer_disconnected(node_b_id); +// } +// nodes[1].node.peer_disconnected(node_a_id); + +// // Now reconnect the two +// let init_msg = msgs::Init { +// features: nodes[1].node.init_features(), +// networks: None, +// remote_network_address: None, +// }; +// nodes[0].node.peer_connected(node_b_id, &init_msg, true).unwrap(); +// let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]); +// assert_eq!(reestablish_1.len(), 1); +// nodes[1].node.peer_connected(node_a_id, &init_msg, false).unwrap(); +// let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]); +// assert_eq!(reestablish_2.len(), 1); + +// nodes[1].node.handle_channel_reestablish(node_a_id, &reestablish_1[0]); +// let resp_1 = handle_chan_reestablish_msgs!(nodes[1], nodes[0]); +// check_added_monitors!(nodes[1], 0); + +// nodes[0].node.handle_channel_reestablish(node_b_id, &reestablish_2[0]); +// let resp_0 = handle_chan_reestablish_msgs!(nodes[0], nodes[1]); + +// assert!(resp_0.0.is_none()); +// assert!(resp_0.1.is_none()); +// assert!(resp_0.2.is_none()); +// assert!(resp_1.0.is_none()); +// assert!(resp_1.1.is_none()); + +// // Check that the freshly-generated cs is equal to the original (which we will deliver in a +// // moment). +// if let Some(pending_cs) = resp_1.2 { +// assert!(pending_cs.update_add_htlcs.is_empty()); +// assert!(pending_cs.update_fail_htlcs.is_empty()); +// assert!(pending_cs.update_fulfill_htlcs.is_empty()); +// assert_eq!(pending_cs.commitment_signed, cs); +// } else { +// panic!(); +// } + +// if reload_a { +// // The two pending monitor updates were replayed (but are still pending). +// check_added_monitors(&nodes[0], 2); +// } else { +// // There should be no monitor updates as we are still pending awaiting a failed one. +// check_added_monitors(&nodes[0], 0); +// } +// check_added_monitors(&nodes[1], 0); +// } + +// // If we finish updating the monitor, we should free the holding cell right away (this did +// // not occur prior to #756). +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (mon_id, _) = get_latest_mon_update_id(&nodes[0], chan_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, mon_id); +// expect_payment_claimed!(nodes[0], payment_hash_0, 100_000); + +// // New outbound messages should be generated immediately upon a call to +// // get_and_clear_pending_msg_events (but not before). +// check_added_monitors!(nodes[0], 0); +// let mut events = nodes[0].node.get_and_clear_pending_msg_events(); +// check_added_monitors!(nodes[0], 1); +// assert_eq!(events.len(), 1); + +// // Deliver the pending in-flight CS +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &cs); +// check_added_monitors!(nodes[0], 1); + +// let commitment_msg = match events.pop().unwrap() { +// MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } => { +// assert_eq!(node_id, node_b_id); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[1].node.handle_update_fulfill_htlc(node_a_id, &updates.update_fulfill_htlcs[0]); +// expect_payment_sent(&nodes[1], payment_preimage_0, None, false, false); +// assert_eq!(updates.update_add_htlcs.len(), 1); +// nodes[1].node.handle_update_add_htlc(node_a_id, &updates.update_add_htlcs[0]); +// updates.commitment_signed +// }, +// _ => panic!("Unexpected event type!"), +// }; + +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &commitment_msg); +// check_added_monitors!(nodes[1], 1); + +// let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_revoke_and_ack); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash_1, payment_secret_1, 100000); +// check_added_monitors!(nodes[1], 1); + +// commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// Event::PendingHTLCsForwardable { .. } => {}, +// _ => panic!("Unexpected event"), +// }; +// match events[1] { +// Event::PaymentPathSuccessful { .. } => {}, +// _ => panic!("Unexpected event"), +// }; + +// nodes[1].node.process_pending_htlc_forwards(); +// expect_payment_claimable!(nodes[1], payment_hash_2, payment_secret_2, 100000); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2); +// } +// #[test] +// fn channel_holding_cell_serialize() { +// do_channel_holding_cell_serialize(true, true); +// do_channel_holding_cell_serialize(true, false); +// do_channel_holding_cell_serialize(false, true); // last arg doesn't matter +// } + +// #[derive(PartialEq)] +// enum HTLCStatusAtDupClaim { +// Received, +// HoldingCell, +// Cleared, +// } +// fn do_test_reconnect_dup_htlc_claims(htlc_status: HTLCStatusAtDupClaim, second_fails: bool) { +// // When receiving an update_fulfill_htlc message, we immediately forward the claim backwards +// // along the payment path before waiting for a full commitment_signed dance. This is great, but +// // can cause duplicative claims if a node sends an update_fulfill_htlc message, disconnects, +// // reconnects, and then has to re-send its update_fulfill_htlc message again. +// // In previous code, we didn't handle the double-claim correctly, spuriously closing the +// // channel on which the inbound HTLC was received. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + +// let mut as_raa = None; +// if htlc_status == HTLCStatusAtDupClaim::HoldingCell { +// // In order to get the HTLC claim into the holding cell at nodes[1], we need nodes[1] to be +// // awaiting a remote revoke_and_ack from nodes[0]. +// let (route, second_payment_hash, _, second_payment_secret) = +// get_route_and_payment_hash!(nodes[0], nodes[1], 100_000); +// let onion_2 = RecipientOnionFields::secret_only(second_payment_secret); +// let id_2 = PaymentId(second_payment_hash.0); +// nodes[0].node.send_payment_with_route(route, second_payment_hash, onion_2, id_2).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let send_event = +// SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(node_a_id, &send_event.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &send_event.commitment_msg); +// check_added_monitors!(nodes[1], 1); + +// let (bs_raa, bs_cs) = get_revoke_commit_msgs!(nodes[1], node_a_id); +// nodes[0].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); +// check_added_monitors!(nodes[0], 1); + +// as_raa = Some(get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, node_b_id)); +// } + +// let fulfill_msg = +// msgs::UpdateFulfillHTLC { channel_id: chan_id_2, htlc_id: 0, payment_preimage }; +// if second_fails { +// nodes[2].node.fail_htlc_backwards(&payment_hash); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[2], +// [HTLCHandlingFailureType::Receive { payment_hash }] +// ); +// check_added_monitors!(nodes[2], 1); +// get_htlc_update_msgs!(nodes[2], node_b_id); +// } else { +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 100_000); + +// let cs_updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// assert_eq!(cs_updates.update_fulfill_htlcs.len(), 1); +// // Check that the message we're about to deliver matches the one generated: +// assert_eq!(fulfill_msg, cs_updates.update_fulfill_htlcs[0]); +// } +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &fulfill_msg); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// check_added_monitors!(nodes[1], 1); + +// let mut bs_updates = None; +// if htlc_status != HTLCStatusAtDupClaim::HoldingCell { +// bs_updates = Some(get_htlc_update_msgs!(nodes[1], node_a_id)); +// assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc( +// node_b_id, +// &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0], +// ); +// expect_payment_sent(&nodes[0], payment_preimage, None, false, false); +// if htlc_status == HTLCStatusAtDupClaim::Cleared { +// commitment_signed_dance!( +// nodes[0], +// nodes[1], +// &bs_updates.as_ref().unwrap().commitment_signed, +// false +// ); +// expect_payment_path_successful!(nodes[0]); +// } +// } else { +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// nodes[1].node.peer_disconnected(node_c_id); +// nodes[2].node.peer_disconnected(node_b_id); + +// if second_fails { +// let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); +// reconnect_args.pending_htlc_fails.0 = 1; +// reconnect_nodes(reconnect_args); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!( +// nodes[1], +// [HTLCHandlingFailureType::Forward { node_id: Some(node_c_id), channel_id: chan_id_2 }] +// ); +// } else { +// let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); +// reconnect_args.pending_htlc_claims.0 = 1; +// reconnect_nodes(reconnect_args); +// } + +// if htlc_status == HTLCStatusAtDupClaim::HoldingCell { +// nodes[1].node.handle_revoke_and_ack(node_a_id, &as_raa.unwrap()); +// check_added_monitors!(nodes[1], 1); +// expect_pending_htlcs_forwardable_ignore!(nodes[1]); // We finally receive the second payment, but don't claim it + +// bs_updates = Some(get_htlc_update_msgs!(nodes[1], node_a_id)); +// assert_eq!(bs_updates.as_ref().unwrap().update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc( +// node_b_id, +// &bs_updates.as_ref().unwrap().update_fulfill_htlcs[0], +// ); +// expect_payment_sent(&nodes[0], payment_preimage, None, false, false); +// } +// if htlc_status != HTLCStatusAtDupClaim::Cleared { +// commitment_signed_dance!( +// nodes[0], +// nodes[1], +// &bs_updates.as_ref().unwrap().commitment_signed, +// false +// ); +// expect_payment_path_successful!(nodes[0]); +// } +// } + +// #[test] +// fn test_reconnect_dup_htlc_claims() { +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Received, false); +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::HoldingCell, false); +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Cleared, false); +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Received, true); +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::HoldingCell, true); +// do_test_reconnect_dup_htlc_claims(HTLCStatusAtDupClaim::Cleared, true); +// } + +// #[test] +// fn test_temporary_error_during_shutdown() { +// // Test that temporary failures when updating the monitor's shutdown script delay cooperative +// // close. +// let mut config = test_default_channel_config(); +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; + +// 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, &[Some(config.clone()), Some(config)]); +// let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// nodes[0].node.close_channel(&channel_id, &node_b_id).unwrap(); +// nodes[1].node.handle_shutdown( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, node_b_id), +// ); +// check_added_monitors!(nodes[1], 1); + +// nodes[0].node.handle_shutdown( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, node_a_id), +// ); +// check_added_monitors!(nodes[0], 1); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); + +// let (latest_update, _) = get_latest_mon_update_id(&nodes[0], channel_id); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); +// nodes[1].node.handle_closing_signed( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, node_b_id), +// ); + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (latest_update, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update); + +// nodes[0].node.handle_closing_signed( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, node_a_id), +// ); +// let (_, closing_signed_a) = get_closing_signed_broadcast!(nodes[0].node, node_b_id); +// let txn_a = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); + +// nodes[1].node.handle_closing_signed(node_a_id, &closing_signed_a.unwrap()); +// let (_, none_b) = get_closing_signed_broadcast!(nodes[1].node, node_a_id); +// assert!(none_b.is_none()); +// let txn_b = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); + +// assert_eq!(txn_a, txn_b); +// assert_eq!(txn_a.len(), 1); +// check_spends!(txn_a[0], funding_tx); +// let reason_b = ClosureReason::CounterpartyInitiatedCooperativeClosure; +// check_closed_event!(nodes[1], 1, reason_b, [node_a_id], 100000); +// let reason_a = ClosureReason::LocallyInitiatedCooperativeClosure; +// check_closed_event!(nodes[0], 1, reason_a, [node_b_id], 100000); +// } + +// #[test] +// fn double_temp_error() { +// // Test that it's OK to have multiple `ChainMonitor::update_channel` calls fail in a row. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// let (_, _, channel_id, _) = create_announced_chan_between_nodes(&nodes, 0, 1); + +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); +// let (payment_preimage_2, payment_hash_2, ..) = +// route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// // `claim_funds` results in a ChannelMonitorUpdate. +// nodes[1].node.claim_funds(payment_preimage_1); +// check_added_monitors!(nodes[1], 1); +// let (latest_update_1, _) = get_latest_mon_update_id(&nodes[1], channel_id); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// // Previously, this would've panicked due to a double-call to `Channel::monitor_update_failed`, +// // which had some asserts that prevented it from being called twice. +// nodes[1].node.claim_funds(payment_preimage_2); +// check_added_monitors!(nodes[1], 1); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); + +// let (latest_update_2, _) = get_latest_mon_update_id(&nodes[1], channel_id); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 0); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(channel_id, latest_update_2); + +// // Complete the first HTLC. Note that as a side-effect we handle the monitor update completions +// // and get both PaymentClaimed events at once. +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// Event::PaymentClaimed { amount_msat: 1_000_000, payment_hash, .. } => { +// assert_eq!(payment_hash, payment_hash_1) +// }, +// _ => panic!("Unexpected Event: {:?}", events[0]), +// } +// match events[1] { +// Event::PaymentClaimed { amount_msat: 1_000_000, payment_hash, .. } => { +// assert_eq!(payment_hash, payment_hash_2) +// }, +// _ => panic!("Unexpected Event: {:?}", events[1]), +// } + +// assert_eq!(msg_events.len(), 1); +// let (update_fulfill_1, commitment_signed_b1, node_id) = { +// match &msg_events[0] { +// &MessageSendEvent::UpdateHTLCs { +// ref node_id, +// channel_id: _, +// updates: +// msgs::CommitmentUpdate { +// ref update_add_htlcs, +// ref update_fulfill_htlcs, +// ref update_fail_htlcs, +// ref update_fail_malformed_htlcs, +// ref update_fee, +// ref commitment_signed, +// }, +// } => { +// assert!(update_add_htlcs.is_empty()); +// assert_eq!(update_fulfill_htlcs.len(), 1); +// assert!(update_fail_htlcs.is_empty()); +// assert!(update_fail_malformed_htlcs.is_empty()); +// assert!(update_fee.is_none()); +// (update_fulfill_htlcs[0].clone(), commitment_signed.clone(), node_id.clone()) +// }, +// _ => panic!("Unexpected event"), +// } +// }; +// assert_eq!(node_id, node_a_id); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_1); +// check_added_monitors!(nodes[0], 0); +// expect_payment_sent(&nodes[0], payment_preimage_1, None, false, false); +// nodes[0].node.handle_commitment_signed_batch_test(node_b_id, &commitment_signed_b1); +// check_added_monitors!(nodes[0], 1); +// nodes[0].node.process_pending_htlc_forwards(); +// let (raa_a1, commitment_signed_a1) = get_revoke_commit_msgs!(nodes[0], node_b_id); +// check_added_monitors!(nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// nodes[1].node.handle_revoke_and_ack(node_a_id, &raa_a1); +// check_added_monitors!(nodes[1], 1); +// nodes[1].node.handle_commitment_signed_batch_test(node_a_id, &commitment_signed_a1); +// check_added_monitors!(nodes[1], 1); + +// // Complete the second HTLC. +// let ((update_fulfill_2, commitment_signed_b2), raa_b2) = { +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 2); +// ( +// match &events[0] { +// MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } => { +// assert_eq!(*node_id, node_a_id); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone()) +// }, +// _ => panic!("Unexpected event"), +// }, +// match events[1] { +// MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => { +// assert_eq!(*node_id, node_a_id); +// (*msg).clone() +// }, +// _ => panic!("Unexpected event"), +// }, +// ) +// }; +// nodes[0].node.handle_revoke_and_ack(node_b_id, &raa_b2); +// check_added_monitors!(nodes[0], 1); +// expect_payment_path_successful!(nodes[0]); + +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &update_fulfill_2); +// check_added_monitors!(nodes[0], 0); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// commitment_signed_dance!(nodes[0], nodes[1], commitment_signed_b2, false); +// expect_payment_sent!(nodes[0], payment_preimage_2); +// } + +// fn do_test_outbound_reload_without_init_mon(use_0conf: bool) { +// // Test that if the monitor update generated in funding_signed is stored async and we restart +// // with the latest ChannelManager but the ChannelMonitor persistence never completed we happily +// // drop the channel and move on. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + +// let persister; +// let new_chain_monitor; + +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; +// chan_config.channel_handshake_limits.trust_own_funding_0conf = true; + +// let node_chanmgrs = +// create_node_chanmgrs(2, &node_cfgs, &[Some(chan_config.clone()), Some(chan_config)]); +// let node_a_reload; + +// let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); +// nodes[1].node.handle_open_channel( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), +// ); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id: chan_id, .. } => { +// if use_0conf { +// nodes[1] +// .node +// .accept_inbound_channel_from_trusted_peer_0conf(&chan_id, &node_a_id, 0, None) +// .unwrap(); +// } else { +// nodes[1].node.accept_inbound_channel(&chan_id, &node_a_id, 0, None).unwrap(); +// } +// }, +// _ => panic!("Unexpected event"), +// }; + +// nodes[0].node.handle_accept_channel( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), +// ); + +// let (temporary_channel_id, funding_tx, ..) = +// create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); + +// nodes[0] +// .node +// .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) +// .unwrap(); +// check_added_monitors!(nodes[0], 0); + +// let funding_created_msg = +// get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); +// nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); +// check_added_monitors!(nodes[1], 1); +// expect_channel_pending_event(&nodes[1], &node_a_id); + +// let bs_signed_locked = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_signed_locked.len(), if use_0conf { 2 } else { 1 }); +// match &bs_signed_locked[0] { +// MessageSendEvent::SendFundingSigned { msg, .. } => { +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// nodes[0].node.handle_funding_signed(node_b_id, &msg); +// check_added_monitors!(nodes[0], 1); +// }, +// _ => panic!("Unexpected event"), +// } +// if use_0conf { +// match &bs_signed_locked[1] { +// MessageSendEvent::SendChannelReady { msg, .. } => { +// nodes[0].node.handle_channel_ready(node_b_id, &msg); +// }, +// _ => panic!("Unexpected event"), +// } +// } + +// assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[0].node.get_and_clear_pending_events().is_empty()); + +// // nodes[0] is now waiting on the first ChannelMonitor persistence to complete in order to +// // broadcast the funding transaction. If nodes[0] restarts at this point with the +// // ChannelMonitor lost, we should simply discard the channel. + +// // The test framework checks that watched_txn/outputs match the monitor set, which they will +// // not, so we have to clear them here. +// nodes[0].chain_source.watched_txn.lock().unwrap().clear(); +// nodes[0].chain_source.watched_outputs.lock().unwrap().clear(); + +// let node_a_ser = nodes[0].node.encode(); +// reload_node!(nodes[0], &node_a_ser, &[], persister, new_chain_monitor, node_a_reload); +// check_closed_event!(nodes[0], 1, ClosureReason::DisconnectedPeer, [node_b_id], 100000); +// assert!(nodes[0].node.list_channels().is_empty()); +// } + +// #[test] +// fn test_outbound_reload_without_init_mon() { +// do_test_outbound_reload_without_init_mon(true); +// do_test_outbound_reload_without_init_mon(false); +// } + +// fn do_test_inbound_reload_without_init_mon(use_0conf: bool, lock_commitment: bool) { +// // Test that if the monitor update generated by funding_transaction_generated is stored async +// // and we restart with the latest ChannelManager but the ChannelMonitor persistence never +// // completed we happily drop the channel and move on. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + +// let persister; +// let new_chain_monitor; + +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; +// chan_config.channel_handshake_limits.trust_own_funding_0conf = true; + +// let node_chanmgrs = +// create_node_chanmgrs(2, &node_cfgs, &[Some(chan_config.clone()), Some(chan_config)]); +// let node_b_reload; + +// let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// nodes[0].node.create_channel(node_b_id, 100000, 10001, 43, None, None).unwrap(); +// nodes[1].node.handle_open_channel( +// node_a_id, +// &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, node_b_id), +// ); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id: chan_id, .. } => { +// if use_0conf { +// nodes[1] +// .node +// .accept_inbound_channel_from_trusted_peer_0conf(&chan_id, &node_a_id, 0, None) +// .unwrap(); +// } else { +// nodes[1].node.accept_inbound_channel(&chan_id, &node_a_id, 0, None).unwrap(); +// } +// }, +// _ => panic!("Unexpected event"), +// }; + +// nodes[0].node.handle_accept_channel( +// node_b_id, +// &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, node_a_id), +// ); + +// let (temporary_channel_id, funding_tx, ..) = +// create_funding_transaction(&nodes[0], &node_b_id, 100000, 43); + +// nodes[0] +// .node +// .funding_transaction_generated(temporary_channel_id, node_b_id, funding_tx.clone()) +// .unwrap(); +// check_added_monitors!(nodes[0], 0); + +// let funding_created_msg = +// get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, node_b_id); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_funding_created(node_a_id, &funding_created_msg); +// check_added_monitors!(nodes[1], 1); + +// // nodes[1] happily sends its funding_signed even though its awaiting the persistence of the +// // initial ChannelMonitor, but it will decline to send its channel_ready even if the funding +// // transaction is confirmed. +// let funding_signed_msg = +// get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); + +// nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); +// check_added_monitors!(nodes[0], 1); +// expect_channel_pending_event(&nodes[0], &node_b_id); + +// let as_funding_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// if lock_commitment { +// confirm_transaction(&nodes[0], &as_funding_tx[0]); +// confirm_transaction(&nodes[1], &as_funding_tx[0]); +// } +// if use_0conf || lock_commitment { +// let as_ready = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReady, node_b_id); +// nodes[1].node.handle_channel_ready(node_a_id, &as_ready); +// } +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // nodes[1] is now waiting on the first ChannelMonitor persistence to complete in order to +// // move the channel to ready (or is waiting on the funding transaction to confirm). If nodes[1] +// // restarts at this point with the ChannelMonitor lost, we should simply discard the channel. + +// // The test framework checks that watched_txn/outputs match the monitor set, which they will +// // not, so we have to clear them here. +// nodes[1].chain_source.watched_txn.lock().unwrap().clear(); +// nodes[1].chain_source.watched_outputs.lock().unwrap().clear(); + +// let node_b_ser = nodes[1].node.encode(); +// reload_node!(nodes[1], &node_b_ser, &[], persister, new_chain_monitor, node_b_reload); + +// check_closed_event!(nodes[1], 1, ClosureReason::DisconnectedPeer, [node_a_id], 100000); +// assert!(nodes[1].node.list_channels().is_empty()); +// } + +// #[test] +// fn test_inbound_reload_without_init_mon() { +// do_test_inbound_reload_without_init_mon(true, true); +// do_test_inbound_reload_without_init_mon(true, false); +// do_test_inbound_reload_without_init_mon(false, true); +// do_test_inbound_reload_without_init_mon(false, false); +// } + +// #[test] +// fn test_blocked_chan_preimage_release() { +// // Test that even if a channel's `ChannelMonitorUpdate` flow is blocked waiting on an event to +// // be handled HTLC preimage `ChannelMonitorUpdate`s will still go out. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5_000_000); + +// // Tee up two payments in opposite directions across nodes[1], one it sent to generate a +// // PaymentSent event and one it forwards. +// let (payment_preimage_1, payment_hash_1, ..) = +// route_payment(&nodes[1], &[&nodes[2]], 1_000_000); +// let (payment_preimage_2, payment_hash_2, ..) = +// route_payment(&nodes[2], &[&nodes[1], &nodes[0]], 1_000_000); + +// // Claim the first payment to get a `PaymentSent` event (but don't handle it yet). +// nodes[2].node.claim_funds(payment_preimage_1); +// check_added_monitors(&nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash_1, 1_000_000); + +// let cs_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// nodes[1] +// .node +// .handle_update_fulfill_htlc(node_c_id, &cs_htlc_fulfill_updates.update_fulfill_htlcs[0]); +// let commitment = cs_htlc_fulfill_updates.commitment_signed; +// do_commitment_signed_dance(&nodes[1], &nodes[2], &commitment, false, false); +// check_added_monitors(&nodes[1], 0); + +// // Now claim the second payment on nodes[0], which will ultimately result in nodes[1] trying to +// // claim an HTLC on its channel with nodes[2], but that channel is blocked on the above +// // `PaymentSent` event. +// nodes[0].node.claim_funds(payment_preimage_2); +// check_added_monitors(&nodes[0], 1); +// expect_payment_claimed!(nodes[0], payment_hash_2, 1_000_000); + +// let as_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[0], node_b_id); +// nodes[1] +// .node +// .handle_update_fulfill_htlc(node_a_id, &as_htlc_fulfill_updates.update_fulfill_htlcs[0]); +// check_added_monitors(&nodes[1], 1); // We generate only a preimage monitor update +// assert!(get_monitor!(nodes[1], chan_id_2).get_stored_preimages().contains_key(&payment_hash_2)); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Finish the CS dance between nodes[0] and nodes[1]. Note that until the event handling, the +// // update_fulfill_htlc + CS is held, even though the preimage is already on disk for the +// // channel. +// nodes[1] +// .node +// .handle_commitment_signed_batch_test(node_a_id, &as_htlc_fulfill_updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// let (a, raa) = do_main_commitment_signed_dance(&nodes[1], &nodes[0], false); +// assert!(a.is_none()); + +// nodes[1].node.handle_revoke_and_ack(node_a_id, &raa); +// check_added_monitors(&nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 3); +// if let Event::PaymentSent { .. } = events[0] { +// } else { +// panic!(); +// } +// if let Event::PaymentPathSuccessful { .. } = events[2] { +// } else { +// panic!(); +// } +// if let Event::PaymentForwarded { .. } = events[1] { +// } else { +// panic!(); +// } + +// // The event processing should release the last RAA updates on both channels. +// check_added_monitors(&nodes[1], 2); + +// // When we fetch the next update the message getter will generate the next update for nodes[2], +// // generating a further monitor update. +// let bs_htlc_fulfill_updates = get_htlc_update_msgs!(nodes[1], node_c_id); +// check_added_monitors(&nodes[1], 1); + +// nodes[2] +// .node +// .handle_update_fulfill_htlc(node_b_id, &bs_htlc_fulfill_updates.update_fulfill_htlcs[0]); +// let commitment = bs_htlc_fulfill_updates.commitment_signed; +// do_commitment_signed_dance(&nodes[2], &nodes[1], &commitment, false, false); +// expect_payment_sent(&nodes[2], payment_preimage_2, None, true, true); +// } + +// fn do_test_inverted_mon_completion_order( +// with_latest_manager: bool, complete_bc_commitment_dance: bool, +// ) { +// // When we forward a payment and receive `update_fulfill_htlc`+`commitment_signed` messages +// // from the downstream channel, we immediately claim the HTLC on the upstream channel, before +// // even doing a `commitment_signed` dance on the downstream channel. This implies that our +// // `ChannelMonitorUpdate`s are generated in the right order - first we ensure we'll get our +// // money, then we write the update that resolves the downstream node claiming their money. This +// // is safe as long as `ChannelMonitorUpdate`s complete in the order in which they are +// // generated, but of course this may not be the case. For asynchronous update writes, we have +// // to ensure monitor updates can block each other, preventing the inversion all together. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + +// let persister; +// let chain_mon; +// let node_b_reload; + +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// // Route a payment from A, through B, to C, then claim it on C. Once we pass B the +// // `update_fulfill_htlc` we have a monitor update for both of B's channels. We complete the one +// // on the B<->C channel but leave the A<->B monitor update pending, then reload B. +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + +// let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); +// let mut manager_b = Vec::new(); +// if !with_latest_manager { +// manager_b = nodes[1].node.encode(); +// } + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors(&nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 100_000); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); + +// // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages +// // for it since the monitor update is marked in-progress. +// check_added_monitors(&nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now step the Commitment Signed Dance between B and C forward a bit (or fully), ensuring we +// // won't get the preimage when the nodes reconnect and we have to get it from the +// // ChannelMonitor. +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// if complete_bc_commitment_dance { +// let (bs_revoke_and_ack, bs_commitment_signed) = +// get_revoke_commit_msgs!(nodes[1], node_c_id); +// nodes[2].node.handle_revoke_and_ack(node_b_id, &bs_revoke_and_ack); +// check_added_monitors(&nodes[2], 1); +// nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &bs_commitment_signed); +// check_added_monitors(&nodes[2], 1); +// let cs_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); + +// // At this point node B still hasn't persisted the `ChannelMonitorUpdate` with the +// // preimage in the A <-> B channel, which will prevent it from persisting the +// // `ChannelMonitorUpdate` for the B<->C channel here to avoid "losing" the preimage. +// nodes[1].node.handle_revoke_and_ack(node_c_id, &cs_raa); +// check_added_monitors(&nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// } + +// // Now reload node B +// if with_latest_manager { +// manager_b = nodes[1].node.encode(); +// } + +// let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); +// reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); + +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[2].node.peer_disconnected(node_b_id); + +// if with_latest_manager { +// // If we used the latest ChannelManager to reload from, we should have both channels still +// // live. The B <-> C channel's final RAA ChannelMonitorUpdate must still be blocked as +// // before - the ChannelMonitorUpdate for the A <-> B channel hasn't completed. +// // When we call `timer_tick_occurred` we will get that monitor update back, which we'll +// // complete after reconnecting to our peers. +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.timer_tick_occurred(); +// check_added_monitors(&nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now reconnect B to both A and C. If the B <-> C commitment signed dance wasn't run to +// // the end go ahead and do that, though the +// // `pending_responding_commitment_signed_dup_monitor` in `reconnect_args` indicates that we +// // expect to *not* receive the final RAA ChannelMonitorUpdate. +// if complete_bc_commitment_dance { +// reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2])); +// } else { +// let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); +// reconnect_args.pending_responding_commitment_signed.1 = true; +// reconnect_args.pending_responding_commitment_signed_dup_monitor.1 = true; +// reconnect_args.pending_raa = (false, true); +// reconnect_nodes(reconnect_args); +// } + +// reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); + +// // (Finally) complete the A <-> B ChannelMonitorUpdate, ensuring the preimage is durably on +// // disk in the proper ChannelMonitor, unblocking the B <-> C ChannelMonitor updating +// // process. +// let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); +// nodes[1] +// .chain_monitor +// .chain_monitor +// .channel_monitor_updated(chan_id_ab, ab_update_id) +// .unwrap(); + +// // When we fetch B's HTLC update messages next (now that the ChannelMonitorUpdate has +// // completed), it will also release the final RAA ChannelMonitorUpdate on the B <-> C +// // channel. +// } else { +// // If the ChannelManager used in the reload was stale, check that the B <-> C channel was +// // closed. +// // +// // Note that this will also process the ChannelMonitorUpdates which were queued up when we +// // reloaded the ChannelManager. This will re-emit the A<->B preimage as well as the B<->C +// // force-closure ChannelMonitorUpdate. Once the A<->B preimage update completes, the claim +// // commitment update will be allowed to go out. +// check_added_monitors(&nodes[1], 0); +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let reason = ClosureReason::OutdatedChannelManager; +// check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100_000); +// check_added_monitors(&nodes[1], 2); + +// nodes[1].node.timer_tick_occurred(); +// check_added_monitors(&nodes[1], 0); + +// // Don't bother to reconnect B to C - that channel has been closed. We don't need to +// // exchange any messages here even though there's a pending commitment update because the +// // ChannelMonitorUpdate hasn't yet completed. +// reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1])); + +// let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); +// nodes[1] +// .chain_monitor +// .chain_monitor +// .channel_monitor_updated(chan_id_ab, ab_update_id) +// .unwrap(); + +// // The ChannelMonitorUpdate which was completed prior to the reconnect only contained the +// // preimage (as it was a replay of the original ChannelMonitorUpdate from before we +// // restarted). When we go to fetch the commitment transaction updates we'll poll the +// // ChannelMonitorUpdate completion, then generate (and complete) a new ChannelMonitorUpdate +// // with the actual commitment transaction, which will allow us to fulfill the HTLC with +// // node A. +// } + +// let bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id); +// check_added_monitors(&nodes[1], 1); + +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); +// do_commitment_signed_dance(&nodes[0], &nodes[1], &bs_updates.commitment_signed, false, false); + +// expect_payment_forwarded!( +// nodes[1], +// &nodes[0], +// &nodes[2], +// Some(1_000), +// false, +// !with_latest_manager +// ); + +// // Finally, check that the payment was, ultimately, seen as sent by node A. +// expect_payment_sent(&nodes[0], payment_preimage, None, true, true); +// } + +// #[test] +// fn test_inverted_mon_completion_order() { +// do_test_inverted_mon_completion_order(true, true); +// do_test_inverted_mon_completion_order(true, false); +// do_test_inverted_mon_completion_order(false, true); +// do_test_inverted_mon_completion_order(false, false); +// } + +// fn do_test_durable_preimages_on_closed_channel( +// close_chans_before_reload: bool, close_only_a: bool, hold_post_reload_mon_update: bool, +// ) { +// // Test that we can apply a `ChannelMonitorUpdate` with a payment preimage even if the channel +// // is force-closed between when we generate the update on reload and when we go to handle the +// // update or prior to generating the update at all. + +// if !close_chans_before_reload && close_only_a { +// // If we're not closing, it makes no sense to "only close A" +// panic!(); +// } + +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + +// let persister; +// let chain_mon; +// let node_b_reload; + +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// // Route a payment from A, through B, to C, then claim it on C. Once we pass B the +// // `update_fulfill_htlc` we have a monitor update for both of B's channels. We complete the one +// // on the B<->C channel but leave the A<->B monitor update pending, then reload B. +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); + +// let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors(&nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); + +// // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages +// // for it since the monitor update is marked in-progress. +// check_added_monitors(&nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now step the Commitment Signed Dance between B and C forward a bit, ensuring we won't get +// // the preimage when the nodes reconnect, at which point we have to ensure we get it from the +// // ChannelMonitor. +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// let _ = get_revoke_commit_msgs!(nodes[1], node_c_id); + +// let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); +// let err_msg = "Channel force-closed".to_owned(); + +// if close_chans_before_reload { +// if !close_only_a { +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1] +// .node +// .force_close_broadcasting_latest_txn(&chan_id_bc, &node_c_id, err_msg.clone()) +// .unwrap(); +// check_closed_broadcast(&nodes[1], 1, true); +// let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event(&nodes[1], 1, reason, false, &[node_c_id], 100000); +// } + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1] +// .node +// .force_close_broadcasting_latest_txn(&chan_id_ab, &node_a_id, err_msg) +// .unwrap(); +// check_closed_broadcast(&nodes[1], 1, true); +// let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000); +// } + +// // Now reload node B +// let manager_b = nodes[1].node.encode(); +// reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); + +// nodes[0].node.peer_disconnected(node_b_id); +// nodes[2].node.peer_disconnected(node_b_id); + +// if close_chans_before_reload { +// // If the channels were already closed, B will rebroadcast its closing transactions here. +// let bs_close_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// if close_only_a { +// assert_eq!(bs_close_txn.len(), 2); +// } else { +// assert_eq!(bs_close_txn.len(), 3); +// } +// } + +// let err_msg = "Channel force-closed".to_owned(); +// nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, err_msg).unwrap(); +// let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100000); +// let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// assert_eq!(as_closing_tx.len(), 1); + +// // In order to give A's closing transaction to B without processing background events first, +// // use the _without_consistency_checks utility method. This is similar to connecting blocks +// // during startup prior to the node being full initialized. +// mine_transaction_without_consistency_checks(&nodes[1], &as_closing_tx[0]); + +// // After a timer tick a payment preimage ChannelMonitorUpdate is applied to the A<->B +// // ChannelMonitor (possible twice), even though the channel has since been closed. +// check_added_monitors(&nodes[1], 0); +// let mons_added = if close_chans_before_reload { +// if !close_only_a { +// 4 +// } else { +// 3 +// } +// } else { +// 2 +// }; +// if hold_post_reload_mon_update { +// for _ in 0..mons_added { +// persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } +// } +// nodes[1].node.timer_tick_occurred(); +// check_added_monitors(&nodes[1], mons_added); + +// // Finally, check that B created a payment preimage transaction and close out the payment. +// let bs_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// assert_eq!(bs_txn.len(), if close_chans_before_reload && !close_only_a { 2 } else { 1 }); +// let bs_preimage_tx = bs_txn +// .iter() +// .find(|tx| tx.input[0].previous_output.txid == as_closing_tx[0].compute_txid()) +// .unwrap(); +// check_spends!(bs_preimage_tx, as_closing_tx[0]); + +// if !close_chans_before_reload { +// check_closed_broadcast(&nodes[1], 1, true); +// let reason = ClosureReason::CommitmentTxConfirmed; +// check_closed_event(&nodes[1], 1, reason, false, &[node_a_id], 100000); +// } + +// mine_transactions(&nodes[0], &[&as_closing_tx[0], bs_preimage_tx]); +// check_closed_broadcast(&nodes[0], 1, true); +// expect_payment_sent(&nodes[0], payment_preimage, None, true, true); + +// if !close_chans_before_reload || close_only_a { +// // Make sure the B<->C channel is still alive and well by sending a payment over it. +// let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]); +// reconnect_args.pending_responding_commitment_signed.1 = true; +// // The B<->C `ChannelMonitorUpdate` shouldn't be allowed to complete, which is the +// // equivalent to the responding `commitment_signed` being a duplicate for node B, thus we +// // need to set the `pending_responding_commitment_signed_dup` flag. +// reconnect_args.pending_responding_commitment_signed_dup_monitor.1 = true; +// reconnect_args.pending_raa.1 = true; + +// reconnect_nodes(reconnect_args); +// } + +// // Once the blocked `ChannelMonitorUpdate` *finally* completes, the pending +// // `PaymentForwarded` event will finally be released. +// let (_, ab_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_ab); +// nodes[1].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id_ab, ab_update_id); + +// // If the A<->B channel was closed before we reload, we'll replay the claim against it on +// // reload, causing the `PaymentForwarded` event to get replayed. +// let evs = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(evs.len(), if close_chans_before_reload { 2 } else { 1 }); +// for ev in evs { +// if let Event::PaymentForwarded { .. } = ev { +// } else { +// panic!(); +// } +// } + +// if !close_chans_before_reload || close_only_a { +// // Once we call `process_pending_events` the final `ChannelMonitor` for the B<->C channel +// // will fly, removing the payment preimage from it. +// check_added_monitors(&nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// send_payment(&nodes[1], &[&nodes[2]], 100_000); +// } +// } + +// #[test] +// fn test_durable_preimages_on_closed_channel() { +// do_test_durable_preimages_on_closed_channel(true, true, true); +// do_test_durable_preimages_on_closed_channel(true, true, false); +// do_test_durable_preimages_on_closed_channel(true, false, true); +// do_test_durable_preimages_on_closed_channel(true, false, false); +// do_test_durable_preimages_on_closed_channel(false, false, true); +// do_test_durable_preimages_on_closed_channel(false, false, false); +// } + +// fn do_test_reload_mon_update_completion_actions(close_during_reload: bool) { +// // Test that if a `ChannelMonitorUpdate` completes but a `ChannelManager` isn't serialized +// // before restart we run the monitor update completion action on startup. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + +// let persister; +// let chain_mon; +// let node_b_reload; + +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// // Route a payment from A, through B, to C, then claim it on C. Once we pass B the +// // `update_fulfill_htlc`+`commitment_signed` we have a monitor update for both of B's channels. +// // We complete the commitment signed dance on the B<->C channel but leave the A<->B monitor +// // update pending, then reload B. At that point, the final monitor update on the B<->C channel +// // is still pending because it can't fly until the preimage is persisted on the A<->B monitor. +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors(&nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); + +// // B generates a new monitor update for the A <-> B channel, but doesn't send the new messages +// // for it since the monitor update is marked in-progress. +// check_added_monitors(&nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now step the Commitment Signed Dance between B and C and check that after the final RAA B +// // doesn't let the preimage-removing monitor update fly. +// nodes[1].node.handle_commitment_signed_batch_test(node_c_id, &cs_updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// let (bs_raa, bs_cs) = get_revoke_commit_msgs!(nodes[1], node_c_id); + +// nodes[2].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// check_added_monitors(&nodes[2], 1); +// nodes[2].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); +// check_added_monitors(&nodes[2], 1); + +// let cs_final_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, node_b_id); +// nodes[1].node.handle_revoke_and_ack(node_c_id, &cs_final_raa); +// check_added_monitors(&nodes[1], 0); + +// // Finally, reload node B and check that after we call `process_pending_events` once we realize +// // we've completed the A<->B preimage-including monitor update and so can release the B<->C +// // preimage-removing monitor update. +// let mon_ab = get_monitor!(nodes[1], chan_id_ab).encode(); +// let mon_bc = get_monitor!(nodes[1], chan_id_bc).encode(); +// let manager_b = nodes[1].node.encode(); +// reload_node!(nodes[1], &manager_b, &[&mon_ab, &mon_bc], persister, chain_mon, node_b_reload); + +// let msg = "Channel force-closed".to_owned(); +// if close_during_reload { +// // Test that we still free the B<->C channel if the A<->B channel closed while we reloaded +// // (as learned about during the on-reload block connection). +// nodes[0].node.force_close_broadcasting_latest_txn(&chan_id_ab, &node_b_id, msg).unwrap(); +// check_added_monitors!(nodes[0], 1); +// check_closed_broadcast!(nodes[0], true); +// let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event(&nodes[0], 1, reason, false, &[node_b_id], 100_000); +// let as_closing_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// mine_transaction_without_consistency_checks(&nodes[1], &as_closing_tx[0]); +// } + +// let (_, bc_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_bc); +// let mut events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), if close_during_reload { 2 } else { 1 }); +// expect_payment_forwarded( +// events.pop().unwrap(), +// &nodes[1], +// &nodes[0], +// &nodes[2], +// Some(1000), +// None, +// close_during_reload, +// false, +// false, +// ); +// if close_during_reload { +// match events[0] { +// Event::ChannelClosed { .. } => {}, +// _ => panic!(), +// } +// check_closed_broadcast!(nodes[1], true); +// } + +// // Once we run event processing the monitor should free, check that it was indeed the B<->C +// // channel which was updated. +// check_added_monitors(&nodes[1], if close_during_reload { 2 } else { 1 }); +// let (_, post_ev_bc_update_id) = get_latest_mon_update_id(&nodes[1], chan_id_bc); +// assert!(bc_update_id != post_ev_bc_update_id); + +// // Finally, check that there's nothing left to do on B<->C reconnect and the channel operates +// // fine. +// nodes[2].node.peer_disconnected(node_b_id); +// reconnect_nodes(ReconnectArgs::new(&nodes[1], &nodes[2])); +// send_payment(&nodes[1], &[&nodes[2]], 100_000); +// } + +// #[test] +// fn test_reload_mon_update_completion_actions() { +// do_test_reload_mon_update_completion_actions(true); +// do_test_reload_mon_update_completion_actions(false); +// } + +// fn do_test_glacial_peer_cant_hang(hold_chan_a: bool) { +// // Test that if a peer manages to send an `update_fulfill_htlc` message without a +// // `commitment_signed`, disconnects, then replays the `update_fulfill_htlc` message it doesn't +// // result in a channel hang. This was previously broken as the `DuplicateClaim` case wasn't +// // handled when claiming an HTLC and handling wasn't added when completion actions were added +// // (which must always complete at some point). +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); + +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// let chan_id_ab = create_announced_chan_between_nodes(&nodes, 0, 1).2; +// let _chan_id_bc = create_announced_chan_between_nodes(&nodes, 1, 2).2; + +// // Route a payment from A, through B, to C, then claim it on C. Replay the +// // `update_fulfill_htlc` twice on B to check that B doesn't hang. +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors(&nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); + +// let cs_updates = get_htlc_update_msgs(&nodes[2], &node_b_id); +// if hold_chan_a { +// // The first update will be on the A <-> B channel, which we optionally allow to complete. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// } +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &cs_updates.update_fulfill_htlcs[0]); +// check_added_monitors(&nodes[1], 1); + +// if !hold_chan_a { +// let bs_updates = get_htlc_update_msgs(&nodes[1], &node_a_id); +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &bs_updates.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false); +// expect_payment_sent!(&nodes[0], payment_preimage); +// } + +// nodes[1].node.peer_disconnected(node_c_id); +// nodes[2].node.peer_disconnected(node_b_id); + +// let mut reconnect = ReconnectArgs::new(&nodes[1], &nodes[2]); +// reconnect.pending_htlc_claims = (1, 0); +// reconnect_nodes(reconnect); + +// if !hold_chan_a { +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); +// } else { +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// let (route, payment_hash_2, payment_preimage_2, payment_secret_2) = +// get_route_and_payment_hash!(&nodes[1], nodes[2], 1_000_000); + +// // With the A<->B preimage persistence not yet complete, the B<->C channel is stuck +// // waiting. +// let onion_2 = RecipientOnionFields::secret_only(payment_secret_2); +// let id_2 = PaymentId(payment_hash_2.0); +// nodes[1].node.send_payment_with_route(route, payment_hash_2, onion_2, id_2).unwrap(); +// check_added_monitors(&nodes[1], 0); + +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // ...but once we complete the A<->B channel preimage persistence, the B<->C channel +// // unlocks and we send both peers commitment updates. +// let (ab_update_id, _) = get_latest_mon_update_id(&nodes[1], chan_id_ab); +// assert!(nodes[1] +// .chain_monitor +// .chain_monitor +// .channel_monitor_updated(chan_id_ab, ab_update_id) +// .is_ok()); + +// let mut msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(msg_events.len(), 2); +// check_added_monitors(&nodes[1], 2); + +// let mut c_update = msg_events +// .iter() +// .filter( +// |ev| matches!(ev, MessageSendEvent::UpdateHTLCs { node_id, .. } if *node_id == node_c_id), +// ) +// .cloned() +// .collect::>(); +// let a_filtermap = |ev| { +// if let MessageSendEvent::UpdateHTLCs { node_id, channel_id: _, updates } = ev { +// if node_id == node_a_id { +// Some(updates) +// } else { +// None +// } +// } else { +// None +// } +// }; +// let a_update = msg_events.drain(..).filter_map(|ev| a_filtermap(ev)).collect::>(); + +// assert_eq!(a_update.len(), 1); +// assert_eq!(c_update.len(), 1); + +// nodes[0].node.handle_update_fulfill_htlc(node_b_id, &a_update[0].update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], a_update[0].commitment_signed, false); +// expect_payment_sent(&nodes[0], payment_preimage, None, true, true); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); + +// pass_along_path( +// &nodes[1], +// &[&nodes[2]], +// 1_000_000, +// payment_hash_2, +// Some(payment_secret_2), +// c_update.pop().unwrap(), +// true, +// None, +// ); +// claim_payment(&nodes[1], &[&nodes[2]], payment_preimage_2); +// } +// } + +// #[test] +// fn test_glacial_peer_cant_hang() { +// do_test_glacial_peer_cant_hang(false); +// do_test_glacial_peer_cant_hang(true); +// } + +// #[test] +// fn test_partial_claim_mon_update_compl_actions() { +// // Test that if we have an MPP claim that we ensure the preimage for the claim is retained in +// // all the `ChannelMonitor`s until the preimage reaches every `ChannelMonitor` for a channel +// // which was a part of the MPP. +// 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 mut nodes = create_network(4, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); +// let node_d_id = nodes[3].node.get_our_node_id(); + +// let chan_1_scid = create_announced_chan_between_nodes(&nodes, 0, 1).0.contents.short_channel_id; +// let chan_2_scid = create_announced_chan_between_nodes(&nodes, 0, 2).0.contents.short_channel_id; +// let (chan_3_update, _, chan_3_id, ..) = create_announced_chan_between_nodes(&nodes, 1, 3); +// let chan_3_scid = chan_3_update.contents.short_channel_id; +// let (chan_4_update, _, chan_4_id, ..) = create_announced_chan_between_nodes(&nodes, 2, 3); +// let chan_4_scid = chan_4_update.contents.short_channel_id; + +// let (mut route, payment_hash, preimage, payment_secret) = +// get_route_and_payment_hash!(&nodes[0], nodes[3], 100000); +// let path = route.paths[0].clone(); +// route.paths.push(path); +// route.paths[0].hops[0].pubkey = node_b_id; +// route.paths[0].hops[0].short_channel_id = chan_1_scid; +// route.paths[0].hops[1].short_channel_id = chan_3_scid; +// route.paths[1].hops[0].pubkey = node_c_id; +// route.paths[1].hops[0].short_channel_id = chan_2_scid; +// route.paths[1].hops[1].short_channel_id = chan_4_scid; +// let paths = &[&[&nodes[1], &nodes[3]][..], &[&nodes[2], &nodes[3]][..]]; +// send_along_route_with_secret(&nodes[0], route, paths, 200_000, payment_hash, payment_secret); + +// // Claim along both paths, but only complete one of the two monitor updates. +// chanmon_cfgs[3].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// chanmon_cfgs[3].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[3].node.claim_funds(preimage); +// assert_eq!(nodes[3].node.get_and_clear_pending_msg_events(), Vec::new()); +// assert_eq!(nodes[3].node.get_and_clear_pending_events(), Vec::new()); +// check_added_monitors(&nodes[3], 2); + +// // Complete the 1<->3 monitor update and play the commitment_signed dance forward until it +// // blocks. +// nodes[3].chain_monitor.complete_sole_pending_chan_update(&chan_3_id); +// expect_payment_claimed!(&nodes[3], payment_hash, 200_000); +// let updates = get_htlc_update_msgs(&nodes[3], &node_b_id); + +// nodes[1].node.handle_update_fulfill_htlc(node_d_id, &updates.update_fulfill_htlcs[0]); +// check_added_monitors(&nodes[1], 1); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[3], Some(1000), false, false); +// let _bs_updates_for_a = get_htlc_update_msgs(&nodes[1], &node_a_id); + +// nodes[1].node.handle_commitment_signed_batch_test(node_d_id, &updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &node_d_id); + +// nodes[3].node.handle_revoke_and_ack(node_b_id, &bs_raa); +// check_added_monitors(&nodes[3], 0); + +// nodes[3].node.handle_commitment_signed_batch_test(node_b_id, &bs_cs); +// check_added_monitors(&nodes[3], 0); +// assert!(nodes[3].node.get_and_clear_pending_msg_events().is_empty()); + +// // Now double-check that the preimage is still in the 1<->3 channel and complete the pending +// // monitor update, allowing node 3 to claim the payment on the 2<->3 channel. This also +// // unblocks the 1<->3 channel, allowing node 3 to release the two blocked monitor updates and +// // respond to the final commitment_signed. +// assert!(get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); + +// nodes[3].chain_monitor.complete_sole_pending_chan_update(&chan_4_id); +// let mut ds_msgs = nodes[3].node.get_and_clear_pending_msg_events(); +// assert_eq!(ds_msgs.len(), 2); +// check_added_monitors(&nodes[3], 2); + +// match remove_first_msg_event_to_node(&node_b_id, &mut ds_msgs) { +// MessageSendEvent::SendRevokeAndACK { msg, .. } => { +// nodes[1].node.handle_revoke_and_ack(node_d_id, &msg); +// check_added_monitors(&nodes[1], 1); +// }, +// _ => panic!(), +// } + +// match remove_first_msg_event_to_node(&node_c_id, &mut ds_msgs) { +// MessageSendEvent::UpdateHTLCs { updates, .. } => { +// nodes[2].node.handle_update_fulfill_htlc(node_d_id, &updates.update_fulfill_htlcs[0]); +// check_added_monitors(&nodes[2], 1); +// expect_payment_forwarded!(nodes[2], nodes[0], nodes[3], Some(1000), false, false); +// let _cs_updates_for_a = get_htlc_update_msgs(&nodes[2], &node_a_id); + +// nodes[2] +// .node +// .handle_commitment_signed_batch_test(node_d_id, &updates.commitment_signed); +// check_added_monitors(&nodes[2], 1); +// }, +// _ => panic!(), +// } + +// let (cs_raa, cs_cs) = get_revoke_commit_msgs(&nodes[2], &node_d_id); + +// nodes[3].node.handle_revoke_and_ack(node_c_id, &cs_raa); +// check_added_monitors(&nodes[3], 1); + +// nodes[3].node.handle_commitment_signed_batch_test(node_c_id, &cs_cs); +// check_added_monitors(&nodes[3], 1); + +// let ds_raa = get_event_msg!(nodes[3], MessageSendEvent::SendRevokeAndACK, node_c_id); +// nodes[2].node.handle_revoke_and_ack(node_d_id, &ds_raa); +// check_added_monitors(&nodes[2], 1); + +// // Our current `ChannelMonitor`s store preimages one RAA longer than they need to. That's nice +// // for safety, but means we have to send one more payment here to wipe the preimage. +// assert!(get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); +// assert!(get_monitor!(nodes[3], chan_4_id).get_stored_preimages().contains_key(&payment_hash)); + +// send_payment(&nodes[1], &[&nodes[3]], 100_000); +// assert!(!get_monitor!(nodes[3], chan_3_id).get_stored_preimages().contains_key(&payment_hash)); + +// send_payment(&nodes[2], &[&nodes[3]], 100_000); +// assert!(!get_monitor!(nodes[3], chan_4_id).get_stored_preimages().contains_key(&payment_hash)); +// } + +// #[test] +// fn test_claim_to_closed_channel_blocks_forwarded_preimage_removal() { +// // One of the last features for async persistence we implemented was the correct blocking of +// // RAA(s) which remove a preimage from an outbound channel for a forwarded payment until the +// // preimage write makes it durably to the closed inbound channel. +// // This tests that behavior. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// // First open channels, route a payment, and force-close the first hop. +// let chan_a = +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); +// let chan_b = +// create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000); + +// let (payment_preimage, payment_hash, ..) = +// route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000); + +// nodes[0] +// .node +// .force_close_broadcasting_latest_txn(&chan_a.2, &node_b_id, String::new()) +// .unwrap(); +// check_added_monitors!(nodes[0], 1); +// let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000); +// check_closed_broadcast!(nodes[0], true); + +// let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// assert_eq!(as_commit_tx.len(), 1); + +// mine_transaction(&nodes[1], &as_commit_tx[0]); +// check_added_monitors!(nodes[1], 1); +// check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000); +// check_closed_broadcast!(nodes[1], true); + +// // Now that B has a pending forwarded payment across it with the inbound edge on-chain, claim +// // the payment on C and give B the preimage for it. +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 1_000_000); + +// let updates = get_htlc_update_msgs!(nodes[2], node_b_id); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_update_fulfill_htlc(node_c_id, &updates.update_fulfill_htlcs[0]); +// check_added_monitors!(nodes[1], 1); +// commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); + +// // At this point nodes[1] has the preimage and is waiting for the `ChannelMonitorUpdate` for +// // channel A to hit disk. Until it does so, it shouldn't ever let the preimage dissapear from +// // channel B's `ChannelMonitor` +// assert!(get_monitor!(nodes[1], chan_b.2) +// .get_all_current_outbound_htlcs() +// .iter() +// .any(|(_, (_, preimage))| *preimage == Some(payment_preimage))); + +// // Once we complete the `ChannelMonitorUpdate` on channel A, and the `ChannelManager` processes +// // background events (via `get_and_clear_pending_msg_events`), the final `ChannelMonitorUpdate` +// // will fly and we'll drop the preimage from channel B's `ChannelMonitor`. We'll also release +// // the `Event::PaymentForwarded`. +// check_added_monitors!(nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// nodes[1].chain_monitor.complete_sole_pending_chan_update(&chan_a.2); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// check_added_monitors!(nodes[1], 1); +// assert!(!get_monitor!(nodes[1], chan_b.2) +// .get_all_current_outbound_htlcs() +// .iter() +// .any(|(_, (_, preimage))| *preimage == Some(payment_preimage))); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], None, true, false); +// } + +// #[test] +// fn test_claim_to_closed_channel_blocks_claimed_event() { +// // One of the last features for async persistence we implemented was the correct blocking of +// // event(s) until the preimage for a claimed HTLC is durably on disk in a ChannelMonitor for a +// // closed channel. +// // This tests that behavior. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); + +// // First open channels, route a payment, and force-close the first hop. +// let chan_a = +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000); + +// let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// nodes[0] +// .node +// .force_close_broadcasting_latest_txn(&chan_a.2, &node_b_id, String::new()) +// .unwrap(); +// check_added_monitors!(nodes[0], 1); +// let a_reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; +// check_closed_event!(nodes[0], 1, a_reason, [node_b_id], 1000000); +// check_closed_broadcast!(nodes[0], true); + +// let as_commit_tx = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// assert_eq!(as_commit_tx.len(), 1); + +// mine_transaction(&nodes[1], &as_commit_tx[0]); +// check_added_monitors!(nodes[1], 1); +// check_closed_event!(nodes[1], 1, ClosureReason::CommitmentTxConfirmed, [node_a_id], 1000000); +// check_closed_broadcast!(nodes[1], true); + +// // Now that B has a pending payment with the inbound HTLC on a closed channel, claim the +// // payment on disk, but don't let the `ChannelMonitorUpdate` complete. This should prevent the +// // `Event::PaymentClaimed` from being generated. +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// // Once we complete the `ChannelMonitorUpdate` the `Event::PaymentClaimed` will become +// // available. +// nodes[1].chain_monitor.complete_sole_pending_chan_update(&chan_a.2); +// expect_payment_claimed!(nodes[1], payment_hash, 1_000_000); +// } + +// #[test] +// #[cfg(all(feature = "std", not(target_os = "windows")))] +// fn test_single_channel_multiple_mpp() { +// use std::sync::atomic::{AtomicBool, Ordering}; + +// // Test what happens when we attempt to claim an MPP with many parts that came to us through +// // the same channel with a synchronous persistence interface which has very high latency. +// // +// // Previously, if a `revoke_and_ack` came in while we were still running in +// // `ChannelManager::claim_payment` we'd end up hanging waiting to apply a +// // `ChannelMonitorUpdate` until after it completed. See the commit which introduced this test +// // for more info. +// let chanmon_cfgs = create_chanmon_cfgs(9); +// let node_cfgs = create_node_cfgs(9, &chanmon_cfgs); +// let configs = [None, None, None, None, None, None, None, None, None]; +// let node_chanmgrs = create_node_chanmgrs(9, &node_cfgs, &configs); +// let mut nodes = create_network(9, &node_cfgs, &node_chanmgrs); + +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); +// let node_d_id = nodes[3].node.get_our_node_id(); +// let node_e_id = nodes[4].node.get_our_node_id(); +// let node_f_id = nodes[5].node.get_our_node_id(); +// let node_g_id = nodes[6].node.get_our_node_id(); +// let node_h_id = nodes[7].node.get_our_node_id(); +// let node_i_id = nodes[8].node.get_our_node_id(); + +// // Send an MPP payment in six parts along the path shown from top to bottom +// // 0 +// // 1 2 3 4 5 6 +// // 7 +// // 8 +// // +// // We can in theory reproduce this issue with fewer channels/HTLCs, but getting this test +// // robust is rather challenging. We rely on having the main test thread wait on locks held in +// // the background `claim_funds` thread and unlocking when the `claim_funds` thread completes a +// // single `ChannelMonitorUpdate`. +// // This thread calls `get_and_clear_pending_msg_events()` and `handle_revoke_and_ack()`, both +// // of which require `ChannelManager` locks, but we have to make sure this thread gets a chance +// // to be blocked on the mutexes before we let the background thread wake `claim_funds` so that +// // the mutex can switch to this main thread. +// // This relies on our locks being fair, but also on our threads getting runtime during the test +// // run, which can be pretty competitive. Thus we do a dumb dance to be as conservative as +// // possible - we have a background thread which completes a `ChannelMonitorUpdate` (by sending +// // into the `write_blocker` mpsc) but it doesn't run until a mpsc channel sends from this main +// // thread to the background thread, and then we let it sleep a while before we send the +// // `ChannelMonitorUpdate` unblocker. +// // Further, we give ourselves two chances each time, needing 4 HTLCs just to unlock our two +// // `ChannelManager` calls. We then need a few remaining HTLCs to actually trigger the bug, so +// // we use 6 HTLCs. +// // Finaly, we do not run this test on Winblowz because it, somehow, in 2025, does not implement +// // actual preemptive multitasking and thinks that cooperative multitasking somehow is +// // acceptable in the 21st century, let alone a quarter of the way into it. +// const MAX_THREAD_INIT_TIME: std::time::Duration = std::time::Duration::from_secs(1); + +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 0, 3, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 0, 4, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 0, 5, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 0, 6, 100_000, 0); + +// create_announced_chan_between_nodes_with_value(&nodes, 1, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 2, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 3, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 4, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 5, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 6, 7, 100_000, 0); +// create_announced_chan_between_nodes_with_value(&nodes, 7, 8, 1_000_000, 0); + +// let (mut route, payment_hash, payment_preimage, payment_secret) = +// get_route_and_payment_hash!(&nodes[0], nodes[8], 50_000_000); + +// send_along_route_with_secret( +// &nodes[0], +// route, +// &[ +// &[&nodes[1], &nodes[7], &nodes[8]], +// &[&nodes[2], &nodes[7], &nodes[8]], +// &[&nodes[3], &nodes[7], &nodes[8]], +// &[&nodes[4], &nodes[7], &nodes[8]], +// &[&nodes[5], &nodes[7], &nodes[8]], +// &[&nodes[6], &nodes[7], &nodes[8]], +// ], +// 50_000_000, +// payment_hash, +// payment_secret, +// ); + +// let (do_a_write, blocker) = std::sync::mpsc::sync_channel(0); +// *nodes[8].chain_monitor.write_blocker.lock().unwrap() = Some(blocker); + +// // Until we have std::thread::scoped we have to unsafe { turn off the borrow checker }. +// // We do this by casting a pointer to a `TestChannelManager` to a pointer to a +// // `TestChannelManager` with different (in this case 'static) lifetime. +// // This is even suggested in the second example at +// // https://doc.rust-lang.org/std/mem/fn.transmute.html#examples +// let claim_node: &'static TestChannelManager<'static, 'static> = +// unsafe { std::mem::transmute(nodes[8].node as &TestChannelManager) }; +// let thrd = std::thread::spawn(move || { +// // Initiate the claim in a background thread as it will immediately block waiting on the +// // `write_blocker` we set above. +// claim_node.claim_funds(payment_preimage); +// }); + +// // First unlock one monitor so that we have a pending +// // `update_fulfill_htlc`/`commitment_signed` pair to pass to our counterparty. +// do_a_write.send(()).unwrap(); + +// // Then fetch the `update_fulfill_htlc`/`commitment_signed`. Note that the +// // `get_and_clear_pending_msg_events` will immediately hang trying to take a peer lock which +// // `claim_funds` is holding. Thus, we release a second write after a small sleep in the +// // background to give `claim_funds` a chance to step forward, unblocking +// // `get_and_clear_pending_msg_events`. +// let do_a_write_background = do_a_write.clone(); +// let block_thrd2 = AtomicBool::new(true); +// let block_thrd2_read: &'static AtomicBool = unsafe { std::mem::transmute(&block_thrd2) }; +// let thrd2 = std::thread::spawn(move || { +// while block_thrd2_read.load(Ordering::Acquire) { +// std::thread::yield_now(); +// } +// std::thread::sleep(MAX_THREAD_INIT_TIME); +// do_a_write_background.send(()).unwrap(); +// std::thread::sleep(MAX_THREAD_INIT_TIME); +// do_a_write_background.send(()).unwrap(); +// }); +// block_thrd2.store(false, Ordering::Release); +// let first_updates = get_htlc_update_msgs(&nodes[8], &node_h_id); +// thrd2.join().unwrap(); + +// // Disconnect node 6 from all its peers so it doesn't bother to fail the HTLCs back +// nodes[7].node.peer_disconnected(node_b_id); +// nodes[7].node.peer_disconnected(node_c_id); +// nodes[7].node.peer_disconnected(node_d_id); +// nodes[7].node.peer_disconnected(node_e_id); +// nodes[7].node.peer_disconnected(node_f_id); +// nodes[7].node.peer_disconnected(node_g_id); + +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, &first_updates.update_fulfill_htlcs[0]); +// check_added_monitors(&nodes[7], 1); +// expect_payment_forwarded!(nodes[7], nodes[1], nodes[8], Some(1000), false, false); +// nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &first_updates.commitment_signed); +// check_added_monitors(&nodes[7], 1); +// let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); + +// // Now, handle the `revoke_and_ack` from node 5. Note that `claim_funds` is still blocked on +// // our peer lock, so we have to release a write to let it process. +// // After this call completes, the channel previously would be locked up and should not be able +// // to make further progress. +// let do_a_write_background = do_a_write.clone(); +// let block_thrd3 = AtomicBool::new(true); +// let block_thrd3_read: &'static AtomicBool = unsafe { std::mem::transmute(&block_thrd3) }; +// let thrd3 = std::thread::spawn(move || { +// while block_thrd3_read.load(Ordering::Acquire) { +// std::thread::yield_now(); +// } +// std::thread::sleep(MAX_THREAD_INIT_TIME); +// do_a_write_background.send(()).unwrap(); +// std::thread::sleep(MAX_THREAD_INIT_TIME); +// do_a_write_background.send(()).unwrap(); +// }); +// block_thrd3.store(false, Ordering::Release); +// nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); +// thrd3.join().unwrap(); +// assert!(!thrd.is_finished()); + +// let thrd4 = std::thread::spawn(move || { +// do_a_write.send(()).unwrap(); +// do_a_write.send(()).unwrap(); +// }); + +// thrd4.join().unwrap(); +// thrd.join().unwrap(); + +// expect_payment_claimed!(nodes[8], payment_hash, 50_000_000); + +// // At the end, we should have 7 ChannelMonitorUpdates - 6 for HTLC claims, and one for the +// // above `revoke_and_ack`. +// check_added_monitors(&nodes[8], 7); + +// // Now drive everything to the end, at least as far as node 7 is concerned... +// *nodes[8].chain_monitor.write_blocker.lock().unwrap() = None; +// nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); +// check_added_monitors(&nodes[8], 1); + +// let (updates, raa) = get_updates_and_revoke(&nodes[8], &node_h_id); + +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[7], nodes[2], nodes[8], Some(1000), false, false); +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[1]); +// expect_payment_forwarded!(nodes[7], nodes[3], nodes[8], Some(1000), false, false); +// let mut next_source = 4; +// if let Some(update) = updates.update_fulfill_htlcs.get(2) { +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, update); +// expect_payment_forwarded!(nodes[7], nodes[4], nodes[8], Some(1000), false, false); +// next_source += 1; +// } + +// nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &updates.commitment_signed); +// nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); +// if updates.update_fulfill_htlcs.get(2).is_some() { +// check_added_monitors(&nodes[7], 5); +// } else { +// check_added_monitors(&nodes[7], 4); +// } + +// let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); + +// nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); +// nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); +// check_added_monitors(&nodes[8], 2); + +// let (updates, raa) = get_updates_and_revoke(&nodes[8], &node_h_id); + +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); +// next_source += 1; +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, &updates.update_fulfill_htlcs[1]); +// expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); +// next_source += 1; +// if let Some(update) = updates.update_fulfill_htlcs.get(2) { +// nodes[7].node.handle_update_fulfill_htlc(node_i_id, update); +// expect_payment_forwarded!(nodes[7], nodes[next_source], nodes[8], Some(1000), false, false); +// } + +// nodes[7].node.handle_commitment_signed_batch_test(node_i_id, &updates.commitment_signed); +// nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); +// if updates.update_fulfill_htlcs.get(2).is_some() { +// check_added_monitors(&nodes[7], 5); +// } else { +// check_added_monitors(&nodes[7], 4); +// } + +// let (raa, cs) = get_revoke_commit_msgs(&nodes[7], &node_i_id); +// nodes[8].node.handle_revoke_and_ack(node_h_id, &raa); +// nodes[8].node.handle_commitment_signed_batch_test(node_h_id, &cs); +// check_added_monitors(&nodes[8], 2); + +// let raa = get_event_msg!(nodes[8], MessageSendEvent::SendRevokeAndACK, node_h_id); +// nodes[7].node.handle_revoke_and_ack(node_i_id, &raa); +// check_added_monitors(&nodes[7], 1); +// } diff --git a/lightning/src/ln/dual_funding_tests.rs b/lightning/src/ln/dual_funding_tests.rs index ed770d06e6d..e52650184c5 100644 --- a/lightning/src/ln/dual_funding_tests.rs +++ b/lightning/src/ln/dual_funding_tests.rs @@ -1,251 +1,251 @@ -// This file is Copyright its original authors, visible in version control -// history. -// -// This file is licensed under the Apache License, Version 2.0 or the MIT license -// , at your option. -// You may not use this file except in accordance with one or both of these -// licenses. - -//! Tests that test the creation of dual-funded channels in ChannelManager. - -use { - crate::chain::chaininterface::{ConfirmationTarget, LowerBoundedFeeEstimator}, - crate::events::Event, - crate::ln::chan_utils::{ - make_funding_redeemscript, ChannelPublicKeys, ChannelTransactionParameters, - CounterpartyChannelTransactionParameters, - }, - crate::ln::channel::PendingV2Channel, - crate::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint}, - crate::ln::functional_test_utils::*, - crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent}, - crate::ln::msgs::{CommitmentSigned, TxAddInput, TxAddOutput, TxComplete, TxSignatures}, - crate::ln::types::ChannelId, - crate::prelude::*, - crate::util::ser::TransactionU16LenLimited, - crate::util::test_utils, - bitcoin::Witness, -}; - -// Dual-funding: V2 Channel Establishment Tests -struct V2ChannelEstablishmentTestSession { - funding_input_sats: u64, - initiator_input_value_satoshis: u64, -} - -// TODO(dual_funding): Use real node and API for creating V2 channels as initiator when available, -// instead of manually constructing messages. -fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession) { - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut node_1_user_config = test_default_channel_config(); - node_1_user_config.enable_dual_funded_channels = true; - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(node_1_user_config)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let logger_a = test_utils::TestLogger::with_id("node a".to_owned()); - - // Create a funding input for the new channel along with its previous transaction. - let initiator_funding_inputs: Vec<_> = create_dual_funding_utxos_with_prev_txs( - &nodes[0], - &[session.initiator_input_value_satoshis], - ) - .into_iter() - .map(|(txin, tx, _)| (txin, TransactionU16LenLimited::new(tx).unwrap())) - .collect(); - - // Alice creates a dual-funded channel as initiator. - let funding_satoshis = session.funding_input_sats; - let mut channel = PendingV2Channel::new_outbound( - &LowerBoundedFeeEstimator(node_cfgs[0].fee_estimator), - &nodes[0].node.entropy_source, - &nodes[0].node.signer_provider, - nodes[1].node.get_our_node_id(), - &nodes[1].node.init_features(), - funding_satoshis, - initiator_funding_inputs.clone(), - 42, /* user_channel_id */ - nodes[0].node.get_current_default_configuration(), - nodes[0].best_block_info().1, - nodes[0].node.create_and_insert_outbound_scid_alias_for_test(), - ConfirmationTarget::NonAnchorChannelFee, - &logger_a, - ) - .unwrap(); - let open_channel_v2_msg = channel.get_open_channel_v2(nodes[0].chain_source.chain_hash); - - nodes[1].node.handle_open_channel_v2(nodes[0].node.get_our_node_id(), &open_channel_v2_msg); - - let accept_channel_v2_msg = get_event_msg!( - nodes[1], - MessageSendEvent::SendAcceptChannelV2, - nodes[0].node.get_our_node_id() - ); - let channel_id = ChannelId::v2_from_revocation_basepoints( - &RevocationBasepoint::from(accept_channel_v2_msg.common_fields.revocation_basepoint), - &RevocationBasepoint::from(open_channel_v2_msg.common_fields.revocation_basepoint), - ); - - let tx_add_input_msg = TxAddInput { - channel_id, - serial_id: 2, // Even serial_id from initiator. - prevtx: initiator_funding_inputs[0].1.clone(), - prevtx_out: 0, - sequence: initiator_funding_inputs[0].0.sequence.0, - shared_input_txid: None, - }; - let input_value = - tx_add_input_msg.prevtx.as_transaction().output[tx_add_input_msg.prevtx_out as usize].value; - assert_eq!(input_value.to_sat(), session.initiator_input_value_satoshis); - - nodes[1].node.handle_tx_add_input(nodes[0].node.get_our_node_id(), &tx_add_input_msg); - - let _tx_complete_msg = - get_event_msg!(nodes[1], MessageSendEvent::SendTxComplete, nodes[0].node.get_our_node_id()); - - let tx_add_output_msg = TxAddOutput { - channel_id, - serial_id: 4, - sats: funding_satoshis, - script: make_funding_redeemscript( - &open_channel_v2_msg.common_fields.funding_pubkey, - &accept_channel_v2_msg.common_fields.funding_pubkey, - ) - .to_p2wsh(), - }; - nodes[1].node.handle_tx_add_output(nodes[0].node.get_our_node_id(), &tx_add_output_msg); - - let _tx_complete_msg = - get_event_msg!(nodes[1], MessageSendEvent::SendTxComplete, nodes[0].node.get_our_node_id()); - - let tx_complete_msg = TxComplete { channel_id }; - - nodes[1].node.handle_tx_complete(nodes[0].node.get_our_node_id(), &tx_complete_msg); - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(msg_events.len(), 1); - let _msg_commitment_signed_from_1 = match msg_events[0] { - MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - updates.commitment_signed.clone() - }, - _ => panic!("Unexpected event"), - }; - - let (funding_outpoint, channel_type_features) = { - let per_peer_state = nodes[1].node.per_peer_state.read().unwrap(); - let peer_state = - per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap(); - let channel_funding = - peer_state.channel_by_id.get(&tx_complete_msg.channel_id).unwrap().funding(); - (channel_funding.get_funding_txo(), channel_funding.get_channel_type().clone()) - }; - - channel.funding.channel_transaction_parameters = ChannelTransactionParameters { - counterparty_parameters: Some(CounterpartyChannelTransactionParameters { - pubkeys: ChannelPublicKeys { - funding_pubkey: accept_channel_v2_msg.common_fields.funding_pubkey, - revocation_basepoint: RevocationBasepoint( - accept_channel_v2_msg.common_fields.revocation_basepoint, - ), - payment_point: accept_channel_v2_msg.common_fields.payment_basepoint, - delayed_payment_basepoint: DelayedPaymentBasepoint( - accept_channel_v2_msg.common_fields.delayed_payment_basepoint, - ), - htlc_basepoint: HtlcBasepoint(accept_channel_v2_msg.common_fields.htlc_basepoint), - }, - selected_contest_delay: accept_channel_v2_msg.common_fields.to_self_delay, - }), - holder_pubkeys: ChannelPublicKeys { - funding_pubkey: open_channel_v2_msg.common_fields.funding_pubkey, - revocation_basepoint: RevocationBasepoint( - open_channel_v2_msg.common_fields.revocation_basepoint, - ), - payment_point: open_channel_v2_msg.common_fields.payment_basepoint, - delayed_payment_basepoint: DelayedPaymentBasepoint( - open_channel_v2_msg.common_fields.delayed_payment_basepoint, - ), - htlc_basepoint: HtlcBasepoint(open_channel_v2_msg.common_fields.htlc_basepoint), - }, - holder_selected_contest_delay: open_channel_v2_msg.common_fields.to_self_delay, - is_outbound_from_holder: true, - funding_outpoint, - splice_parent_funding_txid: None, - channel_type_features, - channel_value_satoshis: funding_satoshis, - }; - - let msg_commitment_signed_from_0 = CommitmentSigned { - channel_id, - signature: channel - .context - .get_initial_counterparty_commitment_signature_for_test( - &mut channel.funding, - &&logger_a, - accept_channel_v2_msg.common_fields.first_per_commitment_point, - ) - .unwrap(), - htlc_signatures: vec![], - funding_txid: None, - #[cfg(taproot)] - partial_signature_with_nonce: None, - }; - - chanmon_cfgs[1].persister.set_update_ret(crate::chain::ChannelMonitorUpdateStatus::InProgress); - - // Handle the initial commitment_signed exchange. Order is not important here. - nodes[1] - .node - .handle_commitment_signed(nodes[0].node.get_our_node_id(), &msg_commitment_signed_from_0); - check_added_monitors(&nodes[1], 1); - - // The funding transaction should not have been broadcast before persisting initial monitor has - // been completed. - assert_eq!(nodes[1].tx_broadcaster.txn_broadcast().len(), 0); - assert_eq!(nodes[1].node.get_and_clear_pending_events().len(), 0); - - // Complete the persistence of the monitor. - let events = nodes[1].node.get_and_clear_pending_events(); - assert!(events.is_empty()); - nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id); - - let tx_signatures_msg = get_event_msg!( - nodes[1], - MessageSendEvent::SendTxSignatures, - nodes[0].node.get_our_node_id() - ); - - assert_eq!(tx_signatures_msg.channel_id, channel_id); - - let mut witness = Witness::new(); - witness.push([0x0]); - // Receive tx_signatures from channel initiator. - nodes[1].node.handle_tx_signatures( - nodes[0].node.get_our_node_id(), - &TxSignatures { - channel_id, - tx_hash: funding_outpoint.unwrap().txid, - witnesses: vec![witness], - shared_input_signature: None, - }, - ); - - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::ChannelPending { channel_id: chan_id, .. } => assert_eq!(chan_id, channel_id), - _ => panic!("Unexpected event"), - }; - - // For an inbound channel V2 channel the transaction should be broadcast once receiving a - // tx_signature and applying local tx_signatures: - let broadcasted_txs = nodes[1].tx_broadcaster.txn_broadcast(); - assert_eq!(broadcasted_txs.len(), 1); -} - -#[test] -fn test_v2_channel_establishment() { - do_test_v2_channel_establishment(V2ChannelEstablishmentTestSession { - funding_input_sats: 100_00, - initiator_input_value_satoshis: 150_000, - }); -} +// // This file is Copyright its original authors, visible in version control +// // history. +// // +// // This file is licensed under the Apache License, Version 2.0 or the MIT license +// // , at your option. +// // You may not use this file except in accordance with one or both of these +// // licenses. + +// //! Tests that test the creation of dual-funded channels in ChannelManager. + +// use { +// crate::chain::chaininterface::{ConfirmationTarget, LowerBoundedFeeEstimator}, +// crate::events::Event, +// crate::ln::chan_utils::{ +// make_funding_redeemscript, ChannelPublicKeys, ChannelTransactionParameters, +// CounterpartyChannelTransactionParameters, +// }, +// crate::ln::channel::PendingV2Channel, +// crate::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint}, +// crate::ln::functional_test_utils::*, +// crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, MessageSendEvent}, +// crate::ln::msgs::{CommitmentSigned, TxAddInput, TxAddOutput, TxComplete, TxSignatures}, +// crate::ln::types::ChannelId, +// crate::prelude::*, +// crate::util::ser::TransactionU16LenLimited, +// crate::util::test_utils, +// bitcoin::Witness, +// }; + +// // Dual-funding: V2 Channel Establishment Tests +// struct V2ChannelEstablishmentTestSession { +// funding_input_sats: u64, +// initiator_input_value_satoshis: u64, +// } + +// // TODO(dual_funding): Use real node and API for creating V2 channels as initiator when available, +// // instead of manually constructing messages. +// fn do_test_v2_channel_establishment(session: V2ChannelEstablishmentTestSession) { +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut node_1_user_config = test_default_channel_config(); +// node_1_user_config.enable_dual_funded_channels = true; +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(node_1_user_config)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let logger_a = test_utils::TestLogger::with_id("node a".to_owned()); + +// // Create a funding input for the new channel along with its previous transaction. +// let initiator_funding_inputs: Vec<_> = create_dual_funding_utxos_with_prev_txs( +// &nodes[0], +// &[session.initiator_input_value_satoshis], +// ) +// .into_iter() +// .map(|(txin, tx, _)| (txin, TransactionU16LenLimited::new(tx).unwrap())) +// .collect(); + +// // Alice creates a dual-funded channel as initiator. +// let funding_satoshis = session.funding_input_sats; +// let mut channel = PendingV2Channel::new_outbound( +// &LowerBoundedFeeEstimator(node_cfgs[0].fee_estimator), +// &nodes[0].node.entropy_source, +// &nodes[0].node.signer_provider, +// nodes[1].node.get_our_node_id(), +// &nodes[1].node.init_features(), +// funding_satoshis, +// initiator_funding_inputs.clone(), +// 42, /* user_channel_id */ +// nodes[0].node.get_current_default_configuration(), +// nodes[0].best_block_info().1, +// nodes[0].node.create_and_insert_outbound_scid_alias_for_test(), +// ConfirmationTarget::NonAnchorChannelFee, +// &logger_a, +// ) +// .unwrap(); +// let open_channel_v2_msg = channel.get_open_channel_v2(nodes[0].chain_source.chain_hash); + +// nodes[1].node.handle_open_channel_v2(nodes[0].node.get_our_node_id(), &open_channel_v2_msg); + +// let accept_channel_v2_msg = get_event_msg!( +// nodes[1], +// MessageSendEvent::SendAcceptChannelV2, +// nodes[0].node.get_our_node_id() +// ); +// let channel_id = ChannelId::v2_from_revocation_basepoints( +// &RevocationBasepoint::from(accept_channel_v2_msg.common_fields.revocation_basepoint), +// &RevocationBasepoint::from(open_channel_v2_msg.common_fields.revocation_basepoint), +// ); + +// let tx_add_input_msg = TxAddInput { +// channel_id, +// serial_id: 2, // Even serial_id from initiator. +// prevtx: initiator_funding_inputs[0].1.clone(), +// prevtx_out: 0, +// sequence: initiator_funding_inputs[0].0.sequence.0, +// shared_input_txid: None, +// }; +// let input_value = +// tx_add_input_msg.prevtx.as_transaction().output[tx_add_input_msg.prevtx_out as usize].value; +// assert_eq!(input_value.to_sat(), session.initiator_input_value_satoshis); + +// nodes[1].node.handle_tx_add_input(nodes[0].node.get_our_node_id(), &tx_add_input_msg); + +// let _tx_complete_msg = +// get_event_msg!(nodes[1], MessageSendEvent::SendTxComplete, nodes[0].node.get_our_node_id()); + +// let tx_add_output_msg = TxAddOutput { +// channel_id, +// serial_id: 4, +// sats: funding_satoshis, +// script: make_funding_redeemscript( +// &open_channel_v2_msg.common_fields.funding_pubkey, +// &accept_channel_v2_msg.common_fields.funding_pubkey, +// ) +// .to_p2wsh(), +// }; +// nodes[1].node.handle_tx_add_output(nodes[0].node.get_our_node_id(), &tx_add_output_msg); + +// let _tx_complete_msg = +// get_event_msg!(nodes[1], MessageSendEvent::SendTxComplete, nodes[0].node.get_our_node_id()); + +// let tx_complete_msg = TxComplete { channel_id }; + +// nodes[1].node.handle_tx_complete(nodes[0].node.get_our_node_id(), &tx_complete_msg); +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(msg_events.len(), 1); +// let _msg_commitment_signed_from_1 = match msg_events[0] { +// MessageSendEvent::UpdateHTLCs { ref node_id, channel_id: _, ref updates } => { +// assert_eq!(*node_id, nodes[0].node.get_our_node_id()); +// updates.commitment_signed.clone() +// }, +// _ => panic!("Unexpected event"), +// }; + +// let (funding_outpoint, channel_type_features) = { +// let per_peer_state = nodes[1].node.per_peer_state.read().unwrap(); +// let peer_state = +// per_peer_state.get(&nodes[0].node.get_our_node_id()).unwrap().lock().unwrap(); +// let channel_funding = +// peer_state.channel_by_id.get(&tx_complete_msg.channel_id).unwrap().funding(); +// (channel_funding.get_funding_txo(), channel_funding.get_channel_type().clone()) +// }; + +// channel.funding.channel_transaction_parameters = ChannelTransactionParameters { +// counterparty_parameters: Some(CounterpartyChannelTransactionParameters { +// pubkeys: ChannelPublicKeys { +// funding_pubkey: accept_channel_v2_msg.common_fields.funding_pubkey, +// revocation_basepoint: RevocationBasepoint( +// accept_channel_v2_msg.common_fields.revocation_basepoint, +// ), +// payment_point: accept_channel_v2_msg.common_fields.payment_basepoint, +// delayed_payment_basepoint: DelayedPaymentBasepoint( +// accept_channel_v2_msg.common_fields.delayed_payment_basepoint, +// ), +// htlc_basepoint: HtlcBasepoint(accept_channel_v2_msg.common_fields.htlc_basepoint), +// }, +// selected_contest_delay: accept_channel_v2_msg.common_fields.to_self_delay, +// }), +// holder_pubkeys: ChannelPublicKeys { +// funding_pubkey: open_channel_v2_msg.common_fields.funding_pubkey, +// revocation_basepoint: RevocationBasepoint( +// open_channel_v2_msg.common_fields.revocation_basepoint, +// ), +// payment_point: open_channel_v2_msg.common_fields.payment_basepoint, +// delayed_payment_basepoint: DelayedPaymentBasepoint( +// open_channel_v2_msg.common_fields.delayed_payment_basepoint, +// ), +// htlc_basepoint: HtlcBasepoint(open_channel_v2_msg.common_fields.htlc_basepoint), +// }, +// holder_selected_contest_delay: open_channel_v2_msg.common_fields.to_self_delay, +// is_outbound_from_holder: true, +// funding_outpoint, +// splice_parent_funding_txid: None, +// channel_type_features, +// channel_value_satoshis: funding_satoshis, +// }; + +// let msg_commitment_signed_from_0 = CommitmentSigned { +// channel_id, +// signature: channel +// .context +// .get_initial_counterparty_commitment_signature_for_test( +// &mut channel.funding, +// &&logger_a, +// accept_channel_v2_msg.common_fields.first_per_commitment_point, +// ) +// .unwrap(), +// htlc_signatures: vec![], +// funding_txid: None, +// #[cfg(taproot)] +// partial_signature_with_nonce: None, +// }; + +// chanmon_cfgs[1].persister.set_update_ret(crate::chain::ChannelMonitorUpdateStatus::InProgress); + +// // Handle the initial commitment_signed exchange. Order is not important here. +// nodes[1] +// .node +// .handle_commitment_signed(nodes[0].node.get_our_node_id(), &msg_commitment_signed_from_0); +// check_added_monitors(&nodes[1], 1); + +// // The funding transaction should not have been broadcast before persisting initial monitor has +// // been completed. +// assert_eq!(nodes[1].tx_broadcaster.txn_broadcast().len(), 0); +// assert_eq!(nodes[1].node.get_and_clear_pending_events().len(), 0); + +// // Complete the persistence of the monitor. +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert!(events.is_empty()); +// nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id); + +// let tx_signatures_msg = get_event_msg!( +// nodes[1], +// MessageSendEvent::SendTxSignatures, +// nodes[0].node.get_our_node_id() +// ); + +// assert_eq!(tx_signatures_msg.channel_id, channel_id); + +// let mut witness = Witness::new(); +// witness.push([0x0]); +// // Receive tx_signatures from channel initiator. +// nodes[1].node.handle_tx_signatures( +// nodes[0].node.get_our_node_id(), +// &TxSignatures { +// channel_id, +// tx_hash: funding_outpoint.unwrap().txid, +// witnesses: vec![witness], +// shared_input_signature: None, +// }, +// ); + +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::ChannelPending { channel_id: chan_id, .. } => assert_eq!(chan_id, channel_id), +// _ => panic!("Unexpected event"), +// }; + +// // For an inbound channel V2 channel the transaction should be broadcast once receiving a +// // tx_signature and applying local tx_signatures: +// let broadcasted_txs = nodes[1].tx_broadcaster.txn_broadcast(); +// assert_eq!(broadcasted_txs.len(), 1); +// } + +// #[test] +// fn test_v2_channel_establishment() { +// do_test_v2_channel_establishment(V2ChannelEstablishmentTestSession { +// funding_input_sats: 100_00, +// initiator_input_value_satoshis: 150_000, +// }); +// } diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index 93153eb1ad9..57fc09fcdbc 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -11270,79 +11270,79 @@ pub fn test_multi_post_event_actions() { do_test_multi_post_event_actions(false); } -#[xtest(feature = "_externalize_tests")] -pub fn test_batch_channel_open() { - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let node_a_id = nodes[0].node.get_our_node_id(); - let node_b_id = nodes[1].node.get_our_node_id(); - let node_c_id = nodes[2].node.get_our_node_id(); - - // Initiate channel opening and create the batch channel funding transaction. - let (tx, funding_created_msgs) = create_batch_channel_funding( - &nodes[0], - &[(&nodes[1], 100_000, 0, 42, None), (&nodes[2], 200_000, 0, 43, None)], - ); - - // Go through the funding_created and funding_signed flow with node 1. - nodes[1].node.handle_funding_created(node_a_id, &funding_created_msgs[0]); - check_added_monitors(&nodes[1], 1); - expect_channel_pending_event(&nodes[1], &node_a_id); - - let funding_signed_msg = - get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); - nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); - check_added_monitors(&nodes[0], 1); - - // The transaction should not have been broadcast before all channels are ready. - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0); - - // Go through the funding_created and funding_signed flow with node 2. - nodes[2].node.handle_funding_created(node_a_id, &funding_created_msgs[1]); - check_added_monitors(&nodes[2], 1); - expect_channel_pending_event(&nodes[2], &node_a_id); - - let funding_signed_msg = - get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, node_a_id); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_funding_signed(node_c_id, &funding_signed_msg); - check_added_monitors(&nodes[0], 1); - - // The transaction should not have been broadcast before persisting all monitors has been - // completed. - assert_eq!(nodes[0].tx_broadcaster.txn_broadcast().len(), 0); - assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); - - // Complete the persistence of the monitor. - nodes[0].chain_monitor.complete_sole_pending_chan_update(&ChannelId::v1_from_funding_outpoint( - OutPoint { txid: tx.compute_txid(), index: 1 }, - )); - let events = nodes[0].node.get_and_clear_pending_events(); - - // The transaction should only have been broadcast now. - let broadcasted_txs = nodes[0].tx_broadcaster.txn_broadcast(); - assert_eq!(broadcasted_txs.len(), 1); - assert_eq!(broadcasted_txs[0], tx); - - assert_eq!(events.len(), 2); - assert!(events.iter().any(|e| matches!( - *e, - crate::events::Event::ChannelPending { - ref counterparty_node_id, - .. - } if counterparty_node_id == &node_b_id, - ))); - assert!(events.iter().any(|e| matches!( - *e, - crate::events::Event::ChannelPending { - ref counterparty_node_id, - .. - } if counterparty_node_id == &node_c_id, - ))); -} +// #[xtest(feature = "_externalize_tests")] +// pub fn test_batch_channel_open() { +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let node_a_id = nodes[0].node.get_our_node_id(); +// let node_b_id = nodes[1].node.get_our_node_id(); +// let node_c_id = nodes[2].node.get_our_node_id(); + +// // Initiate channel opening and create the batch channel funding transaction. +// let (tx, funding_created_msgs) = create_batch_channel_funding( +// &nodes[0], +// &[(&nodes[1], 100_000, 0, 42, None), (&nodes[2], 200_000, 0, 43, None)], +// ); + +// // Go through the funding_created and funding_signed flow with node 1. +// nodes[1].node.handle_funding_created(node_a_id, &funding_created_msgs[0]); +// check_added_monitors(&nodes[1], 1); +// expect_channel_pending_event(&nodes[1], &node_a_id); + +// let funding_signed_msg = +// get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, node_a_id); +// nodes[0].node.handle_funding_signed(node_b_id, &funding_signed_msg); +// check_added_monitors(&nodes[0], 1); + +// // The transaction should not have been broadcast before all channels are ready. +// assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 0); + +// // Go through the funding_created and funding_signed flow with node 2. +// nodes[2].node.handle_funding_created(node_a_id, &funding_created_msgs[1]); +// check_added_monitors(&nodes[2], 1); +// expect_channel_pending_event(&nodes[2], &node_a_id); + +// let funding_signed_msg = +// get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, node_a_id); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.handle_funding_signed(node_c_id, &funding_signed_msg); +// check_added_monitors(&nodes[0], 1); + +// // The transaction should not have been broadcast before persisting all monitors has been +// // completed. +// assert_eq!(nodes[0].tx_broadcaster.txn_broadcast().len(), 0); +// assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0); + +// // Complete the persistence of the monitor. +// nodes[0].chain_monitor.complete_sole_pending_chan_update(&ChannelId::v1_from_funding_outpoint( +// OutPoint { txid: tx.compute_txid(), index: 1 }, +// )); +// let events = nodes[0].node.get_and_clear_pending_events(); + +// // The transaction should only have been broadcast now. +// let broadcasted_txs = nodes[0].tx_broadcaster.txn_broadcast(); +// assert_eq!(broadcasted_txs.len(), 1); +// assert_eq!(broadcasted_txs[0], tx); + +// assert_eq!(events.len(), 2); +// assert!(events.iter().any(|e| matches!( +// *e, +// crate::events::Event::ChannelPending { +// ref counterparty_node_id, +// .. +// } if counterparty_node_id == &node_b_id, +// ))); +// assert!(events.iter().any(|e| matches!( +// *e, +// crate::events::Event::ChannelPending { +// ref counterparty_node_id, +// .. +// } if counterparty_node_id == &node_c_id, +// ))); +// } #[xtest(feature = "_externalize_tests")] pub fn test_close_in_funding_batch() { diff --git a/lightning/src/ln/priv_short_conf_tests.rs b/lightning/src/ln/priv_short_conf_tests.rs index 8f0ab5e39ed..8b27d49f64e 100644 --- a/lightning/src/ln/priv_short_conf_tests.rs +++ b/lightning/src/ln/priv_short_conf_tests.rs @@ -1,1043 +1,1043 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - -// This file is Copyright its original authors, visible in version control -// history. -// -// This file is licensed under the Apache License, Version 2.0 or the MIT license -// , at your option. -// You may not use this file except in accordance with one or both of these -// licenses. - -//! Tests that test ChannelManager behavior with fewer confirmations required than the default and -//! other behavior that exists only on private channels or with a semi-trusted counterparty (eg -//! LSP). - -use crate::chain::ChannelMonitorUpdateStatus; -use crate::events::{ClosureReason, Event, HTLCHandlingFailureType}; -use crate::ln::channelmanager::{MIN_CLTV_EXPIRY_DELTA, PaymentId, RecipientOnionFields}; -use crate::ln::onion_utils::LocalHTLCFailureReason; -use crate::routing::gossip::RoutingFees; -use crate::routing::router::{PaymentParameters, RouteHint, RouteHintHop}; -use crate::types::features::ChannelTypeFeatures; -use crate::ln::msgs; -use crate::ln::types::ChannelId; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, RoutingMessageHandler, ErrorAction, MessageSendEvent}; -use crate::util::config::{MaxDustHTLCExposure, UserConfig}; -use crate::util::ser::Writeable; - -use crate::prelude::*; - -use crate::ln::functional_test_utils::*; - -#[test] -fn test_priv_forwarding_rejection() { - // If we have a private channel with outbound liquidity, and - // UserConfig::accept_forwards_to_priv_channels is set to false, we should reject any attempts - // to forward through that channel. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut no_announce_cfg = test_default_channel_config(); - no_announce_cfg.accept_forwards_to_priv_channels = false; - let persister; - let new_chain_monitor; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg.clone()), None]); - let nodes_1_deserialized; - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let chan_id_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; - let chan_id_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0.channel_id; - - // We should always be able to forward through nodes[1] as long as its out through a public - // channel: - send_payment(&nodes[2], &[&nodes[1], &nodes[0]], 10_000); - - // ... however, if we send to nodes[2], we will have to pass the private channel from nodes[1] - // to nodes[2], which should be rejected: - let route_hint = RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), - short_channel_id: nodes[2].node.list_channels()[0].short_channel_id.unwrap(), - fees: RoutingFees { base_msat: 1000, proportional_millionths: 0 }, - cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA, - htlc_minimum_msat: None, - htlc_maximum_msat: None, - }]); - let last_hops = vec![route_hint]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(last_hops).unwrap(); - let (route, our_payment_hash, our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); - - nodes[0].node.send_payment_with_route(route.clone(), our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_htlc_handling_failed_destinations!( - nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }] - ); - check_added_monitors(&nodes[1], 1); - - let htlc_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - assert!(htlc_fail_updates.update_add_htlcs.is_empty()); - assert_eq!(htlc_fail_updates.update_fail_htlcs.len(), 1); - assert!(htlc_fail_updates.update_fail_malformed_htlcs.is_empty()); - assert!(htlc_fail_updates.update_fee.is_none()); - - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &htlc_fail_updates.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], htlc_fail_updates.commitment_signed, true, true); - expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, nodes[2].node.list_channels()[0].short_channel_id.unwrap(), true); - - // Now disconnect nodes[1] from its peers and restart with accept_forwards_to_priv_channels set - // to true. Sadly there is currently no way to change it at runtime. - - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[2].node.peer_disconnected(nodes[1].node.get_our_node_id()); - - let nodes_1_serialized = nodes[1].node.encode(); - let monitor_a_serialized = get_monitor!(nodes[1], chan_id_1).encode(); - let monitor_b_serialized = get_monitor!(nodes[1], chan_id_2).encode(); - - no_announce_cfg.accept_forwards_to_priv_channels = true; - reload_node!(nodes[1], no_announce_cfg, &nodes_1_serialized, &[&monitor_a_serialized, &monitor_b_serialized], persister, new_chain_monitor, nodes_1_deserialized); - - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &as_reestablish); - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); - get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); - - nodes[1].node.peer_connected(nodes[2].node.get_our_node_id(), &msgs::Init { - features: nodes[2].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - nodes[2].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[2]).pop().unwrap(); - let cs_reestablish = get_chan_reestablish_msgs!(nodes[2], nodes[1]).pop().unwrap(); - nodes[2].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); - nodes[1].node.handle_channel_reestablish(nodes[2].node.get_our_node_id(), &cs_reestablish); - get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - - nodes[0].node.send_payment_with_route(route, our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 10_000, our_payment_hash, our_payment_secret); - claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], our_payment_preimage); -} - -fn do_test_1_conf_open(connect_style: ConnectStyle) { - // Previously, if the minium_depth config was set to 1, we'd never send a channel_ready. This - // tests that we properly send one in that case. - let mut alice_config = UserConfig::default(); - alice_config.channel_handshake_config.minimum_depth = 1; - alice_config.channel_handshake_config.announce_for_forwarding = true; - alice_config.channel_handshake_limits.force_announced_channel_preference = false; - alice_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); - let mut bob_config = UserConfig::default(); - bob_config.channel_handshake_config.minimum_depth = 1; - bob_config.channel_handshake_config.announce_for_forwarding = true; - bob_config.channel_handshake_limits.force_announced_channel_preference = false; - bob_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); - 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, &[Some(alice_config), Some(bob_config)]); - let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - *nodes[0].connect_style.borrow_mut() = connect_style; - - let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001); - mine_transaction(&nodes[1], &tx); - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id())); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - mine_transaction(&nodes[0], &tx); - let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_msg_events.len(), 2); - let as_channel_ready = if let MessageSendEvent::SendChannelReady { ref node_id, ref msg } = as_msg_events[0] { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - msg.clone() - } else { panic!("Unexpected event"); }; - if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = as_msg_events[1] { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - } else { panic!("Unexpected event"); } - - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &as_channel_ready); - expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); - let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_msg_events.len(), 1); - if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = bs_msg_events[0] { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - } else { panic!("Unexpected event"); } - - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - // After 6 confirmations, as required by the spec, we'll send announcement_signatures and - // broadcast the channel_announcement (but not before exactly 6 confirmations). - connect_blocks(&nodes[0], 4); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - connect_blocks(&nodes[0], 1); - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id())); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - connect_blocks(&nodes[1], 5); - let bs_announce_events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_announce_events.len(), 2); - let bs_announcement_sigs = if let MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } = bs_announce_events[1] { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - msg.clone() - } else { panic!("Unexpected event"); }; - let (bs_announcement, bs_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = bs_announce_events[0] { - (msg.clone(), update_msg.clone().unwrap()) - } else { panic!("Unexpected event"); }; - - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); - let as_announce_events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_announce_events.len(), 1); - let (announcement, as_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = as_announce_events[0] { - (msg.clone(), update_msg.clone().unwrap()) - } else { panic!("Unexpected event"); }; - assert_eq!(announcement, bs_announcement); - - for (i, node) in nodes.iter().enumerate() { - let counterparty_node_id = nodes[(i + 1) % 2].node.get_our_node_id(); - assert!(node.gossip_sync.handle_channel_announcement(Some(counterparty_node_id), &announcement).unwrap()); - node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &as_update).unwrap(); - node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap(); - } -} -#[test] -fn test_1_conf_open() { - do_test_1_conf_open(ConnectStyle::BestBlockFirst); - do_test_1_conf_open(ConnectStyle::TransactionsFirst); - do_test_1_conf_open(ConnectStyle::FullBlockViaListen); -} - -#[test] -fn test_routed_scid_alias() { - // Trivially test sending a payment which is routed through an SCID alias. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut no_announce_cfg = test_default_channel_config(); - no_announce_cfg.accept_forwards_to_priv_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg), None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; - let mut as_channel_ready = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0; - - let last_hop = nodes[2].node.list_usable_channels(); - let hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), - short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), - fees: RoutingFees { - base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, - }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, - htlc_maximum_msat: None, - htlc_minimum_msat: None, - }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); - assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - - pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); - - as_channel_ready.short_channel_id_alias = Some(0xeadbeef); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); - // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason - // to bother updating that code, so just drop the message here. - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - - claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); - - // Now test that if a peer sends us a second channel_ready after the channel is operational we - // will use the new alias. - as_channel_ready.short_channel_id_alias = Some(0xdeadbeef); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); - // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason - // to bother updating that code, so just drop the message here. - get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - let updated_channel_info = nodes[2].node.list_usable_channels(); - assert_eq!(updated_channel_info.len(), 1); - assert_eq!(updated_channel_info[0].inbound_scid_alias.unwrap(), 0xdeadbeef); - // Note that because we never send a duplicate channel_ready we can't send a payment through - // the 0xdeadbeef SCID alias. -} - -#[test] -fn test_scid_privacy_on_pub_channel() { - // Tests rejecting the scid_privacy feature for public channels and that we don't ever try to - // send them. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let mut scid_privacy_cfg = test_default_channel_config(); - scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = true; - scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - assert!(!open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); // we ignore `negotiate_scid_privacy` on pub channels - open_channel.common_fields.channel_type.as_mut().unwrap().set_scid_privacy_required(); - assert_eq!(open_channel.common_fields.channel_flags & 1, 1); // The `announce_channel` bit is set. - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let err = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id()); - assert_eq!(err.data, "SCID Alias/Privacy Channel Type cannot be set on a public channel"); -} - -#[test] -fn test_scid_privacy_negotiation() { - // Tests of the negotiation of SCID alias and falling back to non-SCID-alias if our - // counterparty doesn't support it. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let mut scid_privacy_cfg = test_default_channel_config(); - scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = false; - scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); - - let init_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - assert!(init_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); - assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts - - // now simulate nodes[1] responding with an Error message, indicating it doesn't understand - // SCID alias. - nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { - channel_id: init_open_channel.common_fields.temporary_channel_id, - data: "Yo, no SCID aliases, no privacy here!".to_string() - }); - assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts - - let second_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - assert!(!second_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &second_open_channel); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::FundingGenerationReady { .. } => {}, - _ => panic!("Unexpected event"), - } - - assert!(!nodes[0].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); - assert!(!nodes[1].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); -} - -#[test] -fn test_inbound_scid_privacy() { - // Tests accepting channels with the scid_privacy feature and rejecting forwards using the - // channel's real SCID as required by the channel feature. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut accept_forward_cfg = test_default_channel_config(); - accept_forward_cfg.accept_forwards_to_priv_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); - - let mut no_announce_cfg = test_default_channel_config(); - no_announce_cfg.channel_handshake_config.announce_for_forwarding = false; - no_announce_cfg.channel_handshake_config.negotiate_scid_privacy = true; - nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 10_000, 42, None, Some(no_announce_cfg)).unwrap(); - let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[2].node.get_our_node_id()); - - assert!(open_channel.common_fields.channel_type.as_ref().unwrap().requires_scid_privacy()); - - nodes[2].node.handle_open_channel(nodes[1].node.get_our_node_id(), &open_channel); - let accept_channel = get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_accept_channel(nodes[2].node.get_our_node_id(), &accept_channel); - - let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[1], &nodes[2].node.get_our_node_id(), 100_000, 42); - nodes[1].node.funding_transaction_generated(temporary_channel_id, nodes[2].node.get_our_node_id(), tx.clone()).unwrap(); - nodes[2].node.handle_funding_created(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingCreated, nodes[2].node.get_our_node_id())); - check_added_monitors!(nodes[2], 1); - - let cs_funding_signed = get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, nodes[1].node.get_our_node_id()); - expect_channel_pending_event(&nodes[2], &nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_funding_signed(nodes[2].node.get_our_node_id(), &cs_funding_signed); - expect_channel_pending_event(&nodes[1], &nodes[2].node.get_our_node_id()); - check_added_monitors!(nodes[1], 1); - - let conf_height = core::cmp::max(nodes[1].best_block_info().1 + 1, nodes[2].best_block_info().1 + 1); - confirm_transaction_at(&nodes[1], &tx, conf_height); - connect_blocks(&nodes[1], CHAN_CONFIRM_DEPTH - 1); - confirm_transaction_at(&nodes[2], &tx, conf_height); - connect_blocks(&nodes[2], CHAN_CONFIRM_DEPTH - 1); - let bs_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[2].node.get_our_node_id()); - nodes[1].node.handle_channel_ready(nodes[2].node.get_our_node_id(), &get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id())); - expect_channel_ready_event(&nodes[1], &nodes[2].node.get_our_node_id()); - let bs_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); - nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &bs_channel_ready); - expect_channel_ready_event(&nodes[2], &nodes[1].node.get_our_node_id()); - let cs_update = get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_channel_update(nodes[2].node.get_our_node_id(), &cs_update); - nodes[2].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_update); - - // Now we can pay just fine using the SCID alias nodes[2] gave to nodes[1]... - - let last_hop = nodes[2].node.list_usable_channels(); - let mut hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), - short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), - fees: RoutingFees { - base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, - }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, - htlc_maximum_msat: None, - htlc_minimum_msat: None, - }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints.clone()).unwrap(); - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); - assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - - pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); - claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); - - // ... but if we try to pay using the real SCID, nodes[1] will just tell us they don't know - // what channel we're talking about. - hop_hints[0].0[0].short_channel_id = last_hop[0].short_channel_id.unwrap(); - - let payment_params_2 = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (route_2, payment_hash_2, _, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params_2, 100_000); - assert_eq!(route_2.paths[0].hops[1].short_channel_id, last_hop[0].short_channel_id.unwrap()); - nodes[0].node.send_payment_with_route(route_2, payment_hash_2, - RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - - let payment_event = SendEvent::from_node(&nodes[0]); - assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); - commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, true, true); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_htlc_handling_failed_destinations!( - nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: last_hop[0].channel_id }] - ); - check_added_monitors(&nodes[1], 1); - - nodes[1].logger.assert_log_regex("lightning::ln::channelmanager", - regex::Regex::new(r"Failed to accept/forward incoming HTLC: RealSCIDForward").unwrap(), 1); - - let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); - - expect_payment_failed_conditions(&nodes[0], payment_hash_2, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].short_channel_id.unwrap()) - .blamed_chan_closed(true).expected_htlc_error_data(LocalHTLCFailureReason::UnknownNextPeer, &[0; 0])); -} - -#[test] -fn test_scid_alias_returned() { - // Tests that when we fail an HTLC (in this case due to attempting to forward more than the - // channel's available balance) we use the correct (in this case the aliased) SCID in the - // channel_update which is returned in the onion to the sender. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut accept_forward_cfg = test_default_channel_config(); - accept_forward_cfg.accept_forwards_to_priv_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0); - let chan = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000, 0); - - let last_hop = nodes[2].node.list_usable_channels(); - let mut hop_hints = vec![RouteHint(vec![RouteHintHop { - src_node_id: nodes[1].node.get_our_node_id(), - short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), - fees: RoutingFees { - base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, - proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, - }, - cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, - htlc_maximum_msat: None, - htlc_minimum_msat: None, - }])]; - let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), 42) - .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() - .with_route_hints(hop_hints).unwrap(); - let (mut route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); - assert_eq!(route.paths[0].hops[1].short_channel_id, nodes[2].node.list_usable_channels()[0].inbound_scid_alias.unwrap()); - - route.paths[0].hops[1].fee_msat = 10_000_000; // Overshoot the last channel's value - - // Route the HTLC through to the destination. - nodes[0].node.send_payment_with_route(route.clone(), payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); - commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], vec![HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }]); - check_added_monitors!(nodes[1], 1); - - let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); - - let err_data = 0u16.to_be_bytes(); - expect_payment_failed_conditions(&nodes[0], payment_hash, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) - .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::TemporaryChannelFailure, &err_data)); - - route.paths[0].hops[1].fee_msat = 10_000; // Reset to the correct payment amount - route.paths[0].hops[0].fee_msat = 0; // But set fee paid to the middle hop to 0 - - // Route the HTLC through to the destination. - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); - commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); - - expect_pending_htlcs_forwardable!(nodes[1]); - expect_htlc_handling_failed_destinations!( - nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }] - ); - check_added_monitors(&nodes[1], 1); - - let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); - - let mut err_data = Vec::new(); - err_data.extend_from_slice(&10_000u64.to_be_bytes()); - err_data.extend_from_slice(&0u16.to_be_bytes()); - expect_payment_failed_conditions(&nodes[0], payment_hash, false, - PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) - .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::FeeInsufficient, &err_data)); -} - -#[test] -fn test_simple_0conf_channel() { - // If our peer tells us they will accept our channel with 0 confs, and we funded the channel, - // we should trust the funding won't be double-spent (assuming `trust_own_funding_0conf` is - // set)! - // Further, if we `accept_inbound_channel_from_trusted_peer_0conf`, `channel_ready` messages - // should fly immediately and the channel should be available for use as soon as they are - // received. - - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - open_zero_conf_channel(&nodes[0], &nodes[1], None); - - send_payment(&nodes[0], &[&nodes[1]], 100_000); -} - -#[test] -fn test_0conf_channel_with_async_monitor() { - // Test that we properly send out channel_ready in (both inbound- and outbound-) zero-conf - // channels if ChannelMonitor updates return a `TemporaryFailure` during the initial channel - // negotiation. - - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(chan_config.clone()), None]); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); - - chan_config.channel_handshake_config.announce_for_forwarding = false; - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(chan_config)).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); - }, - _ => panic!("Unexpected event"), - }; - - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); - assert_eq!(accept_channel.common_fields.minimum_depth, 0); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); - - let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); - nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); - let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - let channel_id = ChannelId::v1_from_funding_outpoint(funding_output); - nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id); - expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); - - let bs_signed_locked = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_signed_locked.len(), 2); - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - - match &bs_signed_locked[0] { - MessageSendEvent::SendFundingSigned { node_id, msg } => { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &msg); - check_added_monitors!(nodes[0], 1); - } - _ => panic!("Unexpected event"), - } - match &bs_signed_locked[1] { - MessageSendEvent::SendChannelReady { node_id, msg } => { - assert_eq!(*node_id, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &msg); - } - _ => panic!("Unexpected event"), - } - - assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - nodes[0].chain_monitor.complete_sole_pending_chan_update(&channel_id); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 2); - match events[0] { - crate::events::Event::ChannelPending { ref counterparty_node_id, .. } => { - assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); - }, - _ => panic!("Unexpected event"), - } - match events[1] { - crate::events::Event::ChannelReady { ref counterparty_node_id, .. } => { - assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); - }, - _ => panic!("Unexpected event"), - } - - let as_locked_update = nodes[0].node.get_and_clear_pending_msg_events(); - - // Note that the funding transaction is actually released when - // get_and_clear_pending_msg_events, above, checks for monitor events. - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], tx); - - match &as_locked_update[0] { - MessageSendEvent::SendChannelReady { node_id, msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &msg); - } - _ => panic!("Unexpected event"), - } - expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); - - let bs_channel_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); - - let as_channel_update = match &as_locked_update[1] { - MessageSendEvent::SendChannelUpdate { node_id, msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - msg.clone() - } - _ => panic!("Unexpected event"), - }; - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - - nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_channel_update); - nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &as_channel_update); - - assert_eq!(nodes[0].node.list_usable_channels().len(), 1); - assert_eq!(nodes[1].node.list_usable_channels().len(), 2); - - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - // Now that we have useful channels, try sending a payment where the we hit a temporary monitor - // failure before we've ever confirmed the funding transaction. This previously caused a panic. - let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000); - - nodes[0].node.send_payment_with_route(route, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); - check_added_monitors!(nodes[0], 1); - - let as_send = SendEvent::from_node(&nodes[0]); - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_send.msgs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_send.commitment_msg); - check_added_monitors!(nodes[1], 1); - - let (bs_raa, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); - check_added_monitors!(nodes[0], 1); - - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_commitment_signed); - check_added_monitors!(nodes[0], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id())); - check_added_monitors!(nodes[1], 1); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); - let (_, latest_update) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&bs_raa.channel_id).unwrap().clone(); - nodes[1].chain_monitor.chain_monitor.channel_monitor_updated(bs_raa.channel_id, latest_update).unwrap(); - check_added_monitors!(nodes[1], 0); - expect_pending_htlcs_forwardable!(nodes[1]); - check_added_monitors!(nodes[1], 1); - - let bs_send = SendEvent::from_node(&nodes[1]); - nodes[2].node.handle_update_add_htlc(nodes[1].node.get_our_node_id(), &bs_send.msgs[0]); - commitment_signed_dance!(nodes[2], nodes[1], bs_send.commitment_msg, false); - expect_pending_htlcs_forwardable!(nodes[2]); - expect_payment_claimable!(nodes[2], payment_hash, payment_secret, 1_000_000); - claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); - - confirm_transaction(&nodes[0], &tx); - confirm_transaction(&nodes[1], &tx); - - send_payment(&nodes[0], &[&nodes[1]], 100_000); -} - -#[test] -fn test_0conf_close_no_early_chan_update() { - // Tests that even with a public channel 0conf channel, we don't generate a channel_update on - // closing. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let error_message = "Channel force-closed"; - - // This is the default but we force it on anyway - chan_config.channel_handshake_config.announce_for_forwarding = true; - open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); - - // We can use the channel immediately, but won't generate a channel_update until we get confs - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - nodes[0].node.force_close_all_channels_broadcasting_latest_txn(error_message.to_string()); - check_added_monitors!(nodes[0], 1); - check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[1].node.get_our_node_id()], 100000); - let _ = get_err_msg(&nodes[0], &nodes[1].node.get_our_node_id()); -} - -#[test] -fn test_public_0conf_channel() { - // Tests that we will announce a public channel (after confirmation) even if its 0conf. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // This is the default but we force it on anyway - chan_config.channel_handshake_config.announce_for_forwarding = true; - let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); - - // We can use the channel immediately, but we can't announce it until we get 6+ confirmations - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - let scid = confirm_transaction(&nodes[0], &tx); - let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); - assert_eq!(confirm_transaction(&nodes[1], &tx), scid); - let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); - - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); - - let bs_announcement = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(bs_announcement.len(), 1); - let announcement; - let bs_update; - match bs_announcement[0] { - MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { - announcement = msg.clone(); - bs_update = update_msg.clone().unwrap(); - }, - _ => panic!("Unexpected event"), - }; - - let as_announcement = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_announcement.len(), 1); - match as_announcement[0] { - MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { - assert!(announcement == *msg); - let update_msg = update_msg.as_ref().unwrap(); - assert_eq!(update_msg.contents.short_channel_id, scid); - assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id); - assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id); - }, - _ => panic!("Unexpected event"), - }; -} - -#[test] -fn test_0conf_channel_reorg() { - // If we accept a 0conf channel, which is then confirmed, but then changes SCID in a reorg, we - // have to make sure we handle this correctly (or, currently, just force-close the channel). - - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // This is the default but we force it on anyway - chan_config.channel_handshake_config.announce_for_forwarding = true; - let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); - - // We can use the channel immediately, but we can't announce it until we get 6+ confirmations - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - mine_transaction(&nodes[0], &tx); - mine_transaction(&nodes[1], &tx); - - // Send a payment using the channel's real SCID, which will be public in a few blocks once we - // can generate a channel_announcement. - let real_scid = nodes[0].node.list_usable_channels()[0].short_channel_id.unwrap(); - assert_eq!(nodes[1].node.list_usable_channels()[0].short_channel_id.unwrap(), real_scid); - - let (mut route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000); - assert_eq!(route.paths[0].hops[0].short_channel_id, real_scid); - send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1]]], 10_000, payment_hash, payment_secret); - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); - - disconnect_blocks(&nodes[0], 1); - disconnect_blocks(&nodes[1], 1); - - // At this point the channel no longer has an SCID again. In the future we should likely - // support simply un-setting the SCID and waiting until the channel gets re-confirmed, but for - // now we force-close the channel here. - check_closed_event!(&nodes[0], 1, ClosureReason::ProcessingError { - err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() - }, [nodes[1].node.get_our_node_id()], 100000); - check_closed_broadcast!(nodes[0], true); - check_added_monitors(&nodes[0], 1); - check_closed_event!(&nodes[1], 1, ClosureReason::ProcessingError { - err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() - }, [nodes[0].node.get_our_node_id()], 100000); - check_closed_broadcast!(nodes[1], true); - check_added_monitors(&nodes[1], 1); -} - -#[test] -fn test_zero_conf_accept_reject() { - let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key(); - channel_type_features.set_zero_conf_required(); - - // 1. Check we reject zero conf channels by default - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); - - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - match msg_events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { - assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); - }, - _ => panic!(), - } - - // 2. Check we can manually accept zero conf channels via the right method - let mut manually_accept_conf = UserConfig::default(); - manually_accept_conf.manually_accept_inbound_channels = true; - - 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, Some(manually_accept_conf.clone())]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // 2.1 First try the non-0conf method to manually accept - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, - None, Some(manually_accept_conf.clone())).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, - nodes[1].node.get_our_node_id()); - - open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); - - // Assert that `nodes[1]` has no `MessageSendEvent::SendAcceptChannel` in the `msg_events`. - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - let events = nodes[1].node.get_and_clear_pending_events(); - - match events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - // Assert we fail to accept via the non-0conf method - assert!(nodes[1].node.accept_inbound_channel(&temporary_channel_id, - &nodes[0].node.get_our_node_id(), 0, None).is_err()); - }, - _ => panic!(), - } - - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - match msg_events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { - assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); - }, - _ => panic!(), - } - - // 2.2 Try again with the 0conf method to manually accept - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, - None, Some(manually_accept_conf)).unwrap(); - let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, - nodes[1].node.get_our_node_id()); - - open_channel_msg.common_fields.channel_type = Some(channel_type_features); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); - - let events = nodes[1].node.get_and_clear_pending_events(); - - match events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - // Assert we can accept via the 0conf method - assert!(nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( - &temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).is_ok()); - }, - _ => panic!(), - } - - // Check we would send accept - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - match msg_events[0] { - MessageSendEvent::SendAcceptChannel { .. } => {}, - _ => panic!(), - } -} - -#[test] -fn test_connect_before_funding() { - // Tests for a particularly dumb explicit panic that existed prior to 0.0.111 for 0conf - // channels. If we received a block while awaiting funding for 0-conf channels we'd hit an - // explicit panic when deciding if we should broadcast our channel_ready message. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - - let mut manually_accept_conf = test_default_channel_config(); - manually_accept_conf.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_conf)]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 10_001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let events = nodes[1].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::OpenChannelRequest { temporary_channel_id, .. } => { - nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); - }, - _ => panic!("Unexpected event"), - }; - - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); - assert_eq!(accept_channel.common_fields.minimum_depth, 0); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 1); - match events[0] { - Event::FundingGenerationReady { .. } => {}, - _ => panic!("Unexpected event"), - } - - connect_blocks(&nodes[0], 1); - connect_blocks(&nodes[1], 1); -} - -#[test] -fn test_0conf_ann_sigs_racing_conf() { - // Previously we had a bug where we'd panic when receiving a counterparty's - // announcement_signatures message for a 0conf channel pending confirmation on-chain. Here we - // check that we just error out, ignore the announcement_signatures message, and proceed - // instead. - let chanmon_cfgs = create_chanmon_cfgs(2); - let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let mut chan_config = test_default_channel_config(); - chan_config.manually_accept_inbound_channels = true; - - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // This is the default but we force it on anyway - chan_config.channel_handshake_config.announce_for_forwarding = true; - let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); - - // We can use the channel immediately, but we can't announce it until we get 6+ confirmations - send_payment(&nodes[0], &[&nodes[1]], 100_000); - - let scid = confirm_transaction(&nodes[0], &tx); - let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); - - // Handling the announcement_signatures prior to the first confirmation would panic before. - nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); - - assert_eq!(confirm_transaction(&nodes[1], &tx), scid); - let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); - - nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); - let as_announcement = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_announcement.len(), 1); -} +// #![cfg_attr(rustfmt, rustfmt_skip)] + +// // This file is Copyright its original authors, visible in version control +// // history. +// // +// // This file is licensed under the Apache License, Version 2.0 or the MIT license +// // , at your option. +// // You may not use this file except in accordance with one or both of these +// // licenses. + +// //! Tests that test ChannelManager behavior with fewer confirmations required than the default and +// //! other behavior that exists only on private channels or with a semi-trusted counterparty (eg +// //! LSP). + +// use crate::chain::ChannelMonitorUpdateStatus; +// use crate::events::{ClosureReason, Event, HTLCHandlingFailureType}; +// use crate::ln::channelmanager::{MIN_CLTV_EXPIRY_DELTA, PaymentId, RecipientOnionFields}; +// use crate::ln::onion_utils::LocalHTLCFailureReason; +// use crate::routing::gossip::RoutingFees; +// use crate::routing::router::{PaymentParameters, RouteHint, RouteHintHop}; +// use crate::types::features::ChannelTypeFeatures; +// use crate::ln::msgs; +// use crate::ln::types::ChannelId; +// use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, RoutingMessageHandler, ErrorAction, MessageSendEvent}; +// use crate::util::config::{MaxDustHTLCExposure, UserConfig}; +// use crate::util::ser::Writeable; + +// use crate::prelude::*; + +// use crate::ln::functional_test_utils::*; + +// #[test] +// fn test_priv_forwarding_rejection() { +// // If we have a private channel with outbound liquidity, and +// // UserConfig::accept_forwards_to_priv_channels is set to false, we should reject any attempts +// // to forward through that channel. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut no_announce_cfg = test_default_channel_config(); +// no_announce_cfg.accept_forwards_to_priv_channels = false; +// let persister; +// let new_chain_monitor; +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg.clone()), None]); +// let nodes_1_deserialized; +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let chan_id_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; +// let chan_id_2 = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0.channel_id; + +// // We should always be able to forward through nodes[1] as long as its out through a public +// // channel: +// send_payment(&nodes[2], &[&nodes[1], &nodes[0]], 10_000); + +// // ... however, if we send to nodes[2], we will have to pass the private channel from nodes[1] +// // to nodes[2], which should be rejected: +// let route_hint = RouteHint(vec![RouteHintHop { +// src_node_id: nodes[1].node.get_our_node_id(), +// short_channel_id: nodes[2].node.list_channels()[0].short_channel_id.unwrap(), +// fees: RoutingFees { base_msat: 1000, proportional_millionths: 0 }, +// cltv_expiry_delta: MIN_CLTV_EXPIRY_DELTA, +// htlc_minimum_msat: None, +// htlc_maximum_msat: None, +// }]); +// let last_hops = vec![route_hint]; +// let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() +// .with_route_hints(last_hops).unwrap(); +// let (route, our_payment_hash, our_payment_preimage, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); + +// nodes[0].node.send_payment_with_route(route.clone(), our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_htlc_handling_failed_destinations!( +// nodes[1].node.get_and_clear_pending_events(), +// &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }] +// ); +// check_added_monitors(&nodes[1], 1); + +// let htlc_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// assert!(htlc_fail_updates.update_add_htlcs.is_empty()); +// assert_eq!(htlc_fail_updates.update_fail_htlcs.len(), 1); +// assert!(htlc_fail_updates.update_fail_malformed_htlcs.is_empty()); +// assert!(htlc_fail_updates.update_fee.is_none()); + +// nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &htlc_fail_updates.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], htlc_fail_updates.commitment_signed, true, true); +// expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, nodes[2].node.list_channels()[0].short_channel_id.unwrap(), true); + +// // Now disconnect nodes[1] from its peers and restart with accept_forwards_to_priv_channels set +// // to true. Sadly there is currently no way to change it at runtime. + +// nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); +// nodes[2].node.peer_disconnected(nodes[1].node.get_our_node_id()); + +// let nodes_1_serialized = nodes[1].node.encode(); +// let monitor_a_serialized = get_monitor!(nodes[1], chan_id_1).encode(); +// let monitor_b_serialized = get_monitor!(nodes[1], chan_id_2).encode(); + +// no_announce_cfg.accept_forwards_to_priv_channels = true; +// reload_node!(nodes[1], no_announce_cfg, &nodes_1_serialized, &[&monitor_a_serialized, &monitor_b_serialized], persister, new_chain_monitor, nodes_1_deserialized); + +// nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { +// features: nodes[1].node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { +// features: nodes[0].node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); +// nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &as_reestablish); +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); +// get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); +// get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); + +// nodes[1].node.peer_connected(nodes[2].node.get_our_node_id(), &msgs::Init { +// features: nodes[2].node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// nodes[2].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { +// features: nodes[1].node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[2]).pop().unwrap(); +// let cs_reestablish = get_chan_reestablish_msgs!(nodes[2], nodes[1]).pop().unwrap(); +// nodes[2].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &bs_reestablish); +// nodes[1].node.handle_channel_reestablish(nodes[2].node.get_our_node_id(), &cs_reestablish); +// get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); +// get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + +// nodes[0].node.send_payment_with_route(route, our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); +// pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 10_000, our_payment_hash, our_payment_secret); +// claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], our_payment_preimage); +// } + +// fn do_test_1_conf_open(connect_style: ConnectStyle) { +// // Previously, if the minium_depth config was set to 1, we'd never send a channel_ready. This +// // tests that we properly send one in that case. +// let mut alice_config = UserConfig::default(); +// alice_config.channel_handshake_config.minimum_depth = 1; +// alice_config.channel_handshake_config.announce_for_forwarding = true; +// alice_config.channel_handshake_limits.force_announced_channel_preference = false; +// alice_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); +// let mut bob_config = UserConfig::default(); +// bob_config.channel_handshake_config.minimum_depth = 1; +// bob_config.channel_handshake_config.announce_for_forwarding = true; +// bob_config.channel_handshake_limits.force_announced_channel_preference = false; +// bob_config.channel_config.max_dust_htlc_exposure = MaxDustHTLCExposure::FeeRateMultiplier(5_000_000 / 253); +// 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, &[Some(alice_config), Some(bob_config)]); +// let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// *nodes[0].connect_style.borrow_mut() = connect_style; + +// let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001); +// mine_transaction(&nodes[1], &tx); +// nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[0].node.get_our_node_id())); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// mine_transaction(&nodes[0], &tx); +// let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_msg_events.len(), 2); +// let as_channel_ready = if let MessageSendEvent::SendChannelReady { ref node_id, ref msg } = as_msg_events[0] { +// assert_eq!(*node_id, nodes[1].node.get_our_node_id()); +// msg.clone() +// } else { panic!("Unexpected event"); }; +// if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = as_msg_events[1] { +// assert_eq!(*node_id, nodes[1].node.get_our_node_id()); +// } else { panic!("Unexpected event"); } + +// nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &as_channel_ready); +// expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id()); +// expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); +// let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_msg_events.len(), 1); +// if let MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } = bs_msg_events[0] { +// assert_eq!(*node_id, nodes[0].node.get_our_node_id()); +// } else { panic!("Unexpected event"); } + +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// // After 6 confirmations, as required by the spec, we'll send announcement_signatures and +// // broadcast the channel_announcement (but not before exactly 6 confirmations). +// connect_blocks(&nodes[0], 4); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// connect_blocks(&nodes[0], 1); +// nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id())); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// connect_blocks(&nodes[1], 5); +// let bs_announce_events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_announce_events.len(), 2); +// let bs_announcement_sigs = if let MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } = bs_announce_events[1] { +// assert_eq!(*node_id, nodes[0].node.get_our_node_id()); +// msg.clone() +// } else { panic!("Unexpected event"); }; +// let (bs_announcement, bs_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = bs_announce_events[0] { +// (msg.clone(), update_msg.clone().unwrap()) +// } else { panic!("Unexpected event"); }; + +// nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); +// let as_announce_events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_announce_events.len(), 1); +// let (announcement, as_update) = if let MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } = as_announce_events[0] { +// (msg.clone(), update_msg.clone().unwrap()) +// } else { panic!("Unexpected event"); }; +// assert_eq!(announcement, bs_announcement); + +// for (i, node) in nodes.iter().enumerate() { +// let counterparty_node_id = nodes[(i + 1) % 2].node.get_our_node_id(); +// assert!(node.gossip_sync.handle_channel_announcement(Some(counterparty_node_id), &announcement).unwrap()); +// node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &as_update).unwrap(); +// node.gossip_sync.handle_channel_update(Some(counterparty_node_id), &bs_update).unwrap(); +// } +// } +// #[test] +// fn test_1_conf_open() { +// do_test_1_conf_open(ConnectStyle::BestBlockFirst); +// do_test_1_conf_open(ConnectStyle::TransactionsFirst); +// do_test_1_conf_open(ConnectStyle::FullBlockViaListen); +// } + +// #[test] +// fn test_routed_scid_alias() { +// // Trivially test sending a payment which is routed through an SCID alias. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut no_announce_cfg = test_default_channel_config(); +// no_announce_cfg.accept_forwards_to_priv_channels = true; +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(no_announce_cfg), None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000).2; +// let mut as_channel_ready = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 500_000_000).0; + +// let last_hop = nodes[2].node.list_usable_channels(); +// let hop_hints = vec![RouteHint(vec![RouteHintHop { +// src_node_id: nodes[1].node.get_our_node_id(), +// short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), +// fees: RoutingFees { +// base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, +// proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, +// }, +// cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, +// htlc_maximum_msat: None, +// htlc_minimum_msat: None, +// }])]; +// let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() +// .with_route_hints(hop_hints).unwrap(); +// let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); +// assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); +// nodes[0].node.send_payment_with_route(route, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); + +// as_channel_ready.short_channel_id_alias = Some(0xeadbeef); +// nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); +// // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason +// // to bother updating that code, so just drop the message here. +// get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + +// claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); + +// // Now test that if a peer sends us a second channel_ready after the channel is operational we +// // will use the new alias. +// as_channel_ready.short_channel_id_alias = Some(0xdeadbeef); +// nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &as_channel_ready); +// // Note that we always respond to a channel_ready with a channel_update. Not a lot of reason +// // to bother updating that code, so just drop the message here. +// get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); +// let updated_channel_info = nodes[2].node.list_usable_channels(); +// assert_eq!(updated_channel_info.len(), 1); +// assert_eq!(updated_channel_info[0].inbound_scid_alias.unwrap(), 0xdeadbeef); +// // Note that because we never send a duplicate channel_ready we can't send a payment through +// // the 0xdeadbeef SCID alias. +// } + +// #[test] +// fn test_scid_privacy_on_pub_channel() { +// // Tests rejecting the scid_privacy feature for public channels and that we don't ever try to +// // send them. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let mut scid_privacy_cfg = test_default_channel_config(); +// scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = true; +// scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); +// let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// assert!(!open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); // we ignore `negotiate_scid_privacy` on pub channels +// open_channel.common_fields.channel_type.as_mut().unwrap().set_scid_privacy_required(); +// assert_eq!(open_channel.common_fields.channel_flags & 1, 1); // The `announce_channel` bit is set. + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); +// let err = get_err_msg(&nodes[1], &nodes[0].node.get_our_node_id()); +// assert_eq!(err.data, "SCID Alias/Privacy Channel Type cannot be set on a public channel"); +// } + +// #[test] +// fn test_scid_privacy_negotiation() { +// // Tests of the negotiation of SCID alias and falling back to non-SCID-alias if our +// // counterparty doesn't support it. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let mut scid_privacy_cfg = test_default_channel_config(); +// scid_privacy_cfg.channel_handshake_config.announce_for_forwarding = false; +// scid_privacy_cfg.channel_handshake_config.negotiate_scid_privacy = true; +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(scid_privacy_cfg)).unwrap(); + +// let init_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// assert!(init_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); +// assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts + +// // now simulate nodes[1] responding with an Error message, indicating it doesn't understand +// // SCID alias. +// nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &msgs::ErrorMessage { +// channel_id: init_open_channel.common_fields.temporary_channel_id, +// data: "Yo, no SCID aliases, no privacy here!".to_string() +// }); +// assert!(nodes[0].node.list_channels()[0].channel_type.is_none()); // channel_type is none until counterparty accepts + +// let second_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// assert!(!second_open_channel.common_fields.channel_type.as_ref().unwrap().supports_scid_privacy()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &second_open_channel); +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::FundingGenerationReady { .. } => {}, +// _ => panic!("Unexpected event"), +// } + +// assert!(!nodes[0].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); +// assert!(!nodes[1].node.list_channels()[0].channel_type.as_ref().unwrap().supports_scid_privacy()); +// } + +// #[test] +// fn test_inbound_scid_privacy() { +// // Tests accepting channels with the scid_privacy feature and rejecting forwards using the +// // channel's real SCID as required by the channel feature. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut accept_forward_cfg = test_default_channel_config(); +// accept_forward_cfg.accept_forwards_to_priv_channels = true; +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0); + +// let mut no_announce_cfg = test_default_channel_config(); +// no_announce_cfg.channel_handshake_config.announce_for_forwarding = false; +// no_announce_cfg.channel_handshake_config.negotiate_scid_privacy = true; +// nodes[1].node.create_channel(nodes[2].node.get_our_node_id(), 100_000, 10_000, 42, None, Some(no_announce_cfg)).unwrap(); +// let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[2].node.get_our_node_id()); + +// assert!(open_channel.common_fields.channel_type.as_ref().unwrap().requires_scid_privacy()); + +// nodes[2].node.handle_open_channel(nodes[1].node.get_our_node_id(), &open_channel); +// let accept_channel = get_event_msg!(nodes[2], MessageSendEvent::SendAcceptChannel, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_accept_channel(nodes[2].node.get_our_node_id(), &accept_channel); + +// let (temporary_channel_id, tx, _) = create_funding_transaction(&nodes[1], &nodes[2].node.get_our_node_id(), 100_000, 42); +// nodes[1].node.funding_transaction_generated(temporary_channel_id, nodes[2].node.get_our_node_id(), tx.clone()).unwrap(); +// nodes[2].node.handle_funding_created(nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingCreated, nodes[2].node.get_our_node_id())); +// check_added_monitors!(nodes[2], 1); + +// let cs_funding_signed = get_event_msg!(nodes[2], MessageSendEvent::SendFundingSigned, nodes[1].node.get_our_node_id()); +// expect_channel_pending_event(&nodes[2], &nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_funding_signed(nodes[2].node.get_our_node_id(), &cs_funding_signed); +// expect_channel_pending_event(&nodes[1], &nodes[2].node.get_our_node_id()); +// check_added_monitors!(nodes[1], 1); + +// let conf_height = core::cmp::max(nodes[1].best_block_info().1 + 1, nodes[2].best_block_info().1 + 1); +// confirm_transaction_at(&nodes[1], &tx, conf_height); +// connect_blocks(&nodes[1], CHAN_CONFIRM_DEPTH - 1); +// confirm_transaction_at(&nodes[2], &tx, conf_height); +// connect_blocks(&nodes[2], CHAN_CONFIRM_DEPTH - 1); +// let bs_channel_ready = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReady, nodes[2].node.get_our_node_id()); +// nodes[1].node.handle_channel_ready(nodes[2].node.get_our_node_id(), &get_event_msg!(nodes[2], MessageSendEvent::SendChannelReady, nodes[1].node.get_our_node_id())); +// expect_channel_ready_event(&nodes[1], &nodes[2].node.get_our_node_id()); +// let bs_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[2].node.get_our_node_id()); +// nodes[2].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &bs_channel_ready); +// expect_channel_ready_event(&nodes[2], &nodes[1].node.get_our_node_id()); +// let cs_update = get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_channel_update(nodes[2].node.get_our_node_id(), &cs_update); +// nodes[2].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_update); + +// // Now we can pay just fine using the SCID alias nodes[2] gave to nodes[1]... + +// let last_hop = nodes[2].node.list_usable_channels(); +// let mut hop_hints = vec![RouteHint(vec![RouteHintHop { +// src_node_id: nodes[1].node.get_our_node_id(), +// short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), +// fees: RoutingFees { +// base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, +// proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, +// }, +// cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, +// htlc_maximum_msat: None, +// htlc_minimum_msat: None, +// }])]; +// let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() +// .with_route_hints(hop_hints.clone()).unwrap(); +// let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 100_000); +// assert_eq!(route.paths[0].hops[1].short_channel_id, last_hop[0].inbound_scid_alias.unwrap()); +// nodes[0].node.send_payment_with_route(route, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], 100_000, payment_hash, payment_secret); +// claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); + +// // ... but if we try to pay using the real SCID, nodes[1] will just tell us they don't know +// // what channel we're talking about. +// hop_hints[0].0[0].short_channel_id = last_hop[0].short_channel_id.unwrap(); + +// let payment_params_2 = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() +// .with_route_hints(hop_hints).unwrap(); +// let (route_2, payment_hash_2, _, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params_2, 100_000); +// assert_eq!(route_2.paths[0].hops[1].short_channel_id, last_hop[0].short_channel_id.unwrap()); +// nodes[0].node.send_payment_with_route(route_2, payment_hash_2, +// RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let payment_event = SendEvent::from_node(&nodes[0]); +// assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id); +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &payment_event.msgs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, true, true); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_htlc_handling_failed_destinations!( +// nodes[1].node.get_and_clear_pending_events(), +// &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: last_hop[0].channel_id }] +// ); +// check_added_monitors(&nodes[1], 1); + +// nodes[1].logger.assert_log_regex("lightning::ln::channelmanager", +// regex::Regex::new(r"Failed to accept/forward incoming HTLC: RealSCIDForward").unwrap(), 1); + +// let mut updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false); + +// expect_payment_failed_conditions(&nodes[0], payment_hash_2, false, +// PaymentFailedConditions::new().blamed_scid(last_hop[0].short_channel_id.unwrap()) +// .blamed_chan_closed(true).expected_htlc_error_data(LocalHTLCFailureReason::UnknownNextPeer, &[0; 0])); +// } + +// #[test] +// fn test_scid_alias_returned() { +// // Tests that when we fail an HTLC (in this case due to attempting to forward more than the +// // channel's available balance) we use the correct (in this case the aliased) SCID in the +// // channel_update which is returned in the onion to the sender. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut accept_forward_cfg = test_default_channel_config(); +// accept_forward_cfg.accept_forwards_to_priv_channels = true; +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(accept_forward_cfg), None]); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 0); +// let chan = create_unannounced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000, 0); + +// let last_hop = nodes[2].node.list_usable_channels(); +// let mut hop_hints = vec![RouteHint(vec![RouteHintHop { +// src_node_id: nodes[1].node.get_our_node_id(), +// short_channel_id: last_hop[0].inbound_scid_alias.unwrap(), +// fees: RoutingFees { +// base_msat: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_base_msat, +// proportional_millionths: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().fee_proportional_millionths, +// }, +// cltv_expiry_delta: last_hop[0].counterparty.forwarding_info.as_ref().unwrap().cltv_expiry_delta, +// htlc_maximum_msat: None, +// htlc_minimum_msat: None, +// }])]; +// let payment_params = PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), 42) +// .with_bolt11_features(nodes[2].node.bolt11_invoice_features()).unwrap() +// .with_route_hints(hop_hints).unwrap(); +// let (mut route, payment_hash, _, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], payment_params, 10_000); +// assert_eq!(route.paths[0].hops[1].short_channel_id, nodes[2].node.list_usable_channels()[0].inbound_scid_alias.unwrap()); + +// route.paths[0].hops[1].fee_msat = 10_000_000; // Overshoot the last channel's value + +// // Route the HTLC through to the destination. +// nodes[0].node.send_payment_with_route(route.clone(), payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], vec![HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }]); +// check_added_monitors!(nodes[1], 1); + +// let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); + +// let err_data = 0u16.to_be_bytes(); +// expect_payment_failed_conditions(&nodes[0], payment_hash, false, +// PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) +// .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::TemporaryChannelFailure, &err_data)); + +// route.paths[0].hops[1].fee_msat = 10_000; // Reset to the correct payment amount +// route.paths[0].hops[0].fee_msat = 0; // But set fee paid to the middle hop to 0 + +// // Route the HTLC through to the destination. +// nodes[0].node.send_payment_with_route(route, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]); +// commitment_signed_dance!(nodes[1], nodes[0], &as_updates.commitment_signed, false, true); + +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_htlc_handling_failed_destinations!( +// nodes[1].node.get_and_clear_pending_events(), +// &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan.0.channel_id }] +// ); +// check_added_monitors(&nodes[1], 1); + +// let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true); + +// let mut err_data = Vec::new(); +// err_data.extend_from_slice(&10_000u64.to_be_bytes()); +// err_data.extend_from_slice(&0u16.to_be_bytes()); +// expect_payment_failed_conditions(&nodes[0], payment_hash, false, +// PaymentFailedConditions::new().blamed_scid(last_hop[0].inbound_scid_alias.unwrap()) +// .blamed_chan_closed(false).expected_htlc_error_data(LocalHTLCFailureReason::FeeInsufficient, &err_data)); +// } + +// #[test] +// fn test_simple_0conf_channel() { +// // If our peer tells us they will accept our channel with 0 confs, and we funded the channel, +// // we should trust the funding won't be double-spent (assuming `trust_own_funding_0conf` is +// // set)! +// // Further, if we `accept_inbound_channel_from_trusted_peer_0conf`, `channel_ready` messages +// // should fly immediately and the channel should be available for use as soon as they are +// // received. + +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// open_zero_conf_channel(&nodes[0], &nodes[1], None); + +// send_payment(&nodes[0], &[&nodes[1]], 100_000); +// } + +// #[test] +// fn test_0conf_channel_with_async_monitor() { +// // Test that we properly send out channel_ready in (both inbound- and outbound-) zero-conf +// // channels if ChannelMonitor updates return a `TemporaryFailure` during the initial channel +// // negotiation. + +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(chan_config.clone()), None]); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0); + +// chan_config.channel_handshake_config.announce_for_forwarding = false; +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, Some(chan_config)).unwrap(); +// let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); +// }, +// _ => panic!("Unexpected event"), +// }; + +// let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); +// assert_eq!(accept_channel.common_fields.minimum_depth, 0); +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + +// let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], &nodes[1].node.get_our_node_id(), 100000, 42); +// nodes[0].node.funding_transaction_generated(temporary_channel_id, nodes[1].node.get_our_node_id(), tx.clone()).unwrap(); +// let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_funding_created(nodes[0].node.get_our_node_id(), &funding_created); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// let channel_id = ChannelId::v1_from_funding_outpoint(funding_output); +// nodes[1].chain_monitor.complete_sole_pending_chan_update(&channel_id); +// expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id()); + +// let bs_signed_locked = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_signed_locked.len(), 2); +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); + +// match &bs_signed_locked[0] { +// MessageSendEvent::SendFundingSigned { node_id, msg } => { +// assert_eq!(*node_id, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_funding_signed(nodes[1].node.get_our_node_id(), &msg); +// check_added_monitors!(nodes[0], 1); +// } +// _ => panic!("Unexpected event"), +// } +// match &bs_signed_locked[1] { +// MessageSendEvent::SendChannelReady { node_id, msg } => { +// assert_eq!(*node_id, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_channel_ready(nodes[1].node.get_our_node_id(), &msg); +// } +// _ => panic!("Unexpected event"), +// } + +// assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// nodes[0].chain_monitor.complete_sole_pending_chan_update(&channel_id); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// crate::events::Event::ChannelPending { ref counterparty_node_id, .. } => { +// assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); +// }, +// _ => panic!("Unexpected event"), +// } +// match events[1] { +// crate::events::Event::ChannelReady { ref counterparty_node_id, .. } => { +// assert_eq!(nodes[1].node.get_our_node_id(), *counterparty_node_id); +// }, +// _ => panic!("Unexpected event"), +// } + +// let as_locked_update = nodes[0].node.get_and_clear_pending_msg_events(); + +// // Note that the funding transaction is actually released when +// // get_and_clear_pending_msg_events, above, checks for monitor events. +// assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0)[0], tx); + +// match &as_locked_update[0] { +// MessageSendEvent::SendChannelReady { node_id, msg } => { +// assert_eq!(*node_id, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_channel_ready(nodes[0].node.get_our_node_id(), &msg); +// } +// _ => panic!("Unexpected event"), +// } +// expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id()); + +// let bs_channel_update = get_event_msg!(nodes[1], MessageSendEvent::SendChannelUpdate, nodes[0].node.get_our_node_id()); + +// let as_channel_update = match &as_locked_update[1] { +// MessageSendEvent::SendChannelUpdate { node_id, msg } => { +// assert_eq!(*node_id, nodes[1].node.get_our_node_id()); +// msg.clone() +// } +// _ => panic!("Unexpected event"), +// }; + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); + +// nodes[0].node.handle_channel_update(nodes[1].node.get_our_node_id(), &bs_channel_update); +// nodes[1].node.handle_channel_update(nodes[0].node.get_our_node_id(), &as_channel_update); + +// assert_eq!(nodes[0].node.list_usable_channels().len(), 1); +// assert_eq!(nodes[1].node.list_usable_channels().len(), 2); + +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// // Now that we have useful channels, try sending a payment where the we hit a temporary monitor +// // failure before we've ever confirmed the funding transaction. This previously caused a panic. +// let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000); + +// nodes[0].node.send_payment_with_route(route, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap(); +// check_added_monitors!(nodes[0], 1); + +// let as_send = SendEvent::from_node(&nodes[0]); +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &as_send.msgs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &as_send.commitment_msg); +// check_added_monitors!(nodes[1], 1); + +// let (bs_raa, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); +// check_added_monitors!(nodes[0], 1); + +// nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_commitment_signed); +// check_added_monitors!(nodes[0], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id())); +// check_added_monitors!(nodes[1], 1); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::Completed); +// let (_, latest_update) = nodes[1].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&bs_raa.channel_id).unwrap().clone(); +// nodes[1].chain_monitor.chain_monitor.channel_monitor_updated(bs_raa.channel_id, latest_update).unwrap(); +// check_added_monitors!(nodes[1], 0); +// expect_pending_htlcs_forwardable!(nodes[1]); +// check_added_monitors!(nodes[1], 1); + +// let bs_send = SendEvent::from_node(&nodes[1]); +// nodes[2].node.handle_update_add_htlc(nodes[1].node.get_our_node_id(), &bs_send.msgs[0]); +// commitment_signed_dance!(nodes[2], nodes[1], bs_send.commitment_msg, false); +// expect_pending_htlcs_forwardable!(nodes[2]); +// expect_payment_claimable!(nodes[2], payment_hash, payment_secret, 1_000_000); +// claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage); + +// confirm_transaction(&nodes[0], &tx); +// confirm_transaction(&nodes[1], &tx); + +// send_payment(&nodes[0], &[&nodes[1]], 100_000); +// } + +// #[test] +// fn test_0conf_close_no_early_chan_update() { +// // Tests that even with a public channel 0conf channel, we don't generate a channel_update on +// // closing. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let error_message = "Channel force-closed"; + +// // This is the default but we force it on anyway +// chan_config.channel_handshake_config.announce_for_forwarding = true; +// open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); + +// // We can use the channel immediately, but won't generate a channel_update until we get confs +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// nodes[0].node.force_close_all_channels_broadcasting_latest_txn(error_message.to_string()); +// check_added_monitors!(nodes[0], 1); +// check_closed_event!(&nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[1].node.get_our_node_id()], 100000); +// let _ = get_err_msg(&nodes[0], &nodes[1].node.get_our_node_id()); +// } + +// #[test] +// fn test_public_0conf_channel() { +// // Tests that we will announce a public channel (after confirmation) even if its 0conf. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // This is the default but we force it on anyway +// chan_config.channel_handshake_config.announce_for_forwarding = true; +// let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); + +// // We can use the channel immediately, but we can't announce it until we get 6+ confirmations +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// let scid = confirm_transaction(&nodes[0], &tx); +// let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); +// assert_eq!(confirm_transaction(&nodes[1], &tx), scid); +// let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); + +// nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); +// nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); + +// let bs_announcement = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(bs_announcement.len(), 1); +// let announcement; +// let bs_update; +// match bs_announcement[0] { +// MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { +// announcement = msg.clone(); +// bs_update = update_msg.clone().unwrap(); +// }, +// _ => panic!("Unexpected event"), +// }; + +// let as_announcement = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_announcement.len(), 1); +// match as_announcement[0] { +// MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { +// assert!(announcement == *msg); +// let update_msg = update_msg.as_ref().unwrap(); +// assert_eq!(update_msg.contents.short_channel_id, scid); +// assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id); +// assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id); +// }, +// _ => panic!("Unexpected event"), +// }; +// } + +// #[test] +// fn test_0conf_channel_reorg() { +// // If we accept a 0conf channel, which is then confirmed, but then changes SCID in a reorg, we +// // have to make sure we handle this correctly (or, currently, just force-close the channel). + +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // This is the default but we force it on anyway +// chan_config.channel_handshake_config.announce_for_forwarding = true; +// let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); + +// // We can use the channel immediately, but we can't announce it until we get 6+ confirmations +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// mine_transaction(&nodes[0], &tx); +// mine_transaction(&nodes[1], &tx); + +// // Send a payment using the channel's real SCID, which will be public in a few blocks once we +// // can generate a channel_announcement. +// let real_scid = nodes[0].node.list_usable_channels()[0].short_channel_id.unwrap(); +// assert_eq!(nodes[1].node.list_usable_channels()[0].short_channel_id.unwrap(), real_scid); + +// let (mut route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 10_000); +// assert_eq!(route.paths[0].hops[0].short_channel_id, real_scid); +// send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1]]], 10_000, payment_hash, payment_secret); +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); + +// disconnect_blocks(&nodes[0], 1); +// disconnect_blocks(&nodes[1], 1); + +// // At this point the channel no longer has an SCID again. In the future we should likely +// // support simply un-setting the SCID and waiting until the channel gets re-confirmed, but for +// // now we force-close the channel here. +// check_closed_event!(&nodes[0], 1, ClosureReason::ProcessingError { +// err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() +// }, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_broadcast!(nodes[0], true); +// check_added_monitors(&nodes[0], 1); +// check_closed_event!(&nodes[1], 1, ClosureReason::ProcessingError { +// err: "Funding transaction was un-confirmed. Locked at 0 confs, now have 0 confs.".to_owned() +// }, [nodes[0].node.get_our_node_id()], 100000); +// check_closed_broadcast!(nodes[1], true); +// check_added_monitors(&nodes[1], 1); +// } + +// #[test] +// fn test_zero_conf_accept_reject() { +// let mut channel_type_features = ChannelTypeFeatures::only_static_remote_key(); +// channel_type_features.set_zero_conf_required(); + +// // 1. Check we reject zero conf channels by default +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); +// let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// match msg_events[0] { +// MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { +// assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); +// }, +// _ => panic!(), +// } + +// // 2. Check we can manually accept zero conf channels via the right method +// let mut manually_accept_conf = UserConfig::default(); +// manually_accept_conf.manually_accept_inbound_channels = true; + +// 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, Some(manually_accept_conf.clone())]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // 2.1 First try the non-0conf method to manually accept +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, +// None, Some(manually_accept_conf.clone())).unwrap(); +// let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, +// nodes[1].node.get_our_node_id()); + +// open_channel_msg.common_fields.channel_type = Some(channel_type_features.clone()); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + +// // Assert that `nodes[1]` has no `MessageSendEvent::SendAcceptChannel` in the `msg_events`. +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// let events = nodes[1].node.get_and_clear_pending_events(); + +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// // Assert we fail to accept via the non-0conf method +// assert!(nodes[1].node.accept_inbound_channel(&temporary_channel_id, +// &nodes[0].node.get_our_node_id(), 0, None).is_err()); +// }, +// _ => panic!(), +// } + +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// match msg_events[0] { +// MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg, .. }, .. } => { +// assert_eq!(msg.data, "No zero confirmation channels accepted".to_owned()); +// }, +// _ => panic!(), +// } + +// // 2.2 Try again with the 0conf method to manually accept +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, +// None, Some(manually_accept_conf)).unwrap(); +// let mut open_channel_msg = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, +// nodes[1].node.get_our_node_id()); + +// open_channel_msg.common_fields.channel_type = Some(channel_type_features); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel_msg); + +// let events = nodes[1].node.get_and_clear_pending_events(); + +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// // Assert we can accept via the 0conf method +// assert!(nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf( +// &temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).is_ok()); +// }, +// _ => panic!(), +// } + +// // Check we would send accept +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// match msg_events[0] { +// MessageSendEvent::SendAcceptChannel { .. } => {}, +// _ => panic!(), +// } +// } + +// #[test] +// fn test_connect_before_funding() { +// // Tests for a particularly dumb explicit panic that existed prior to 0.0.111 for 0conf +// // channels. If we received a block while awaiting funding for 0-conf channels we'd hit an +// // explicit panic when deciding if we should broadcast our channel_ready message. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + +// let mut manually_accept_conf = test_default_channel_config(); +// manually_accept_conf.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(manually_accept_conf)]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100_000, 10_001, 42, None, None).unwrap(); +// let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); +// let events = nodes[1].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::OpenChannelRequest { temporary_channel_id, .. } => { +// nodes[1].node.accept_inbound_channel_from_trusted_peer_0conf(&temporary_channel_id, &nodes[0].node.get_our_node_id(), 0, None).unwrap(); +// }, +// _ => panic!("Unexpected event"), +// }; + +// let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); +// assert_eq!(accept_channel.common_fields.minimum_depth, 0); +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// Event::FundingGenerationReady { .. } => {}, +// _ => panic!("Unexpected event"), +// } + +// connect_blocks(&nodes[0], 1); +// connect_blocks(&nodes[1], 1); +// } + +// #[test] +// fn test_0conf_ann_sigs_racing_conf() { +// // Previously we had a bug where we'd panic when receiving a counterparty's +// // announcement_signatures message for a 0conf channel pending confirmation on-chain. Here we +// // check that we just error out, ignore the announcement_signatures message, and proceed +// // instead. +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// let mut chan_config = test_default_channel_config(); +// chan_config.manually_accept_inbound_channels = true; + +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(chan_config.clone())]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // This is the default but we force it on anyway +// chan_config.channel_handshake_config.announce_for_forwarding = true; +// let (tx, ..) = open_zero_conf_channel(&nodes[0], &nodes[1], Some(chan_config)); + +// // We can use the channel immediately, but we can't announce it until we get 6+ confirmations +// send_payment(&nodes[0], &[&nodes[1]], 100_000); + +// let scid = confirm_transaction(&nodes[0], &tx); +// let as_announcement_sigs = get_event_msg!(nodes[0], MessageSendEvent::SendAnnouncementSignatures, nodes[1].node.get_our_node_id()); + +// // Handling the announcement_signatures prior to the first confirmation would panic before. +// nodes[1].node.handle_announcement_signatures(nodes[0].node.get_our_node_id(), &as_announcement_sigs); + +// assert_eq!(confirm_transaction(&nodes[1], &tx), scid); +// let bs_announcement_sigs = get_event_msg!(nodes[1], MessageSendEvent::SendAnnouncementSignatures, nodes[0].node.get_our_node_id()); + +// nodes[0].node.handle_announcement_signatures(nodes[1].node.get_our_node_id(), &bs_announcement_sigs); +// let as_announcement = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_announcement.len(), 1); +// } diff --git a/lightning/src/ln/quiescence_tests.rs b/lightning/src/ln/quiescence_tests.rs index 82aa0208c67..458d049dcce 100644 --- a/lightning/src/ln/quiescence_tests.rs +++ b/lightning/src/ln/quiescence_tests.rs @@ -1,543 +1,543 @@ -use crate::chain::ChannelMonitorUpdateStatus; -use crate::events::{Event, HTLCHandlingFailureType}; -use crate::ln::channel::DISCONNECT_PEER_AWAITING_RESPONSE_TICKS; -use crate::ln::channelmanager::PaymentId; -use crate::ln::channelmanager::RecipientOnionFields; -use crate::ln::functional_test_utils::*; -use crate::ln::msgs; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent}; -use crate::util::errors::APIError; -use crate::util::test_channel_signer::SignerOp; - -#[test] -fn test_quiescence_tie() { - // Test that both nodes proposing quiescence at the same time results in the channel funder - // becoming the quiescence initiator. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); - nodes[1].node.maybe_propose_quiescence(&nodes[0].node.get_our_node_id(), &chan_id).unwrap(); - - let stfu_node_0 = - get_event_msg!(nodes[0], MessageSendEvent::SendStfu, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_stfu(nodes[0].node.get_our_node_id(), &stfu_node_0); - - let stfu_node_1 = - get_event_msg!(nodes[1], MessageSendEvent::SendStfu, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_stfu(nodes[1].node.get_our_node_id(), &stfu_node_1); - - assert!(stfu_node_0.initiator && stfu_node_1.initiator); - - assert!(nodes[0].node.exit_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap()); - assert!(!nodes[1].node.exit_quiescence(&nodes[0].node.get_our_node_id(), &chan_id).unwrap()); -} - -#[test] -fn test_quiescence_shutdown_ignored() { - // Test that a shutdown sent/received during quiescence is ignored. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); - let _ = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, nodes[1].node.get_our_node_id()); - - if let Err(e) = nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()) { - assert_eq!( - e, - APIError::APIMisuseError { err: "Cannot begin shutdown while quiescent".to_owned() } - ); - } else { - panic!("Expected shutdown to be ignored while quiescent"); - } - - nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap(); - let shutdown = - get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &shutdown); - let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); - match msg_events[0] { - MessageSendEvent::HandleError { - action: ErrorAction::DisconnectPeerWithWarning { ref msg, .. }, - .. - } => { - assert_eq!(msg.data, "Got shutdown request while quiescent".to_owned()); - }, - _ => panic!(), - } -} - -#[test] -fn test_allow_shutdown_while_awaiting_quiescence() { - allow_shutdown_while_awaiting_quiescence(false); - allow_shutdown_while_awaiting_quiescence(true); -} - -fn allow_shutdown_while_awaiting_quiescence(local_shutdown: bool) { - // Test that a shutdown sent/received while we're still awaiting quiescence (stfu has not been - // sent yet) is honored and the channel is closed cooperatively. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let local_node = &nodes[0]; - let remote_node = &nodes[1]; - let local_node_id = local_node.node.get_our_node_id(); - let remote_node_id = remote_node.node.get_our_node_id(); - - let payment_amount = 1_000_000; - let (route, payment_hash, _, payment_secret) = - get_route_and_payment_hash!(local_node, remote_node, payment_amount); - let onion = RecipientOnionFields::secret_only(payment_secret); - let payment_id = PaymentId(payment_hash.0); - local_node.node.send_payment_with_route(route, payment_hash, onion, payment_id).unwrap(); - check_added_monitors!(local_node, 1); - - // Attempt to send an HTLC, but don't fully commit it yet. - let update_add = get_htlc_update_msgs!(local_node, remote_node_id); - remote_node.node.handle_update_add_htlc(local_node_id, &update_add.update_add_htlcs[0]); - remote_node - .node - .handle_commitment_signed_batch_test(local_node_id, &update_add.commitment_signed); - let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(remote_node, local_node_id); - local_node.node.handle_revoke_and_ack(remote_node_id, &revoke_and_ack); - check_added_monitors(local_node, 1); - - // Request the local node to propose quiescence, and immediately try to close the channel. Since - // we haven't sent `stfu` yet as the state machine is pending, we should forget about our - // quiescence attempt. - local_node.node.maybe_propose_quiescence(&remote_node_id, &chan_id).unwrap(); - assert!(local_node.node.get_and_clear_pending_msg_events().is_empty()); - - let (closer_node, closee_node) = - if local_shutdown { (local_node, remote_node) } else { (remote_node, local_node) }; - let closer_node_id = closer_node.node.get_our_node_id(); - let closee_node_id = closee_node.node.get_our_node_id(); - - closer_node.node.close_channel(&chan_id, &closee_node_id).unwrap(); - check_added_monitors(&remote_node, 1); - let shutdown_initiator = - get_event_msg!(closer_node, MessageSendEvent::SendShutdown, closee_node_id); - closee_node.node.handle_shutdown(closer_node_id, &shutdown_initiator); - let shutdown_responder = - get_event_msg!(closee_node, MessageSendEvent::SendShutdown, closer_node_id); - closer_node.node.handle_shutdown(closee_node_id, &shutdown_responder); - - // Continue exchanging messages until the HTLC is irrevocably committed and eventually failed - // back as we are shutting down. - local_node.node.handle_commitment_signed_batch_test(remote_node_id, &commit_sig); - check_added_monitors(local_node, 1); - - let last_revoke_and_ack = - get_event_msg!(local_node, MessageSendEvent::SendRevokeAndACK, remote_node_id); - remote_node.node.handle_revoke_and_ack(local_node_id, &last_revoke_and_ack); - check_added_monitors(remote_node, 1); - expect_pending_htlcs_forwardable!(remote_node); - expect_htlc_handling_failed_destinations!( - remote_node.node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Receive { payment_hash }] - ); - check_added_monitors(remote_node, 1); - - let update_fail = get_htlc_update_msgs!(remote_node, local_node_id); - local_node.node.handle_update_fail_htlc(remote_node_id, &update_fail.update_fail_htlcs[0]); - local_node - .node - .handle_commitment_signed_batch_test(remote_node_id, &update_fail.commitment_signed); - - let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(local_node, remote_node_id); - remote_node.node.handle_revoke_and_ack(local_node_id, &revoke_and_ack); - check_added_monitors(remote_node, 1); - remote_node.node.handle_commitment_signed_batch_test(local_node_id, &commit_sig); - check_added_monitors(remote_node, 1); - - let last_revoke_and_ack = - get_event_msg!(remote_node, MessageSendEvent::SendRevokeAndACK, local_node_id); - local_node.node.handle_revoke_and_ack(remote_node_id, &last_revoke_and_ack); - - expect_payment_failed_conditions( - local_node, - payment_hash, - true, - PaymentFailedConditions::new(), - ); - - // Now that the state machine is no longer pending, and `closing_signed` is ready to be sent, - // make sure we're still not waiting for the quiescence handshake to complete. - local_node.node.exit_quiescence(&remote_node_id, &chan_id).unwrap(); - - let _ = get_event_msg!(local_node, MessageSendEvent::SendClosingSigned, remote_node_id); - check_added_monitors(local_node, 2); // One for the last revoke_and_ack, another for closing_signed -} - -#[test] -fn test_quiescence_waits_for_async_signer_and_monitor_update() { - // Test that quiescence: - // a) considers an async signer when determining whether a pending channel update exists - // b) waits until pending monitor updates complete to send `stfu`/become quiescent - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - let payment_amount = 1_000_000; - let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], payment_amount); - nodes[1].node.claim_funds(preimage); - check_added_monitors(&nodes[1], 1); - - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); - check_added_monitors(&nodes[0], 1); - - // While settling back the payment, propose quiescence from nodes[1]. We won't see its `stfu` go - // out yet as the `update_fulfill` is still pending on both sides. - nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); - - // Disable releasing commitment secrets on nodes[1], to hold back their `stfu` until the - // `revoke_and_ack` goes out, and drive the state machine forward. - nodes[1].disable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); - - let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(&nodes[0], node_id_1); - nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); - check_added_monitors(&nodes[1], 1); - nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &commit_sig); - check_added_monitors(&nodes[1], 1); - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Resume the signer. We should now expect to see both messages. - nodes[1].enable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); - nodes[1].node.signer_unblocked(Some((node_id_0, chan_id))); - - expect_payment_claimed!(&nodes[1], payment_hash, payment_amount); - - macro_rules! find_msg { - ($events: expr, $msg: ident) => {{ - $events - .iter() - .find_map(|event| { - if let MessageSendEvent::$msg { ref msg, .. } = event { - Some(msg) - } else { - None - } - }) - .unwrap() - }}; - } - let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(msg_events.len(), 2); - let revoke_and_ack = find_msg!(msg_events, SendRevokeAndACK); - let stfu = find_msg!(msg_events, SendStfu); - - // While handling the last `revoke_and_ack` on nodes[0], we'll hold the monitor update. We - // cannot become quiescent until it completes. - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_revoke_and_ack(node_id_1, &revoke_and_ack); - - nodes[0].node.handle_stfu(node_id_1, &stfu); - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - // We have two updates pending: - { - let chain_monitor = &nodes[0].chain_monitor; - let (_, latest_update) = - chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); - let chain_monitor = &nodes[0].chain_monitor.chain_monitor; - // One for the latest commitment transaction update from the last `revoke_and_ack` - chain_monitor.channel_monitor_updated(chan_id, latest_update).unwrap(); - expect_payment_sent(&nodes[0], preimage, None, true, true); - // One for the commitment secret update from the last `revoke_and_ack` - chain_monitor.channel_monitor_updated(chan_id, latest_update + 1).unwrap(); - } - - // With the updates completed, we can now become quiescent. - let stfu = get_event_msg!(&nodes[0], MessageSendEvent::SendStfu, node_id_1); - nodes[1].node.handle_stfu(node_id_0, &stfu); - - nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); - nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); - - // After exiting quiescence, we should be able to resume payments from nodes[0]. - send_payment(&nodes[0], &[&nodes[1]], payment_amount); -} - -#[test] -fn test_quiescence_on_final_revoke_and_ack_pending_monitor_update() { - // Test that we do not let a pending monitor update for a final `revoke_and_ack` prevent us from - // entering quiescence. This was caught by the fuzzer, reported as #3805. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - let payment_amount = 1_000_000; - let (route, payment_hash, _, payment_secret) = - get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); - let onion = RecipientOnionFields::secret_only(payment_secret); - let payment_id = PaymentId(payment_hash.0); - nodes[0].node.send_payment_with_route(route, payment_hash, onion, payment_id).unwrap(); - check_added_monitors(&nodes[0], 1); - - nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); - let stfu = get_event_msg!(&nodes[1], MessageSendEvent::SendStfu, node_id_0); - nodes[0].node.handle_stfu(node_id_1, &stfu); - - let update_add = get_htlc_update_msgs!(&nodes[0], node_id_1); - nodes[1].node.handle_update_add_htlc(node_id_0, &update_add.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &update_add.commitment_signed); - check_added_monitors(&nodes[1], 1); - - let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(&nodes[1], node_id_0); - nodes[0].node.handle_revoke_and_ack(node_id_1, &revoke_and_ack); - check_added_monitors(&nodes[0], 1); - nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &commit_sig); - check_added_monitors(&nodes[0], 1); - - chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - let msgs = nodes[0].node.get_and_clear_pending_msg_events(); - if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &msgs[0] { - nodes[1].node.handle_revoke_and_ack(node_id_0, &msg); - check_added_monitors(&nodes[1], 1); - } else { - panic!(); - } - if let MessageSendEvent::SendStfu { msg, .. } = &msgs[1] { - nodes[1].node.handle_stfu(node_id_0, &msg); - } else { - panic!(); - } - - nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); - nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); -} - -#[test] -fn test_quiescence_updates_go_to_holding_cell() { - quiescence_updates_go_to_holding_cell(false); - quiescence_updates_go_to_holding_cell(true); -} - -fn quiescence_updates_go_to_holding_cell(fail_htlc: bool) { - // Test that any updates made to a channel while quiescent go to the holding cell. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - // Send enough to be able to pay from both directions. - let payment_amount = 1_000_000; - send_payment(&nodes[0], &[&nodes[1]], payment_amount * 4); - - // Propose quiescence from nodes[1], and immediately try to send a payment. Since its `stfu` has - // already gone out first, the outbound HTLC will go into the holding cell. - nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); - let stfu = get_event_msg!(&nodes[1], MessageSendEvent::SendStfu, node_id_0); - - let (route1, payment_hash1, payment_preimage1, payment_secret1) = - get_route_and_payment_hash!(&nodes[1], &nodes[0], payment_amount); - let onion1 = RecipientOnionFields::secret_only(payment_secret1); - let payment_id1 = PaymentId(payment_hash1.0); - nodes[1].node.send_payment_with_route(route1, payment_hash1, onion1, payment_id1).unwrap(); - check_added_monitors!(&nodes[1], 0); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Send a payment in the opposite direction. Since nodes[0] hasn't sent its own `stfu` yet, it's - // allowed to make updates. - let (route2, payment_hash2, payment_preimage2, payment_secret2) = - get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); - let onion2 = RecipientOnionFields::secret_only(payment_secret2); - let payment_id2 = PaymentId(payment_hash2.0); - nodes[0].node.send_payment_with_route(route2, payment_hash2, onion2, payment_id2).unwrap(); - check_added_monitors!(&nodes[0], 1); - - let update_add = get_htlc_update_msgs!(&nodes[0], node_id_1); - nodes[1].node.handle_update_add_htlc(node_id_0, &update_add.update_add_htlcs[0]); - commitment_signed_dance!(&nodes[1], &nodes[0], update_add.commitment_signed, false); - expect_pending_htlcs_forwardable!(&nodes[1]); - expect_payment_claimable!(nodes[1], payment_hash2, payment_secret2, payment_amount); - - // Have nodes[1] attempt to fail/claim nodes[0]'s payment. Since nodes[1] already sent out - // `stfu`, the `update_fail/fulfill` will go into the holding cell. - if fail_htlc { - nodes[1].node.fail_htlc_backwards(&payment_hash2); - let failed_payment = HTLCHandlingFailureType::Receive { payment_hash: payment_hash2 }; - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(&nodes[1], vec![failed_payment]); - } else { - nodes[1].node.claim_funds(payment_preimage2); - check_added_monitors(&nodes[1], 1); - } - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Finish the quiescence handshake. - nodes[0].node.handle_stfu(node_id_1, &stfu); - let stfu = get_event_msg!(&nodes[0], MessageSendEvent::SendStfu, node_id_1); - nodes[1].node.handle_stfu(node_id_0, &stfu); - - nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); - nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); - - // Now that quiescence is over, nodes are allowed to make updates again. nodes[1] will have its - // outbound HTLC finally go out, along with the fail/claim of nodes[0]'s payment. - let update = get_htlc_update_msgs!(&nodes[1], node_id_0); - check_added_monitors(&nodes[1], 1); - nodes[0].node.handle_update_add_htlc(node_id_1, &update.update_add_htlcs[0]); - if fail_htlc { - nodes[0].node.handle_update_fail_htlc(node_id_1, &update.update_fail_htlcs[0]); - } else { - nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); - } - commitment_signed_dance!(&nodes[0], &nodes[1], update.commitment_signed, false); - - if !fail_htlc { - expect_payment_claimed!(nodes[1], payment_hash2, payment_amount); - } - - // The payment from nodes[0] should now be seen as failed/successful. - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 3); - assert!(events.iter().find(|e| matches!(e, Event::PendingHTLCsForwardable { .. })).is_some()); - if fail_htlc { - assert!(events.iter().find(|e| matches!(e, Event::PaymentFailed { .. })).is_some()); - assert!(events.iter().find(|e| matches!(e, Event::PaymentPathFailed { .. })).is_some()); - } else { - assert!(events.iter().find(|e| matches!(e, Event::PaymentSent { .. })).is_some()); - assert!(events.iter().find(|e| matches!(e, Event::PaymentPathSuccessful { .. })).is_some()); - check_added_monitors(&nodes[0], 1); - } - nodes[0].node.process_pending_htlc_forwards(); - expect_payment_claimable!(nodes[0], payment_hash1, payment_secret1, payment_amount); - - // Have nodes[0] fail/claim nodes[1]'s payment. - if fail_htlc { - nodes[0].node.fail_htlc_backwards(&payment_hash1); - let failed_payment = HTLCHandlingFailureType::Receive { payment_hash: payment_hash1 }; - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(&nodes[0], vec![failed_payment]); - } else { - nodes[0].node.claim_funds(payment_preimage1); - } - check_added_monitors(&nodes[0], 1); - - let update = get_htlc_update_msgs!(&nodes[0], node_id_1); - if fail_htlc { - nodes[1].node.handle_update_fail_htlc(node_id_0, &update.update_fail_htlcs[0]); - } else { - nodes[1].node.handle_update_fulfill_htlc(node_id_0, &update.update_fulfill_htlcs[0]); - } - commitment_signed_dance!(&nodes[1], &nodes[0], update.commitment_signed, false); - - // The payment from nodes[1] should now be seen as failed/successful. - if fail_htlc { - let conditions = PaymentFailedConditions::new(); - expect_payment_failed_conditions(&nodes[1], payment_hash1, true, conditions); - } else { - expect_payment_claimed!(nodes[0], payment_hash1, payment_amount); - expect_payment_sent(&nodes[1], payment_preimage1, None, true, true); - } -} - -#[test] -fn test_quiescence_timeout() { - // Test that we'll disconnect if we remain quiescent for `DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - let node_id_1 = nodes[1].node.get_our_node_id(); - - nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); - - let stfu_initiator = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1); - nodes[1].node.handle_stfu(node_id_0, &stfu_initiator); - - let stfu_responder = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); - nodes[0].node.handle_stfu(node_id_1, &stfu_responder); - - assert!(stfu_initiator.initiator && !stfu_responder.initiator); - - for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { - nodes[0].node.timer_tick_occurred(); - nodes[1].node.timer_tick_occurred(); - } - - let f = |event| { - if let MessageSendEvent::HandleError { action, .. } = event { - if let msgs::ErrorAction::DisconnectPeerWithWarning { .. } = action { - Some(()) - } else { - None - } - } else { - None - } - }; - assert!(nodes[0].node.get_and_clear_pending_msg_events().into_iter().find_map(f).is_some()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().into_iter().find_map(f).is_some()); -} - -#[test] -fn test_quiescence_timeout_while_waiting_for_counterparty_stfu() { - // Test that we'll disconnect if the counterparty does not send their stfu within a reasonable - // time if we've already sent ours. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - let node_id_0 = nodes[0].node.get_our_node_id(); - - nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); - let _ = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); - - // Route a payment in between to ensure expecting to receive `revoke_and_ack` doesn't override - // the expectation of receiving `stfu` as well. - let _ = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); - - for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { - nodes[0].node.timer_tick_occurred(); - nodes[1].node.timer_tick_occurred(); - } - - // nodes[0] hasn't received stfu from nodes[1], so it's not enforcing any timeouts. - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - // nodes[1] didn't receive nodes[0]'s stfu within the timeout so it'll disconnect. - let f = |&ref event| { - if let MessageSendEvent::HandleError { action, .. } = event { - if let msgs::ErrorAction::DisconnectPeerWithWarning { .. } = action { - Some(()) - } else { - None - } - } else { - None - } - }; - assert!(nodes[1].node.get_and_clear_pending_msg_events().iter().find_map(f).is_some()); -} +// use crate::chain::ChannelMonitorUpdateStatus; +// use crate::events::{Event, HTLCHandlingFailureType}; +// use crate::ln::channel::DISCONNECT_PEER_AWAITING_RESPONSE_TICKS; +// use crate::ln::channelmanager::PaymentId; +// use crate::ln::channelmanager::RecipientOnionFields; +// use crate::ln::functional_test_utils::*; +// use crate::ln::msgs; +// use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent}; +// use crate::util::errors::APIError; +// use crate::util::test_channel_signer::SignerOp; + +// #[test] +// fn test_quiescence_tie() { +// // Test that both nodes proposing quiescence at the same time results in the channel funder +// // becoming the quiescence initiator. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); +// nodes[1].node.maybe_propose_quiescence(&nodes[0].node.get_our_node_id(), &chan_id).unwrap(); + +// let stfu_node_0 = +// get_event_msg!(nodes[0], MessageSendEvent::SendStfu, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_stfu(nodes[0].node.get_our_node_id(), &stfu_node_0); + +// let stfu_node_1 = +// get_event_msg!(nodes[1], MessageSendEvent::SendStfu, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_stfu(nodes[1].node.get_our_node_id(), &stfu_node_1); + +// assert!(stfu_node_0.initiator && stfu_node_1.initiator); + +// assert!(nodes[0].node.exit_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap()); +// assert!(!nodes[1].node.exit_quiescence(&nodes[0].node.get_our_node_id(), &chan_id).unwrap()); +// } + +// #[test] +// fn test_quiescence_shutdown_ignored() { +// // Test that a shutdown sent/received during quiescence is ignored. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); +// let _ = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, nodes[1].node.get_our_node_id()); + +// if let Err(e) = nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()) { +// assert_eq!( +// e, +// APIError::APIMisuseError { err: "Cannot begin shutdown while quiescent".to_owned() } +// ); +// } else { +// panic!("Expected shutdown to be ignored while quiescent"); +// } + +// nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap(); +// let shutdown = +// get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &shutdown); +// let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); +// match msg_events[0] { +// MessageSendEvent::HandleError { +// action: ErrorAction::DisconnectPeerWithWarning { ref msg, .. }, +// .. +// } => { +// assert_eq!(msg.data, "Got shutdown request while quiescent".to_owned()); +// }, +// _ => panic!(), +// } +// } + +// #[test] +// fn test_allow_shutdown_while_awaiting_quiescence() { +// allow_shutdown_while_awaiting_quiescence(false); +// allow_shutdown_while_awaiting_quiescence(true); +// } + +// fn allow_shutdown_while_awaiting_quiescence(local_shutdown: bool) { +// // Test that a shutdown sent/received while we're still awaiting quiescence (stfu has not been +// // sent yet) is honored and the channel is closed cooperatively. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let local_node = &nodes[0]; +// let remote_node = &nodes[1]; +// let local_node_id = local_node.node.get_our_node_id(); +// let remote_node_id = remote_node.node.get_our_node_id(); + +// let payment_amount = 1_000_000; +// let (route, payment_hash, _, payment_secret) = +// get_route_and_payment_hash!(local_node, remote_node, payment_amount); +// let onion = RecipientOnionFields::secret_only(payment_secret); +// let payment_id = PaymentId(payment_hash.0); +// local_node.node.send_payment_with_route(route, payment_hash, onion, payment_id).unwrap(); +// check_added_monitors!(local_node, 1); + +// // Attempt to send an HTLC, but don't fully commit it yet. +// let update_add = get_htlc_update_msgs!(local_node, remote_node_id); +// remote_node.node.handle_update_add_htlc(local_node_id, &update_add.update_add_htlcs[0]); +// remote_node +// .node +// .handle_commitment_signed_batch_test(local_node_id, &update_add.commitment_signed); +// let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(remote_node, local_node_id); +// local_node.node.handle_revoke_and_ack(remote_node_id, &revoke_and_ack); +// check_added_monitors(local_node, 1); + +// // Request the local node to propose quiescence, and immediately try to close the channel. Since +// // we haven't sent `stfu` yet as the state machine is pending, we should forget about our +// // quiescence attempt. +// local_node.node.maybe_propose_quiescence(&remote_node_id, &chan_id).unwrap(); +// assert!(local_node.node.get_and_clear_pending_msg_events().is_empty()); + +// let (closer_node, closee_node) = +// if local_shutdown { (local_node, remote_node) } else { (remote_node, local_node) }; +// let closer_node_id = closer_node.node.get_our_node_id(); +// let closee_node_id = closee_node.node.get_our_node_id(); + +// closer_node.node.close_channel(&chan_id, &closee_node_id).unwrap(); +// check_added_monitors(&remote_node, 1); +// let shutdown_initiator = +// get_event_msg!(closer_node, MessageSendEvent::SendShutdown, closee_node_id); +// closee_node.node.handle_shutdown(closer_node_id, &shutdown_initiator); +// let shutdown_responder = +// get_event_msg!(closee_node, MessageSendEvent::SendShutdown, closer_node_id); +// closer_node.node.handle_shutdown(closee_node_id, &shutdown_responder); + +// // Continue exchanging messages until the HTLC is irrevocably committed and eventually failed +// // back as we are shutting down. +// local_node.node.handle_commitment_signed_batch_test(remote_node_id, &commit_sig); +// check_added_monitors(local_node, 1); + +// let last_revoke_and_ack = +// get_event_msg!(local_node, MessageSendEvent::SendRevokeAndACK, remote_node_id); +// remote_node.node.handle_revoke_and_ack(local_node_id, &last_revoke_and_ack); +// check_added_monitors(remote_node, 1); +// expect_pending_htlcs_forwardable!(remote_node); +// expect_htlc_handling_failed_destinations!( +// remote_node.node.get_and_clear_pending_events(), +// &[HTLCHandlingFailureType::Receive { payment_hash }] +// ); +// check_added_monitors(remote_node, 1); + +// let update_fail = get_htlc_update_msgs!(remote_node, local_node_id); +// local_node.node.handle_update_fail_htlc(remote_node_id, &update_fail.update_fail_htlcs[0]); +// local_node +// .node +// .handle_commitment_signed_batch_test(remote_node_id, &update_fail.commitment_signed); + +// let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(local_node, remote_node_id); +// remote_node.node.handle_revoke_and_ack(local_node_id, &revoke_and_ack); +// check_added_monitors(remote_node, 1); +// remote_node.node.handle_commitment_signed_batch_test(local_node_id, &commit_sig); +// check_added_monitors(remote_node, 1); + +// let last_revoke_and_ack = +// get_event_msg!(remote_node, MessageSendEvent::SendRevokeAndACK, local_node_id); +// local_node.node.handle_revoke_and_ack(remote_node_id, &last_revoke_and_ack); + +// expect_payment_failed_conditions( +// local_node, +// payment_hash, +// true, +// PaymentFailedConditions::new(), +// ); + +// // Now that the state machine is no longer pending, and `closing_signed` is ready to be sent, +// // make sure we're still not waiting for the quiescence handshake to complete. +// local_node.node.exit_quiescence(&remote_node_id, &chan_id).unwrap(); + +// let _ = get_event_msg!(local_node, MessageSendEvent::SendClosingSigned, remote_node_id); +// check_added_monitors(local_node, 2); // One for the last revoke_and_ack, another for closing_signed +// } + +// #[test] +// fn test_quiescence_waits_for_async_signer_and_monitor_update() { +// // Test that quiescence: +// // a) considers an async signer when determining whether a pending channel update exists +// // b) waits until pending monitor updates complete to send `stfu`/become quiescent +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// let payment_amount = 1_000_000; +// let (preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], payment_amount); +// nodes[1].node.claim_funds(preimage); +// check_added_monitors(&nodes[1], 1); + +// let update = get_htlc_update_msgs!(&nodes[1], node_id_0); +// nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); +// nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &update.commitment_signed); +// check_added_monitors(&nodes[0], 1); + +// // While settling back the payment, propose quiescence from nodes[1]. We won't see its `stfu` go +// // out yet as the `update_fulfill` is still pending on both sides. +// nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); + +// // Disable releasing commitment secrets on nodes[1], to hold back their `stfu` until the +// // `revoke_and_ack` goes out, and drive the state machine forward. +// nodes[1].disable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); + +// let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(&nodes[0], node_id_1); +// nodes[1].node.handle_revoke_and_ack(node_id_0, &revoke_and_ack); +// check_added_monitors(&nodes[1], 1); +// nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &commit_sig); +// check_added_monitors(&nodes[1], 1); + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Resume the signer. We should now expect to see both messages. +// nodes[1].enable_channel_signer_op(&node_id_0, &chan_id, SignerOp::ReleaseCommitmentSecret); +// nodes[1].node.signer_unblocked(Some((node_id_0, chan_id))); + +// expect_payment_claimed!(&nodes[1], payment_hash, payment_amount); + +// macro_rules! find_msg { +// ($events: expr, $msg: ident) => {{ +// $events +// .iter() +// .find_map(|event| { +// if let MessageSendEvent::$msg { ref msg, .. } = event { +// Some(msg) +// } else { +// None +// } +// }) +// .unwrap() +// }}; +// } +// let msg_events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(msg_events.len(), 2); +// let revoke_and_ack = find_msg!(msg_events, SendRevokeAndACK); +// let stfu = find_msg!(msg_events, SendStfu); + +// // While handling the last `revoke_and_ack` on nodes[0], we'll hold the monitor update. We +// // cannot become quiescent until it completes. +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.handle_revoke_and_ack(node_id_1, &revoke_and_ack); + +// nodes[0].node.handle_stfu(node_id_1, &stfu); +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// // We have two updates pending: +// { +// let chain_monitor = &nodes[0].chain_monitor; +// let (_, latest_update) = +// chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); +// let chain_monitor = &nodes[0].chain_monitor.chain_monitor; +// // One for the latest commitment transaction update from the last `revoke_and_ack` +// chain_monitor.channel_monitor_updated(chan_id, latest_update).unwrap(); +// expect_payment_sent(&nodes[0], preimage, None, true, true); +// // One for the commitment secret update from the last `revoke_and_ack` +// chain_monitor.channel_monitor_updated(chan_id, latest_update + 1).unwrap(); +// } + +// // With the updates completed, we can now become quiescent. +// let stfu = get_event_msg!(&nodes[0], MessageSendEvent::SendStfu, node_id_1); +// nodes[1].node.handle_stfu(node_id_0, &stfu); + +// nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); +// nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); + +// // After exiting quiescence, we should be able to resume payments from nodes[0]. +// send_payment(&nodes[0], &[&nodes[1]], payment_amount); +// } + +// #[test] +// fn test_quiescence_on_final_revoke_and_ack_pending_monitor_update() { +// // Test that we do not let a pending monitor update for a final `revoke_and_ack` prevent us from +// // entering quiescence. This was caught by the fuzzer, reported as #3805. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// let payment_amount = 1_000_000; +// let (route, payment_hash, _, payment_secret) = +// get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); +// let onion = RecipientOnionFields::secret_only(payment_secret); +// let payment_id = PaymentId(payment_hash.0); +// nodes[0].node.send_payment_with_route(route, payment_hash, onion, payment_id).unwrap(); +// check_added_monitors(&nodes[0], 1); + +// nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); +// let stfu = get_event_msg!(&nodes[1], MessageSendEvent::SendStfu, node_id_0); +// nodes[0].node.handle_stfu(node_id_1, &stfu); + +// let update_add = get_htlc_update_msgs!(&nodes[0], node_id_1); +// nodes[1].node.handle_update_add_htlc(node_id_0, &update_add.update_add_htlcs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(node_id_0, &update_add.commitment_signed); +// check_added_monitors(&nodes[1], 1); + +// let (revoke_and_ack, commit_sig) = get_revoke_commit_msgs!(&nodes[1], node_id_0); +// nodes[0].node.handle_revoke_and_ack(node_id_1, &revoke_and_ack); +// check_added_monitors(&nodes[0], 1); +// nodes[0].node.handle_commitment_signed_batch_test(node_id_1, &commit_sig); +// check_added_monitors(&nodes[0], 1); + +// chanmon_cfgs[1].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// let msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &msgs[0] { +// nodes[1].node.handle_revoke_and_ack(node_id_0, &msg); +// check_added_monitors(&nodes[1], 1); +// } else { +// panic!(); +// } +// if let MessageSendEvent::SendStfu { msg, .. } = &msgs[1] { +// nodes[1].node.handle_stfu(node_id_0, &msg); +// } else { +// panic!(); +// } + +// nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); +// nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); +// } + +// #[test] +// fn test_quiescence_updates_go_to_holding_cell() { +// quiescence_updates_go_to_holding_cell(false); +// quiescence_updates_go_to_holding_cell(true); +// } + +// fn quiescence_updates_go_to_holding_cell(fail_htlc: bool) { +// // Test that any updates made to a channel while quiescent go to the holding cell. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// // Send enough to be able to pay from both directions. +// let payment_amount = 1_000_000; +// send_payment(&nodes[0], &[&nodes[1]], payment_amount * 4); + +// // Propose quiescence from nodes[1], and immediately try to send a payment. Since its `stfu` has +// // already gone out first, the outbound HTLC will go into the holding cell. +// nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); +// let stfu = get_event_msg!(&nodes[1], MessageSendEvent::SendStfu, node_id_0); + +// let (route1, payment_hash1, payment_preimage1, payment_secret1) = +// get_route_and_payment_hash!(&nodes[1], &nodes[0], payment_amount); +// let onion1 = RecipientOnionFields::secret_only(payment_secret1); +// let payment_id1 = PaymentId(payment_hash1.0); +// nodes[1].node.send_payment_with_route(route1, payment_hash1, onion1, payment_id1).unwrap(); +// check_added_monitors!(&nodes[1], 0); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Send a payment in the opposite direction. Since nodes[0] hasn't sent its own `stfu` yet, it's +// // allowed to make updates. +// let (route2, payment_hash2, payment_preimage2, payment_secret2) = +// get_route_and_payment_hash!(&nodes[0], &nodes[1], payment_amount); +// let onion2 = RecipientOnionFields::secret_only(payment_secret2); +// let payment_id2 = PaymentId(payment_hash2.0); +// nodes[0].node.send_payment_with_route(route2, payment_hash2, onion2, payment_id2).unwrap(); +// check_added_monitors!(&nodes[0], 1); + +// let update_add = get_htlc_update_msgs!(&nodes[0], node_id_1); +// nodes[1].node.handle_update_add_htlc(node_id_0, &update_add.update_add_htlcs[0]); +// commitment_signed_dance!(&nodes[1], &nodes[0], update_add.commitment_signed, false); +// expect_pending_htlcs_forwardable!(&nodes[1]); +// expect_payment_claimable!(nodes[1], payment_hash2, payment_secret2, payment_amount); + +// // Have nodes[1] attempt to fail/claim nodes[0]'s payment. Since nodes[1] already sent out +// // `stfu`, the `update_fail/fulfill` will go into the holding cell. +// if fail_htlc { +// nodes[1].node.fail_htlc_backwards(&payment_hash2); +// let failed_payment = HTLCHandlingFailureType::Receive { payment_hash: payment_hash2 }; +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!(&nodes[1], vec![failed_payment]); +// } else { +// nodes[1].node.claim_funds(payment_preimage2); +// check_added_monitors(&nodes[1], 1); +// } +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Finish the quiescence handshake. +// nodes[0].node.handle_stfu(node_id_1, &stfu); +// let stfu = get_event_msg!(&nodes[0], MessageSendEvent::SendStfu, node_id_1); +// nodes[1].node.handle_stfu(node_id_0, &stfu); + +// nodes[0].node.exit_quiescence(&node_id_1, &chan_id).unwrap(); +// nodes[1].node.exit_quiescence(&node_id_0, &chan_id).unwrap(); + +// // Now that quiescence is over, nodes are allowed to make updates again. nodes[1] will have its +// // outbound HTLC finally go out, along with the fail/claim of nodes[0]'s payment. +// let update = get_htlc_update_msgs!(&nodes[1], node_id_0); +// check_added_monitors(&nodes[1], 1); +// nodes[0].node.handle_update_add_htlc(node_id_1, &update.update_add_htlcs[0]); +// if fail_htlc { +// nodes[0].node.handle_update_fail_htlc(node_id_1, &update.update_fail_htlcs[0]); +// } else { +// nodes[0].node.handle_update_fulfill_htlc(node_id_1, &update.update_fulfill_htlcs[0]); +// } +// commitment_signed_dance!(&nodes[0], &nodes[1], update.commitment_signed, false); + +// if !fail_htlc { +// expect_payment_claimed!(nodes[1], payment_hash2, payment_amount); +// } + +// // The payment from nodes[0] should now be seen as failed/successful. +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 3); +// assert!(events.iter().find(|e| matches!(e, Event::PendingHTLCsForwardable { .. })).is_some()); +// if fail_htlc { +// assert!(events.iter().find(|e| matches!(e, Event::PaymentFailed { .. })).is_some()); +// assert!(events.iter().find(|e| matches!(e, Event::PaymentPathFailed { .. })).is_some()); +// } else { +// assert!(events.iter().find(|e| matches!(e, Event::PaymentSent { .. })).is_some()); +// assert!(events.iter().find(|e| matches!(e, Event::PaymentPathSuccessful { .. })).is_some()); +// check_added_monitors(&nodes[0], 1); +// } +// nodes[0].node.process_pending_htlc_forwards(); +// expect_payment_claimable!(nodes[0], payment_hash1, payment_secret1, payment_amount); + +// // Have nodes[0] fail/claim nodes[1]'s payment. +// if fail_htlc { +// nodes[0].node.fail_htlc_backwards(&payment_hash1); +// let failed_payment = HTLCHandlingFailureType::Receive { payment_hash: payment_hash1 }; +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!(&nodes[0], vec![failed_payment]); +// } else { +// nodes[0].node.claim_funds(payment_preimage1); +// } +// check_added_monitors(&nodes[0], 1); + +// let update = get_htlc_update_msgs!(&nodes[0], node_id_1); +// if fail_htlc { +// nodes[1].node.handle_update_fail_htlc(node_id_0, &update.update_fail_htlcs[0]); +// } else { +// nodes[1].node.handle_update_fulfill_htlc(node_id_0, &update.update_fulfill_htlcs[0]); +// } +// commitment_signed_dance!(&nodes[1], &nodes[0], update.commitment_signed, false); + +// // The payment from nodes[1] should now be seen as failed/successful. +// if fail_htlc { +// let conditions = PaymentFailedConditions::new(); +// expect_payment_failed_conditions(&nodes[1], payment_hash1, true, conditions); +// } else { +// expect_payment_claimed!(nodes[0], payment_hash1, payment_amount); +// expect_payment_sent(&nodes[1], payment_preimage1, None, true, true); +// } +// } + +// #[test] +// fn test_quiescence_timeout() { +// // Test that we'll disconnect if we remain quiescent for `DISCONNECT_PEER_AWAITING_RESPONSE_TICKS`. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); +// let node_id_1 = nodes[1].node.get_our_node_id(); + +// nodes[0].node.maybe_propose_quiescence(&nodes[1].node.get_our_node_id(), &chan_id).unwrap(); + +// let stfu_initiator = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1); +// nodes[1].node.handle_stfu(node_id_0, &stfu_initiator); + +// let stfu_responder = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); +// nodes[0].node.handle_stfu(node_id_1, &stfu_responder); + +// assert!(stfu_initiator.initiator && !stfu_responder.initiator); + +// for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { +// nodes[0].node.timer_tick_occurred(); +// nodes[1].node.timer_tick_occurred(); +// } + +// let f = |event| { +// if let MessageSendEvent::HandleError { action, .. } = event { +// if let msgs::ErrorAction::DisconnectPeerWithWarning { .. } = action { +// Some(()) +// } else { +// None +// } +// } else { +// None +// } +// }; +// assert!(nodes[0].node.get_and_clear_pending_msg_events().into_iter().find_map(f).is_some()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().into_iter().find_map(f).is_some()); +// } + +// #[test] +// fn test_quiescence_timeout_while_waiting_for_counterparty_stfu() { +// // Test that we'll disconnect if the counterparty does not send their stfu within a reasonable +// // time if we've already sent ours. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// let node_id_0 = nodes[0].node.get_our_node_id(); + +// nodes[1].node.maybe_propose_quiescence(&node_id_0, &chan_id).unwrap(); +// let _ = get_event_msg!(nodes[1], MessageSendEvent::SendStfu, node_id_0); + +// // Route a payment in between to ensure expecting to receive `revoke_and_ack` doesn't override +// // the expectation of receiving `stfu` as well. +// let _ = route_payment(&nodes[0], &[&nodes[1]], 1_000_000); + +// for _ in 0..DISCONNECT_PEER_AWAITING_RESPONSE_TICKS { +// nodes[0].node.timer_tick_occurred(); +// nodes[1].node.timer_tick_occurred(); +// } + +// // nodes[0] hasn't received stfu from nodes[1], so it's not enforcing any timeouts. +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// // nodes[1] didn't receive nodes[0]'s stfu within the timeout so it'll disconnect. +// let f = |&ref event| { +// if let MessageSendEvent::HandleError { action, .. } = event { +// if let msgs::ErrorAction::DisconnectPeerWithWarning { .. } = action { +// Some(()) +// } else { +// None +// } +// } else { +// None +// } +// }; +// assert!(nodes[1].node.get_and_clear_pending_msg_events().iter().find_map(f).is_some()); +// } diff --git a/lightning/src/ln/shutdown_tests.rs b/lightning/src/ln/shutdown_tests.rs index d5c3fe3c387..d3bb7bc3a32 100644 --- a/lightning/src/ln/shutdown_tests.rs +++ b/lightning/src/ln/shutdown_tests.rs @@ -1,1538 +1,1538 @@ -#![cfg_attr(rustfmt, rustfmt_skip)] - -// This file is Copyright its original authors, visible in version control -// history. -// -// This file is licensed under the Apache License, Version 2.0 or the MIT license -// , at your option. -// You may not use this file except in accordance with one or both of these -// licenses. - -//! Tests of our shutdown and closing_signed negotiation logic as well as some assorted force-close -//! handling tests. - -use crate::sign::{EntropySource, SignerProvider}; -use crate::chain::ChannelMonitorUpdateStatus; -use crate::chain::transaction::OutPoint; -use crate::events::{Event, HTLCHandlingFailureType, ClosureReason}; -use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState}; -use crate::ln::channelmanager::{self, PaymentId, RecipientOnionFields, Retry}; -use crate::routing::router::{PaymentParameters, get_route, RouteParameters}; -use crate::ln::msgs; -use crate::ln::types::ChannelId; -use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent}; -use crate::ln::onion_utils::LocalHTLCFailureReason; -use crate::ln::script::ShutdownScript; -use crate::util::test_utils; -use crate::util::test_utils::OnGetShutdownScriptpubkey; -use crate::util::errors::APIError; -use crate::util::config::UserConfig; -use crate::util::string::UntrustedString; -use crate::prelude::*; - -use bitcoin::{Transaction, TxOut, WitnessProgram, WitnessVersion}; -use bitcoin::amount::Amount; -use bitcoin::locktime::absolute::LockTime; -use bitcoin::script::Builder; -use bitcoin::opcodes; -use bitcoin::network::Network; -use bitcoin::transaction::Version; - -use crate::ln::functional_test_utils::*; - -#[test] -fn pre_funding_lock_shutdown_test() { - // Test sending a shutdown prior to channel_ready after funding generation - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0); - mine_transaction(&nodes[0], &tx); - mine_transaction(&nodes[1], &tx); - - nodes[0].node.close_channel(&ChannelId::v1_from_funding_outpoint(OutPoint { txid: tx.compute_txid(), index: 0 }), &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - - assert!(nodes[0].node.list_channels().is_empty()); - assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 8000000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 8000000); -} - -#[test] -fn expect_channel_shutdown_state() { - // Test sending a shutdown prior to channel_ready after funding generation - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); - - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - - // node1 goes into NegotiatingClosingFee since there are no HTLCs in flight, note that it - // doesnt mean that node1 has sent/recved its closing signed message - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - - assert!(nodes[0].node.list_channels().is_empty()); - assert!(nodes[1].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); -} - -#[test] -fn expect_channel_shutdown_state_with_htlc() { - // Test sending a shutdown with outstanding updates pending. - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let _chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - - let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - // Claim Funds on Node2 - nodes[2].node.claim_funds(payment_preimage_0); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); - - // Fulfil HTLCs on node1 and node0 - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); - - // Still in "resolvingHTLCs" on chan1 after htlc removed on chan2 - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); - - assert!(updates_2.update_add_htlcs.is_empty()); - assert!(updates_2.update_fail_htlcs.is_empty()); - assert!(updates_2.update_fail_malformed_htlcs.is_empty()); - assert!(updates_2.update_fee.is_none()); - assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); - expect_payment_sent!(nodes[0], payment_preimage_0); - - // all htlcs removed, chan1 advances to NegotiatingClosingFee - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); - - // ClosingSignNegotion process - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); - - // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary - assert!(nodes[0].node.list_channels().is_empty()); -} - -#[test] -fn test_lnd_bug_6039() { - // LND sends a nonsense error message any time it gets a shutdown if there are still HTLCs - // pending. We currently swallow that error to work around LND's bug #6039. This test emulates - // the LND nonsense and ensures we at least kinda handle it. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - - let (payment_preimage, ..) = route_payment(&nodes[0], &[&nodes[1]], 100_000); - - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - - // Generate an lnd-like error message and check that we respond by simply screaming louder to - // see if LND will accept our protocol compliance. - let err_msg = msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() }; - nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &err_msg); - let node_a_responses = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(node_a_responses[0], MessageSendEvent::SendShutdown { - node_id: nodes[1].node.get_our_node_id(), - msg: node_0_shutdown, - }); - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendWarningMessage { .. }, .. } - = node_a_responses[1] {} else { panic!(); } - - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); - - // Assume that LND will eventually respond to our Shutdown if we clear all the remaining HTLCs - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - // ClosingSignNegotion process - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); - - // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary - assert!(nodes[0].node.list_channels().is_empty()); -} - -#[test] -fn shutdown_on_unfunded_channel() { - // Test receiving a shutdown prior to funding generation - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); - let open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - // Create a dummy P2WPKH script - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &msgs::Shutdown { - channel_id: open_chan.common_fields.temporary_channel_id, scriptpubkey: script, - }); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyCoopClosedUnfundedChannel, [nodes[1].node.get_our_node_id()], 1_000_000); -} - -#[test] -fn close_on_unfunded_channel() { - // Test the user asking us to close prior to funding generation - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan_id = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); - let _open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) }, [nodes[1].node.get_our_node_id()], 1_000_000); -} - -#[test] -fn expect_channel_shutdown_state_with_force_closure() { - // Test sending a shutdown prior to channel_ready after funding generation - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let error_message = "Channel force-closed"; - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); - expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); - - nodes[1].node.force_close_broadcasting_latest_txn(&chan_1.2, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); - check_closed_broadcast!(nodes[1], true); - check_added_monitors!(nodes[1], 1); - - expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); - assert!(nodes[1].node.list_channels().is_empty()); - - let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); - assert_eq!(node_txn.len(), 1); - check_spends!(node_txn[0], chan_1.3); - mine_transaction(&nodes[0], &node_txn[0]); - check_added_monitors!(nodes[0], 1); - - assert!(nodes[0].node.list_channels().is_empty()); - assert!(nodes[1].node.list_channels().is_empty()); - check_closed_broadcast!(nodes[0], true); - check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[0].node.get_our_node_id()], 100000); -} - -#[test] -fn updates_shutdown_wait() { - // Test sending a shutdown with outstanding updates pending - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - let logger = test_utils::TestLogger::new(); - let scorer = test_utils::TestScorer::new(); - let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); - let random_seed_bytes = keys_manager.get_secure_random_bytes(); - - let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - - nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]); - - let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[1].node.bolt11_invoice_features()).unwrap(); - let route_params = RouteParameters::from_payment_params_and_value(payment_params_1, 100_000); - let route_1 = get_route(&nodes[0].node.get_our_node_id(), &route_params, - &nodes[0].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); - let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), TEST_FINAL_CLTV) - .with_bolt11_features(nodes[0].node.bolt11_invoice_features()).unwrap(); - let route_params = RouteParameters::from_payment_params_and_value(payment_params_2, 100_000); - let route_2 = get_route(&nodes[1].node.get_our_node_id(), &route_params, - &nodes[1].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); - unwrap_send_err!(nodes[0], nodes[0].node.send_payment_with_route(route_1, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) - ), true, APIError::ChannelUnavailable {..}, {}); - unwrap_send_err!(nodes[1], nodes[1].node.send_payment_with_route(route_2, payment_hash, - RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) - ), true, APIError::ChannelUnavailable {..}, {}); - - nodes[2].node.claim_funds(payment_preimage_0); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); - - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); - - assert!(updates_2.update_add_htlcs.is_empty()); - assert!(updates_2.update_fail_htlcs.is_empty()); - assert!(updates_2.update_fail_malformed_htlcs.is_empty()); - assert!(updates_2.update_fee.is_none()); - assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); - expect_payment_sent!(nodes[0], payment_preimage_0); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); - - assert!(nodes[0].node.list_channels().is_empty()); - - assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); - close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); - assert!(nodes[1].node.list_channels().is_empty()); - assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); -} - -#[test] -fn htlc_fail_async_shutdown() { - do_htlc_fail_async_shutdown(true); - do_htlc_fail_async_shutdown(false); -} - -fn do_htlc_fail_async_shutdown(blinded_recipient: bool) { - // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - - let amt_msat = 100000; - let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); - let route_params = if blinded_recipient { - crate::ln::blinded_payment_tests::get_blinded_route_parameters( - amt_msat, our_payment_secret, 1, 100000000, - nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_2.0.contents], - &chanmon_cfgs[2].keys_manager) - } else { - RouteParameters::from_payment_params_and_value( - PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV), amt_msat) - }; - nodes[0].node.send_payment(our_payment_hash, - RecipientOnionFields::secret_only(our_payment_secret), - PaymentId(our_payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); - check_added_monitors!(nodes[0], 1); - let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); - assert_eq!(updates.update_add_htlcs.len(), 1); - assert!(updates.update_fulfill_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - - nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - - nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]); - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); - check_added_monitors!(nodes[1], 1); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false); - expect_pending_htlcs_forwardable!(nodes[1]); - expect_htlc_handling_failed_destinations!( - nodes[1].node.get_and_clear_pending_events(), - &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_2.2 }] - ); - check_added_monitors(&nodes[1], 1); - - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - assert!(updates_2.update_add_htlcs.is_empty()); - assert!(updates_2.update_fulfill_htlcs.is_empty()); - assert_eq!(updates_2.update_fail_htlcs.len(), 1); - assert!(updates_2.update_fail_malformed_htlcs.is_empty()); - assert!(updates_2.update_fee.is_none()); - - nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); - - if blinded_recipient { - expect_payment_failed_conditions(&nodes[0], our_payment_hash, false, - PaymentFailedConditions::new().expected_htlc_error_data(LocalHTLCFailureReason::InvalidOnionBlinding, &[0; 32])); - } else { - expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true); - } - - let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(msg_events.len(), 1); - let node_0_closing_signed = match msg_events[0] { - MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { - assert_eq!(*node_id, nodes[1].node.get_our_node_id()); - (*msg).clone() - }, - _ => panic!("Unexpected event"), - }; - - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - - assert!(nodes[0].node.list_channels().is_empty()); - - assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); - close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); - assert!(nodes[1].node.list_channels().is_empty()); - assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - let event1 = ExpectedCloseEvent { - channel_capacity_sats: Some(100000), - channel_id: None, - counterparty_node_id: Some(nodes[0].node.get_our_node_id()), - discard_funding: false, - reason: Some(ClosureReason::LocallyInitiatedCooperativeClosure), - channel_funding_txo: None, - user_channel_id: None, - }; - let event2 = ExpectedCloseEvent { - channel_capacity_sats: Some(100000), - channel_id: None, - counterparty_node_id: Some(nodes[2].node.get_our_node_id()), - discard_funding: false, - reason: Some(ClosureReason::CounterpartyInitiatedCooperativeClosure), - channel_funding_txo: None, - user_channel_id: None, - }; - check_closed_events(&nodes[1], &[event1, event2]); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); -} - -fn do_test_shutdown_rebroadcast(recv_count: u8) { - // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of - // messages delivered prior to disconnect - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); - - let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); - - nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - if recv_count > 0 { - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - if recv_count > 1 { - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - } - } - - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); - let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - assert!(node_1_shutdown == node_1_2nd_shutdown); - - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); - let node_0_2nd_shutdown = if recv_count > 0 { - let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); - node_0_2nd_shutdown - } else { - let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); - assert_eq!(node_0_chan_update.contents.channel_flags & 2, 0); // "disabled" flag must not be set as we just reconnected. - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); - get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()) - }; - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); - - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[2].node.claim_funds(payment_preimage); - check_added_monitors!(nodes[2], 1); - expect_payment_claimed!(nodes[2], payment_hash, 100_000); - - let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); - assert!(updates.update_add_htlcs.is_empty()); - assert!(updates.update_fail_htlcs.is_empty()); - assert!(updates.update_fail_malformed_htlcs.is_empty()); - assert!(updates.update_fee.is_none()); - assert_eq!(updates.update_fulfill_htlcs.len(), 1); - nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); - expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); - check_added_monitors!(nodes[1], 1); - let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); - commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); - - assert!(updates_2.update_add_htlcs.is_empty()); - assert!(updates_2.update_fail_htlcs.is_empty()); - assert!(updates_2.update_fail_malformed_htlcs.is_empty()); - assert!(updates_2.update_fee.is_none()); - assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); - nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); - commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); - expect_payment_sent!(nodes[0], payment_preimage); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - if recv_count > 0 { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - assert!(node_0_2nd_closing_signed.is_some()); - } - - nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); - nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); - - nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { - features: nodes[0].node.init_features(), networks: None, remote_network_address: None - }, true).unwrap(); - let node_1_2nd_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); - nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { - features: nodes[1].node.init_features(), networks: None, remote_network_address: None - }, false).unwrap(); - if recv_count == 0 { - // If all closing_signeds weren't delivered we can just resume where we left off... - let node_0_2nd_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); - - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); - let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(node_0_msgs.len(), 2); - let node_0_2nd_closing_signed = match node_0_msgs[1] { - MessageSendEvent::SendClosingSigned { ref msg, .. } => { - assert_eq!(node_0_closing_signed, *msg); - msg.clone() - }, - _ => panic!(), - }; - - let node_0_3rd_shutdown = match node_0_msgs[0] { - MessageSendEvent::SendShutdown { ref msg, .. } => { - assert_eq!(node_0_2nd_shutdown, *msg); - msg.clone() - }, - _ => panic!(), - }; - assert!(node_0_2nd_shutdown == node_0_3rd_shutdown); - - nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish); - let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - assert!(node_1_3rd_shutdown == node_1_2nd_shutdown); - - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown); - assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown); - - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); - } else { - // If one node, however, received + responded with an identical closing_signed we end - // up erroring and node[0] will try to broadcast its own latest commitment transaction. - // There isn't really anything better we can do simply, but in the future we might - // explore storing a set of recently-closed channels that got disconnected during - // closing_signed and avoiding broadcasting local commitment txn for some timeout to - // give our counterparty enough time to (potentially) broadcast a cooperative closing - // transaction. - assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); - - nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); - let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(msg_events.len(), 2); - if let MessageSendEvent::HandleError { ref action, .. } = msg_events[1] { - match action { - &ErrorAction::SendErrorMessage { ref msg } => { - nodes[1].node.handle_error(nodes[0].node.get_our_node_id(), &msg); - assert_eq!(msg.channel_id, chan_1.2); - }, - _ => panic!("Unexpected event!"), - } - } else { panic!("Needed SendErrorMessage close"); } - - // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and - // checks it, but in this case nodes[1] didn't ever get a chance to receive a - // closing_signed so we do it ourselves - check_closed_broadcast!(nodes[1], false); - check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &nodes[1].node.get_our_node_id())) } - , [nodes[0].node.get_our_node_id()], 100000); - } - - assert!(nodes[0].node.list_channels().is_empty()); - - assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); - close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); - assert!(nodes[1].node.list_channels().is_empty()); - assert!(nodes[2].node.list_channels().is_empty()); - check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); - check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); -} - -#[test] -fn test_shutdown_rebroadcast() { - do_test_shutdown_rebroadcast(0); - do_test_shutdown_rebroadcast(1); - do_test_shutdown_rebroadcast(2); -} - -#[test] -fn test_upfront_shutdown_script() { - // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening - // enforce it at shutdown message - - let mut config = UserConfig::default(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); - let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); - let mut node_0_shutdown = node_0_orig_shutdown.clone(); - node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh(); - // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn - // the peer and ignore the message. - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.") - .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2))); - // This allows nodes[2] to retry the shutdown message, which should get a response: - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_orig_shutdown); - get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); - // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign - nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let events = nodes[2].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - - // We test that if case of peer non-signaling we don't enforce committed script at channel opening - let mut features = nodes[0].node.init_features(); - features.clear_upfront_shutdown_script(); - *nodes[0].override_init_features.borrow_mut() = Some(features); - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); - check_added_monitors!(nodes[1], 1); - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - - // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close - // channel smoothly, opt-out is from channel initiator here - *nodes[0].override_init_features.borrow_mut() = None; - let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - - //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close - //// channel smoothly - let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 2); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } -} - -#[test] -fn test_unsupported_anysegwit_upfront_shutdown_script() { - let chanmon_cfgs = create_chanmon_cfgs(2); - let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - // Clear shutdown_anysegwit on initiator - let mut features = channelmanager::provided_init_features(&test_default_channel_config()); - features.clear_shutdown_anysegwit(); - *node_cfgs[0].override_init_features.borrow_mut() = Some(features); - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // Use a non-v0 segwit script supported by option_shutdown_anysegwit - let anysegwit_shutdown_script = Builder::new() - .push_int(16) - .push_slice(&[0, 40]) - .into_script(); - - // Check script when handling an open_channel message - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - open_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[0].node.get_our_node_id()); - assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); - }, - _ => panic!("Unexpected event"), - } - - let chanmon_cfgs = create_chanmon_cfgs(2); - let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - // Clear shutdown_anysegwit on responder - let mut features = channelmanager::provided_init_features(&test_default_channel_config()); - features.clear_shutdown_anysegwit(); - *node_cfgs[1].override_init_features.borrow_mut() = Some(features); - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // Check script when handling an accept_channel message - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); - accept_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); - nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); - - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[1].node.get_our_node_id()); - assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); - }, - _ => panic!("Unexpected event"), - } - check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028".to_string() } - , [nodes[1].node.get_our_node_id()], 100000); -} - -#[test] -fn test_invalid_upfront_shutdown_script() { - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); - - // Use a segwit v0 script with an unsupported witness program - let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); - open_channel.common_fields.shutdown_scriptpubkey = Some(Builder::new().push_int(0) - .push_slice(&[0, 0]) - .into_script()); - nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); - - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { - assert_eq!(node_id, nodes[0].node.get_our_node_id()); - assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_0 OP_PUSHBYTES_2 0000"); - }, - _ => panic!("Unexpected event"), - } -} - -#[test] -fn test_segwit_v0_shutdown_script() { - let mut config = UserConfig::default(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - - // Use a segwit v0 script supported even without option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 2); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } -} - -#[test] -fn test_anysegwit_shutdown_script() { - let mut config = UserConfig::default(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - - // Use a non-v0 segwit script supported by option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(16) - .push_slice(&[0, 0]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - - let events = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 2); - match events[0] { - MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } - match events[1] { - MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } - _ => panic!("Unexpected event"), - } -} - -#[test] -fn test_unsupported_anysegwit_shutdown_script() { - let mut config = UserConfig::default(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config.clone()), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let mut features = channelmanager::provided_init_features(&config); - features.clear_shutdown_anysegwit(); - *node_cfgs[0].override_init_features.borrow_mut() = Some(features.clone()); - *node_cfgs[1].override_init_features.borrow_mut() = Some(features); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - // Check that using an unsupported shutdown script fails and a supported one succeeds. - let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); - let unsupported_witness_program = WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(); - let unsupported_shutdown_script = - ShutdownScript::new_witness_program(&unsupported_witness_program).unwrap(); - chanmon_cfgs[1].keys_manager - .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() }) - .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script }); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - match nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()) { - Err(APIError::IncompatibleShutdownScript { script }) => { - assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner()); - }, - Err(e) => panic!("Unexpected error: {:?}", e), - Ok(_) => panic!("Expected error"), - } - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - - // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - - assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), - "Got a nonstandard scriptpubkey (60020028) from remote peer"); -} - -#[test] -fn test_invalid_shutdown_script() { - let mut config = UserConfig::default(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); - check_added_monitors!(nodes[1], 1); - - // Use a segwit v0 script with an unsupported witness program - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - node_0_shutdown.scriptpubkey = Builder::new().push_int(0) - .push_slice(&[0, 0]) - .into_script(); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - - assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), - "Got a nonstandard scriptpubkey (00020000) from remote peer"); -} - -#[test] -fn test_user_shutdown_script() { - let mut config = test_default_channel_config(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - // Segwit v0 script of the form OP_0 <20-byte hash> - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - - let shutdown_script = ShutdownScript::try_from(script.clone()).unwrap(); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)).unwrap(); - check_added_monitors!(nodes[1], 1); - - let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - assert_eq!(node_0_shutdown.scriptpubkey, script); -} - -#[test] -fn test_already_set_user_shutdown_script() { - let mut config = test_default_channel_config(); - config.channel_handshake_config.announce_for_forwarding = true; - config.channel_handshake_limits.force_announced_channel_preference = false; - let user_cfgs = [None, Some(config), None]; - let chanmon_cfgs = create_chanmon_cfgs(3); - let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); - let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); - let nodes = create_network(3, &node_cfgs, &node_chanmgrs); - - // Segwit v0 script of the form OP_0 <20-byte hash> - let script = Builder::new().push_int(0) - .push_slice(&[0; 20]) - .into_script(); - - let shutdown_script = ShutdownScript::try_from(script).unwrap(); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - let result = nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)); - - assert_eq!(result, Err(APIError::APIMisuseError { err: "Cannot override shutdown script for a channel with one already set".to_string() })); -} - -#[derive(PartialEq)] -enum TimeoutStep { - AfterShutdown, - AfterClosingSigned, - NoTimeout, -} - -fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { - // The range-based closing signed negotiation allows the funder to restart the process with a - // new range if the previous range did not overlap. This allows implementations to request user - // intervention allowing users to enter a new fee range. We do not implement the sending side - // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid - // force-closing" value and relying on that instead. - // - // Here we run test the fundee side of that restart mechanism, implementing the funder side of - // it manually. - 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - send_payment(&nodes[0], &[&nodes[1]], 8_000_000); - - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - { - // Now we set nodes[1] to require a relatively high feerate for closing. This should result - // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try - // again. - let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock *= 10; - } - - let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks - // is the current prevailing feerate. - assert!(node_0_closing_signed.fee_satoshis <= 500); - - if timeout_step != TimeoutStep::AfterShutdown { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id) - .starts_with("Unable to come to consensus about closing feerate")); - - // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which - // nodes[1] should happily accept and respond to. - node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10; - { - let mut node_0_per_peer_lock; - let mut node_0_peer_state_lock; - get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context_mut().closing_fee_limits.as_mut().unwrap().1 *= 10; - } - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - if timeout_step == TimeoutStep::NoTimeout { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap()); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); - } - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - } - - if timeout_step != TimeoutStep::NoTimeout { - assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); - } else { - assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); - } - - nodes[1].node.timer_tick_occurred(); - nodes[1].node.timer_tick_occurred(); - - let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); - assert_eq!(txn.len(), 1); - assert_eq!(txn[0].output.len(), 2); - - if timeout_step != TimeoutStep::NoTimeout { - assert!((txn[0].output[0].script_pubkey.is_p2wpkh() && - txn[0].output[1].script_pubkey.is_p2wsh()) || - (txn[0].output[1].script_pubkey.is_p2wpkh() && - txn[0].output[0].script_pubkey.is_p2wsh())); - check_closed_broadcast!(nodes[1], true); - check_added_monitors!(nodes[1], 1); - check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() } - , [nodes[0].node.get_our_node_id()], 100000); - } else { - assert!(txn[0].output[0].script_pubkey.is_p2wpkh()); - assert!(txn[0].output[1].script_pubkey.is_p2wpkh()); - - let events = nodes[1].node.get_and_clear_pending_msg_events(); - assert_eq!(events.len(), 1); - match events[0] { - MessageSendEvent::BroadcastChannelUpdate { ref msg } => { - assert_eq!(msg.contents.channel_flags & 2, 2); - }, - _ => panic!("Unexpected event"), - } - } -} - -#[test] -fn test_closing_signed_reinit_timeout() { - do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown); - do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned); - do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout); -} - -fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { - // A simpe test of the legacy shutdown fee negotiation logic. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - - if high_initiator_fee { - // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This - // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee. - let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock *= 10; - } - - nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - node_0_closing_signed.fee_range = None; - if high_initiator_fee { - assert!(node_0_closing_signed.fee_satoshis > 500); - } else { - assert!(node_0_closing_signed.fee_satoshis < 500); - } - - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - node_1_closing_signed.as_mut().unwrap().fee_range = None; - - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()); - let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - assert!(node_0_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); -} - -#[test] -fn simple_legacy_shutdown_test() { - do_simple_legacy_shutdown_test(false); - do_simple_legacy_shutdown_test(true); -} - -#[test] -fn simple_target_feerate_shutdown() { - // Simple test of target in `close_channel_with_target_feerate`. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - let chan_id = chan.2; - - nodes[0].node.close_channel_with_feerate_and_script(&chan_id, &nodes[1].node.get_our_node_id(), Some(253 * 10), None).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - nodes[1].node.close_channel_with_feerate_and_script(&chan_id, &nodes[0].node.get_our_node_id(), Some(253 * 5), None).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); - - let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); - let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - let node_1_closing_signed = node_1_closing_signed_opt.unwrap(); - - // nodes[1] was passed a target which was larger than the current channel feerate, which it - // should ignore in favor of the channel fee, as there is no use demanding a minimum higher - // than what will be paid on a force-close transaction. Note that we have to consider rounding, - // so only check that we're within 10 sats. - assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >= - node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5); - assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <= - node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5); - - // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our - // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should - // be the nodes[0] only available fee. - assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, - node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis); - assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, - node_0_closing_signed.fee_satoshis); - assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis); - - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); - let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - assert!(node_0_none.is_none()); - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); -} - -fn do_outbound_update_no_early_closing_signed(use_htlc: bool) { - // Previously, if we have a pending inbound HTLC (or fee update) on a channel which has - // initiated shutdown, we'd send our initial closing_signed immediately after receiving the - // peer's last RAA to remove the HTLC/fee update, but before receiving their final - // commitment_signed for a commitment without the HTLC/with the new fee. This caused at least - // LDK peers to force-close as we initiated closing_signed prior to the channel actually being - // fully empty of pending updates/HTLCs. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - send_payment(&nodes[0], &[&nodes[1]], 1_000_000); - let payment_hash_opt = if use_htlc { - Some(route_payment(&nodes[1], &[&nodes[0]], 10_000).1) - } else { - None - }; - - if use_htlc { - nodes[0].node.fail_htlc_backwards(&payment_hash_opt.unwrap()); - expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[0], - [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_opt.unwrap() }]); - } else { - *chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap() *= 10; - nodes[0].node.timer_tick_occurred(); - } - let updates = get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); - check_added_monitors(&nodes[0], 1); - - nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap(); - let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); - nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); - let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); - - nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); - nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); - - if use_htlc { - nodes[1].node.handle_update_fail_htlc(nodes[0].node.get_our_node_id(), &updates.update_fail_htlcs[0]); - } else { - nodes[1].node.handle_update_fee(nodes[0].node.get_our_node_id(), &updates.update_fee.unwrap()); - } - nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); - check_added_monitors(&nodes[1], 1); - let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); - - nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); - check_added_monitors(&nodes[0], 1); - - // At this point the Channel on nodes[0] has no record of any HTLCs but the latest - // broadcastable commitment does contain the HTLC (but only the ChannelMonitor knows this). - // Thus, the channel should not yet initiate closing_signed negotiation (but previously did). - assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); - - chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); - nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_cs); - check_added_monitors(&nodes[0], 1); - assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); - - expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ResolvingHTLCs); - assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); - let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); - nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); - - let as_raa_closing_signed = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(as_raa_closing_signed.len(), 2); - - if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &as_raa_closing_signed[0] { - nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &msg); - check_added_monitors(&nodes[1], 1); - if use_htlc { - expect_payment_failed!(nodes[1], payment_hash_opt.unwrap(), true); - } - } else { panic!("Unexpected message {:?}", as_raa_closing_signed[0]); } - - if let MessageSendEvent::SendClosingSigned { msg, .. } = &as_raa_closing_signed[1] { - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &msg); - } else { panic!("Unexpected message {:?}", as_raa_closing_signed[1]); } - - let bs_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); - nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &bs_closing_signed); - let (_, as_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); - nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &as_2nd_closing_signed.unwrap()); - let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); - assert!(node_1_none.is_none()); - - check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); - check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); -} - -#[test] -fn outbound_update_no_early_closing_signed() { - do_outbound_update_no_early_closing_signed(true); - do_outbound_update_no_early_closing_signed(false); -} - -#[test] -fn batch_funding_failure() { - // Provides test coverage of batch funding failure, which previously deadlocked - 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 nodes = create_network(4, &node_cfgs, &node_chanmgrs); - - let temp_chan_id_a = exchange_open_accept_chan(&nodes[0], &nodes[1], 1_000_000, 0); - let temp_chan_id_b = exchange_open_accept_chan(&nodes[0], &nodes[2], 1_000_000, 0); - - let events = nodes[0].node.get_and_clear_pending_events(); - assert_eq!(events.len(), 2); - // Build a transaction which only has the output for one of the two channels we're trying to - // confirm. Previously this led to a deadlock in channel closure handling. - let mut tx = Transaction { version: Version::TWO, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }; - let mut chans = Vec::new(); - for (idx, ev) in events.iter().enumerate() { - if let Event::FundingGenerationReady { temporary_channel_id, counterparty_node_id, output_script, .. } = ev { - if idx == 0 { - tx.output.push(TxOut { value: Amount::from_sat(1_000_000), script_pubkey: output_script.clone() }); - } - chans.push((temporary_channel_id, counterparty_node_id)); - } else { panic!(); } - } - - let err = "Error in transaction funding: Misuse error: No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); - let temp_err = "No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); - let post_funding_chan_id_a = ChannelId::v1_from_funding_txid(tx.compute_txid().as_ref(), 0); - let close = [ - ExpectedCloseEvent::from_id_reason(post_funding_chan_id_a, true, ClosureReason::ProcessingError { err: err.clone() }), - ExpectedCloseEvent::from_id_reason(temp_chan_id_b, false, ClosureReason::ProcessingError { err: temp_err }), - ]; - - nodes[0].node.batch_funding_transaction_generated(&chans, tx).unwrap_err(); - - let msgs = nodes[0].node.get_and_clear_pending_msg_events(); - assert_eq!(msgs.len(), 3); - // We currently spuriously send `FundingCreated` for the first channel and then immediately - // fail both channels, which isn't ideal but should be fine. - assert!(msgs.iter().any(|msg| { - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { - msg: msgs::ErrorMessage { channel_id, .. }, .. - }, .. } = msg { - *channel_id == temp_chan_id_b - } else { false } - })); - let funding_created_pos = msgs.iter().position(|msg| { - if let MessageSendEvent::SendFundingCreated { msg: msgs::FundingCreated { temporary_channel_id, .. }, .. } = msg { - assert_eq!(*temporary_channel_id, temp_chan_id_a); - true - } else { false } - }).unwrap(); - let funded_channel_close_pos = msgs.iter().position(|msg| { - if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { - msg: msgs::ErrorMessage { channel_id, .. }, .. - }, .. } = msg { - *channel_id == post_funding_chan_id_a - } else { false } - }).unwrap(); - - // The error message uses the funded channel_id so must come after the funding_created - assert!(funded_channel_close_pos > funding_created_pos); - - check_closed_events(&nodes[0], &close); - assert_eq!(nodes[0].node.list_channels().len(), 0); -} - -#[test] -fn test_force_closure_on_low_stale_fee() { - // Check that we force-close channels if they have a low fee and that has gotten stale (without - // update). - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; - - // Start by connecting lots of blocks to give LDK some feerate history - for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS * 2 { - connect_blocks(&nodes[1], 1); - } - - // Now connect a handful of blocks with a "high" feerate - { - let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock *= 2; - } - for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS - 1 { - connect_blocks(&nodes[1], 1); - } - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - // Now, note that one more block would cause us to force-close, it won't because we've dropped - // the feerate - { - let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock /= 2; - } - connect_blocks(&nodes[1], super::channelmanager::FEERATE_TRACKING_BLOCKS as u32 * 2); - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - // Now, connect another FEERATE_TRACKING_BLOCKS - 1 blocks at a high feerate, note that none of - // these will cause a force-closure because LDK only looks at the minimium feerate over the - // last FEERATE_TRACKING_BLOCKS blocks. - { - let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); - *feerate_lock *= 2; - } - - for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS - 1 { - connect_blocks(&nodes[1], 1); - } - assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); - - // Finally, connect one more block and check the force-close happened. - connect_blocks(&nodes[1], 1); - check_added_monitors!(nodes[1], 1); - check_closed_broadcast(&nodes[1], 1, true); - let reason = ClosureReason::PeerFeerateTooLow { peer_feerate_sat_per_kw: 253, required_feerate_sat_per_kw: 253 * 2 }; - check_closed_events(&nodes[1], &[ExpectedCloseEvent::from_id_reason(chan_id, false, reason)]); -} +// #![cfg_attr(rustfmt, rustfmt_skip)] + +// // This file is Copyright its original authors, visible in version control +// // history. +// // +// // This file is licensed under the Apache License, Version 2.0 or the MIT license +// // , at your option. +// // You may not use this file except in accordance with one or both of these +// // licenses. + +// //! Tests of our shutdown and closing_signed negotiation logic as well as some assorted force-close +// //! handling tests. + +// use crate::sign::{EntropySource, SignerProvider}; +// use crate::chain::ChannelMonitorUpdateStatus; +// use crate::chain::transaction::OutPoint; +// use crate::events::{Event, HTLCHandlingFailureType, ClosureReason}; +// use crate::ln::channel_state::{ChannelDetails, ChannelShutdownState}; +// use crate::ln::channelmanager::{self, PaymentId, RecipientOnionFields, Retry}; +// use crate::routing::router::{PaymentParameters, get_route, RouteParameters}; +// use crate::ln::msgs; +// use crate::ln::types::ChannelId; +// use crate::ln::msgs::{BaseMessageHandler, ChannelMessageHandler, ErrorAction, MessageSendEvent}; +// use crate::ln::onion_utils::LocalHTLCFailureReason; +// use crate::ln::script::ShutdownScript; +// use crate::util::test_utils; +// use crate::util::test_utils::OnGetShutdownScriptpubkey; +// use crate::util::errors::APIError; +// use crate::util::config::UserConfig; +// use crate::util::string::UntrustedString; +// use crate::prelude::*; + +// use bitcoin::{Transaction, TxOut, WitnessProgram, WitnessVersion}; +// use bitcoin::amount::Amount; +// use bitcoin::locktime::absolute::LockTime; +// use bitcoin::script::Builder; +// use bitcoin::opcodes; +// use bitcoin::network::Network; +// use bitcoin::transaction::Version; + +// use crate::ln::functional_test_utils::*; + +// #[test] +// fn pre_funding_lock_shutdown_test() { +// // Test sending a shutdown prior to channel_ready after funding generation +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0); +// mine_transaction(&nodes[0], &tx); +// mine_transaction(&nodes[1], &tx); + +// nodes[0].node.close_channel(&ChannelId::v1_from_funding_outpoint(OutPoint { txid: tx.compute_txid(), index: 0 }), &nodes[1].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); + +// assert!(nodes[0].node.list_channels().is_empty()); +// assert!(nodes[1].node.list_channels().is_empty()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 8000000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 8000000); +// } + +// #[test] +// fn expect_channel_shutdown_state() { +// // Test sending a shutdown prior to channel_ready after funding generation +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); + +// nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); + +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + +// // node1 goes into NegotiatingClosingFee since there are no HTLCs in flight, note that it +// // doesnt mean that node1 has sent/recved its closing signed message +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); + +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); + +// assert!(nodes[0].node.list_channels().is_empty()); +// assert!(nodes[1].node.list_channels().is_empty()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn expect_channel_shutdown_state_with_htlc() { +// // Test sending a shutdown with outstanding updates pending. +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let _chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + +// let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); + +// nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); + +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); + +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// // Claim Funds on Node2 +// nodes[2].node.claim_funds(payment_preimage_0); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); + +// // Fulfil HTLCs on node1 and node0 +// let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// check_added_monitors!(nodes[1], 1); +// let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); + +// // Still in "resolvingHTLCs" on chan1 after htlc removed on chan2 +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs); + +// assert!(updates_2.update_add_htlcs.is_empty()); +// assert!(updates_2.update_fail_htlcs.is_empty()); +// assert!(updates_2.update_fail_malformed_htlcs.is_empty()); +// assert!(updates_2.update_fee.is_none()); +// assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); +// expect_payment_sent!(nodes[0], payment_preimage_0); + +// // all htlcs removed, chan1 advances to NegotiatingClosingFee +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee); + +// // ClosingSignNegotion process +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + +// // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary +// assert!(nodes[0].node.list_channels().is_empty()); +// } + +// #[test] +// fn test_lnd_bug_6039() { +// // LND sends a nonsense error message any time it gets a shutdown if there are still HTLCs +// // pending. We currently swallow that error to work around LND's bug #6039. This test emulates +// // the LND nonsense and ensures we at least kinda handle it. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + +// let (payment_preimage, ..) = route_payment(&nodes[0], &[&nodes[1]], 100_000); + +// nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); + +// // Generate an lnd-like error message and check that we respond by simply screaming louder to +// // see if LND will accept our protocol compliance. +// let err_msg = msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() }; +// nodes[0].node.handle_error(nodes[1].node.get_our_node_id(), &err_msg); +// let node_a_responses = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(node_a_responses[0], MessageSendEvent::SendShutdown { +// node_id: nodes[1].node.get_our_node_id(), +// msg: node_0_shutdown, +// }); +// if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendWarningMessage { .. }, .. } +// = node_a_responses[1] {} else { panic!(); } + +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// claim_payment(&nodes[0], &[&nodes[1]], payment_preimage); + +// // Assume that LND will eventually respond to our Shutdown if we clear all the remaining HTLCs +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// // ClosingSignNegotion process +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + +// // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary +// assert!(nodes[0].node.list_channels().is_empty()); +// } + +// #[test] +// fn shutdown_on_unfunded_channel() { +// // Test receiving a shutdown prior to funding generation +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); +// let open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// // Create a dummy P2WPKH script +// let script = Builder::new().push_int(0) +// .push_slice(&[0; 20]) +// .into_script(); + +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &msgs::Shutdown { +// channel_id: open_chan.common_fields.temporary_channel_id, scriptpubkey: script, +// }); +// check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyCoopClosedUnfundedChannel, [nodes[1].node.get_our_node_id()], 1_000_000); +// } + +// #[test] +// fn close_on_unfunded_channel() { +// // Test the user asking us to close prior to funding generation +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let chan_id = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap(); +// let _open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); + +// nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); +// check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) }, [nodes[1].node.get_our_node_id()], 1_000_000); +// } + +// #[test] +// fn expect_channel_shutdown_state_with_force_closure() { +// // Test sending a shutdown prior to channel_ready after funding generation +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let error_message = "Channel force-closed"; + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); +// expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown); + +// nodes[1].node.force_close_broadcasting_latest_txn(&chan_1.2, &nodes[0].node.get_our_node_id(), error_message.to_string()).unwrap(); +// check_closed_broadcast!(nodes[1], true); +// check_added_monitors!(nodes[1], 1); + +// expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown); +// assert!(nodes[1].node.list_channels().is_empty()); + +// let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0); +// assert_eq!(node_txn.len(), 1); +// check_spends!(node_txn[0], chan_1.3); +// mine_transaction(&nodes[0], &node_txn[0]); +// check_added_monitors!(nodes[0], 1); + +// assert!(nodes[0].node.list_channels().is_empty()); +// assert!(nodes[1].node.list_channels().is_empty()); +// check_closed_broadcast!(nodes[0], true); +// check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }, [nodes[0].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn updates_shutdown_wait() { +// // Test sending a shutdown with outstanding updates pending +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); +// let logger = test_utils::TestLogger::new(); +// let scorer = test_utils::TestScorer::new(); +// let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); +// let random_seed_bytes = keys_manager.get_secure_random_bytes(); + +// let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + +// nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]); + +// let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[1].node.bolt11_invoice_features()).unwrap(); +// let route_params = RouteParameters::from_payment_params_and_value(payment_params_1, 100_000); +// let route_1 = get_route(&nodes[0].node.get_our_node_id(), &route_params, +// &nodes[0].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); +// let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), TEST_FINAL_CLTV) +// .with_bolt11_features(nodes[0].node.bolt11_invoice_features()).unwrap(); +// let route_params = RouteParameters::from_payment_params_and_value(payment_params_2, 100_000); +// let route_2 = get_route(&nodes[1].node.get_our_node_id(), &route_params, +// &nodes[1].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap(); +// unwrap_send_err!(nodes[0], nodes[0].node.send_payment_with_route(route_1, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) +// ), true, APIError::ChannelUnavailable {..}, {}); +// unwrap_send_err!(nodes[1], nodes[1].node.send_payment_with_route(route_2, payment_hash, +// RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0) +// ), true, APIError::ChannelUnavailable {..}, {}); + +// nodes[2].node.claim_funds(payment_preimage_0); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash_0, 100_000); + +// let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// check_added_monitors!(nodes[1], 1); +// let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); + +// assert!(updates_2.update_add_htlcs.is_empty()); +// assert!(updates_2.update_fail_htlcs.is_empty()); +// assert!(updates_2.update_fail_malformed_htlcs.is_empty()); +// assert!(updates_2.update_fee.is_none()); +// assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); +// expect_payment_sent!(nodes[0], payment_preimage_0); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); + +// assert!(nodes[0].node.list_channels().is_empty()); + +// assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); +// close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); +// assert!(nodes[1].node.list_channels().is_empty()); +// assert!(nodes[2].node.list_channels().is_empty()); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn htlc_fail_async_shutdown() { +// do_htlc_fail_async_shutdown(true); +// do_htlc_fail_async_shutdown(false); +// } + +// fn do_htlc_fail_async_shutdown(blinded_recipient: bool) { +// // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + +// let amt_msat = 100000; +// let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None); +// let route_params = if blinded_recipient { +// crate::ln::blinded_payment_tests::get_blinded_route_parameters( +// amt_msat, our_payment_secret, 1, 100000000, +// nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_2.0.contents], +// &chanmon_cfgs[2].keys_manager) +// } else { +// RouteParameters::from_payment_params_and_value( +// PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV), amt_msat) +// }; +// nodes[0].node.send_payment(our_payment_hash, +// RecipientOnionFields::secret_only(our_payment_secret), +// PaymentId(our_payment_hash.0), route_params, Retry::Attempts(0)).unwrap(); +// check_added_monitors!(nodes[0], 1); +// let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); +// assert_eq!(updates.update_add_htlcs.len(), 1); +// assert!(updates.update_fulfill_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); + +// nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + +// nodes[1].node.handle_update_add_htlc(nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]); +// nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); +// check_added_monitors!(nodes[1], 1); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false); +// expect_pending_htlcs_forwardable!(nodes[1]); +// expect_htlc_handling_failed_destinations!( +// nodes[1].node.get_and_clear_pending_events(), +// &[HTLCHandlingFailureType::Forward { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_2.2 }] +// ); +// check_added_monitors(&nodes[1], 1); + +// let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// assert!(updates_2.update_add_htlcs.is_empty()); +// assert!(updates_2.update_fulfill_htlcs.is_empty()); +// assert_eq!(updates_2.update_fail_htlcs.len(), 1); +// assert!(updates_2.update_fail_malformed_htlcs.is_empty()); +// assert!(updates_2.update_fee.is_none()); + +// nodes[0].node.handle_update_fail_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); + +// if blinded_recipient { +// expect_payment_failed_conditions(&nodes[0], our_payment_hash, false, +// PaymentFailedConditions::new().expected_htlc_error_data(LocalHTLCFailureReason::InvalidOnionBlinding, &[0; 32])); +// } else { +// expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true); +// } + +// let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(msg_events.len(), 1); +// let node_0_closing_signed = match msg_events[0] { +// MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { +// assert_eq!(*node_id, nodes[1].node.get_our_node_id()); +// (*msg).clone() +// }, +// _ => panic!("Unexpected event"), +// }; + +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); + +// assert!(nodes[0].node.list_channels().is_empty()); + +// assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); +// close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); +// assert!(nodes[1].node.list_channels().is_empty()); +// assert!(nodes[2].node.list_channels().is_empty()); +// check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// let event1 = ExpectedCloseEvent { +// channel_capacity_sats: Some(100000), +// channel_id: None, +// counterparty_node_id: Some(nodes[0].node.get_our_node_id()), +// discard_funding: false, +// reason: Some(ClosureReason::LocallyInitiatedCooperativeClosure), +// channel_funding_txo: None, +// user_channel_id: None, +// }; +// let event2 = ExpectedCloseEvent { +// channel_capacity_sats: Some(100000), +// channel_id: None, +// counterparty_node_id: Some(nodes[2].node.get_our_node_id()), +// discard_funding: false, +// reason: Some(ClosureReason::CounterpartyInitiatedCooperativeClosure), +// channel_funding_txo: None, +// user_channel_id: None, +// }; +// check_closed_events(&nodes[1], &[event1, event2]); +// check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// } + +// fn do_test_shutdown_rebroadcast(recv_count: u8) { +// // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of +// // messages delivered prior to disconnect +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); +// let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2); + +// let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000); + +// nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap(); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// if recv_count > 0 { +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// if recv_count > 1 { +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// } +// } + +// nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); +// nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + +// nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { +// features: nodes[1].node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); +// nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { +// features: nodes[0].node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); + +// nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_reestablish); +// let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// assert!(node_1_shutdown == node_1_2nd_shutdown); + +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_reestablish); +// let node_0_2nd_shutdown = if recv_count > 0 { +// let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); +// node_0_2nd_shutdown +// } else { +// let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id()); +// assert_eq!(node_0_chan_update.contents.channel_flags & 2, 0); // "disabled" flag must not be set as we just reconnected. +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown); +// get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()) +// }; +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown); + +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[2].node.claim_funds(payment_preimage); +// check_added_monitors!(nodes[2], 1); +// expect_payment_claimed!(nodes[2], payment_hash, 100_000); + +// let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id()); +// assert!(updates.update_add_htlcs.is_empty()); +// assert!(updates.update_fail_htlcs.is_empty()); +// assert!(updates.update_fail_malformed_htlcs.is_empty()); +// assert!(updates.update_fee.is_none()); +// assert_eq!(updates.update_fulfill_htlcs.len(), 1); +// nodes[1].node.handle_update_fulfill_htlc(nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]); +// expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false); +// check_added_monitors!(nodes[1], 1); +// let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id()); +// commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false); + +// assert!(updates_2.update_add_htlcs.is_empty()); +// assert!(updates_2.update_fail_htlcs.is_empty()); +// assert!(updates_2.update_fail_malformed_htlcs.is_empty()); +// assert!(updates_2.update_fee.is_none()); +// assert_eq!(updates_2.update_fulfill_htlcs.len(), 1); +// nodes[0].node.handle_update_fulfill_htlc(nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]); +// commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true); +// expect_payment_sent!(nodes[0], payment_preimage); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// if recv_count > 0 { +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// assert!(node_0_2nd_closing_signed.is_some()); +// } + +// nodes[0].node.peer_disconnected(nodes[1].node.get_our_node_id()); +// nodes[1].node.peer_disconnected(nodes[0].node.get_our_node_id()); + +// nodes[1].node.peer_connected(nodes[0].node.get_our_node_id(), &msgs::Init { +// features: nodes[0].node.init_features(), networks: None, remote_network_address: None +// }, true).unwrap(); +// let node_1_2nd_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap(); +// nodes[0].node.peer_connected(nodes[1].node.get_our_node_id(), &msgs::Init { +// features: nodes[1].node.init_features(), networks: None, remote_network_address: None +// }, false).unwrap(); +// if recv_count == 0 { +// // If all closing_signeds weren't delivered we can just resume where we left off... +// let node_0_2nd_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap(); + +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); +// let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(node_0_msgs.len(), 2); +// let node_0_2nd_closing_signed = match node_0_msgs[1] { +// MessageSendEvent::SendClosingSigned { ref msg, .. } => { +// assert_eq!(node_0_closing_signed, *msg); +// msg.clone() +// }, +// _ => panic!(), +// }; + +// let node_0_3rd_shutdown = match node_0_msgs[0] { +// MessageSendEvent::SendShutdown { ref msg, .. } => { +// assert_eq!(node_0_2nd_shutdown, *msg); +// msg.clone() +// }, +// _ => panic!(), +// }; +// assert!(node_0_2nd_shutdown == node_0_3rd_shutdown); + +// nodes[1].node.handle_channel_reestablish(nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish); +// let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// assert!(node_1_3rd_shutdown == node_1_2nd_shutdown); + +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown); +// assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown); + +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); +// check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } else { +// // If one node, however, received + responded with an identical closing_signed we end +// // up erroring and node[0] will try to broadcast its own latest commitment transaction. +// // There isn't really anything better we can do simply, but in the future we might +// // explore storing a set of recently-closed channels that got disconnected during +// // closing_signed and avoiding broadcasting local commitment txn for some timeout to +// // give our counterparty enough time to (potentially) broadcast a cooperative closing +// // transaction. +// assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); + +// nodes[0].node.handle_channel_reestablish(nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish); +// let msg_events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(msg_events.len(), 2); +// if let MessageSendEvent::HandleError { ref action, .. } = msg_events[1] { +// match action { +// &ErrorAction::SendErrorMessage { ref msg } => { +// nodes[1].node.handle_error(nodes[0].node.get_our_node_id(), &msg); +// assert_eq!(msg.channel_id, chan_1.2); +// }, +// _ => panic!("Unexpected event!"), +// } +// } else { panic!("Needed SendErrorMessage close"); } + +// // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and +// // checks it, but in this case nodes[1] didn't ever get a chance to receive a +// // closing_signed so we do it ourselves +// check_closed_broadcast!(nodes[1], false); +// check_added_monitors!(nodes[1], 1); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &nodes[1].node.get_our_node_id())) } +// , [nodes[0].node.get_our_node_id()], 100000); +// } + +// assert!(nodes[0].node.list_channels().is_empty()); + +// assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear(); +// close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true); +// assert!(nodes[1].node.list_channels().is_empty()); +// assert!(nodes[2].node.list_channels().is_empty()); +// check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[2].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[2], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn test_shutdown_rebroadcast() { +// do_test_shutdown_rebroadcast(0); +// do_test_shutdown_rebroadcast(1); +// do_test_shutdown_rebroadcast(2); +// } + +// #[test] +// fn test_upfront_shutdown_script() { +// // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening +// // enforce it at shutdown message + +// let mut config = UserConfig::default(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign +// let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); +// nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); +// let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); +// let mut node_0_shutdown = node_0_orig_shutdown.clone(); +// node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh(); +// // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn +// // the peer and ignore the message. +// nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.") +// .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2))); +// // This allows nodes[2] to retry the shutdown message, which should get a response: +// nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_orig_shutdown); +// get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign +// let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000); +// nodes[0].node.close_channel(&chan.2, &nodes[2].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id()); +// // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign +// nodes[2].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// let events = nodes[2].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } + +// // We test that if case of peer non-signaling we don't enforce committed script at channel opening +// let mut features = nodes[0].node.init_features(); +// features.clear_upfront_shutdown_script(); +// *nodes[0].override_init_features.borrow_mut() = Some(features); +// let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); +// nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); +// check_added_monitors!(nodes[1], 1); +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } + +// // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close +// // channel smoothly, opt-out is from channel initiator here +// *nodes[0].override_init_features.borrow_mut() = None; +// let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000); +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); +// let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } + +// //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close +// //// channel smoothly +// let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000); +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); +// let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// match events[1] { +// MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// } + +// #[test] +// fn test_unsupported_anysegwit_upfront_shutdown_script() { +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// // Clear shutdown_anysegwit on initiator +// let mut features = channelmanager::provided_init_features(&test_default_channel_config()); +// features.clear_shutdown_anysegwit(); +// *node_cfgs[0].override_init_features.borrow_mut() = Some(features); +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // Use a non-v0 segwit script supported by option_shutdown_anysegwit +// let anysegwit_shutdown_script = Builder::new() +// .push_int(16) +// .push_slice(&[0, 40]) +// .into_script(); + +// // Check script when handling an open_channel message +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); +// let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// open_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { +// assert_eq!(node_id, nodes[0].node.get_our_node_id()); +// assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); +// }, +// _ => panic!("Unexpected event"), +// } + +// let chanmon_cfgs = create_chanmon_cfgs(2); +// let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); +// // Clear shutdown_anysegwit on responder +// let mut features = channelmanager::provided_init_features(&test_default_channel_config()); +// features.clear_shutdown_anysegwit(); +// *node_cfgs[1].override_init_features.borrow_mut() = Some(features); +// let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); +// let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// // Check script when handling an accept_channel message +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); +// let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); +// let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()); +// accept_channel.common_fields.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone()); +// nodes[0].node.handle_accept_channel(nodes[1].node.get_our_node_id(), &accept_channel); + +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { +// assert_eq!(node_id, nodes[1].node.get_our_node_id()); +// assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028"); +// }, +// _ => panic!("Unexpected event"), +// } +// check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028".to_string() } +// , [nodes[1].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn test_invalid_upfront_shutdown_script() { +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap(); + +// // Use a segwit v0 script with an unsupported witness program +// let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()); +// open_channel.common_fields.shutdown_scriptpubkey = Some(Builder::new().push_int(0) +// .push_slice(&[0, 0]) +// .into_script()); +// nodes[1].node.handle_open_channel(nodes[0].node.get_our_node_id(), &open_channel); + +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => { +// assert_eq!(node_id, nodes[0].node.get_our_node_id()); +// assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_0 OP_PUSHBYTES_2 0000"); +// }, +// _ => panic!("Unexpected event"), +// } +// } + +// #[test] +// fn test_segwit_v0_shutdown_script() { +// let mut config = UserConfig::default(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); + +// // Use a segwit v0 script supported even without option_shutdown_anysegwit +// let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// node_0_shutdown.scriptpubkey = Builder::new().push_int(0) +// .push_slice(&[0; 20]) +// .into_script(); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// match events[1] { +// MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// } + +// #[test] +// fn test_anysegwit_shutdown_script() { +// let mut config = UserConfig::default(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); + +// // Use a non-v0 segwit script supported by option_shutdown_anysegwit +// let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// node_0_shutdown.scriptpubkey = Builder::new().push_int(16) +// .push_slice(&[0, 0]) +// .into_script(); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + +// let events = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 2); +// match events[0] { +// MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// match events[1] { +// MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) } +// _ => panic!("Unexpected event"), +// } +// } + +// #[test] +// fn test_unsupported_anysegwit_shutdown_script() { +// let mut config = UserConfig::default(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config.clone()), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let mut features = channelmanager::provided_init_features(&config); +// features.clear_shutdown_anysegwit(); +// *node_cfgs[0].override_init_features.borrow_mut() = Some(features.clone()); +// *node_cfgs[1].override_init_features.borrow_mut() = Some(features); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// // Check that using an unsupported shutdown script fails and a supported one succeeds. +// let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap(); +// let unsupported_witness_program = WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap(); +// let unsupported_shutdown_script = +// ShutdownScript::new_witness_program(&unsupported_witness_program).unwrap(); +// chanmon_cfgs[1].keys_manager +// .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() }) +// .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script }); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// match nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()) { +// Err(APIError::IncompatibleShutdownScript { script }) => { +// assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner()); +// }, +// Err(e) => panic!("Unexpected error: {:?}", e), +// Ok(_) => panic!("Expected error"), +// } +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); + +// // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit +// let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner(); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + +// assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), +// "Got a nonstandard scriptpubkey (60020028) from remote peer"); +// } + +// #[test] +// fn test_invalid_shutdown_script() { +// let mut config = UserConfig::default(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// nodes[1].node.close_channel(&chan.2, &nodes[0].node.get_our_node_id()).unwrap(); +// check_added_monitors!(nodes[1], 1); + +// // Use a segwit v0 script with an unsupported witness program +// let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// node_0_shutdown.scriptpubkey = Builder::new().push_int(0) +// .push_slice(&[0, 0]) +// .into_script(); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); + +// assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2), +// "Got a nonstandard scriptpubkey (00020000) from remote peer"); +// } + +// #[test] +// fn test_user_shutdown_script() { +// let mut config = test_default_channel_config(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// config.channel_handshake_config.commit_upfront_shutdown_pubkey = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// // Segwit v0 script of the form OP_0 <20-byte hash> +// let script = Builder::new().push_int(0) +// .push_slice(&[0; 20]) +// .into_script(); + +// let shutdown_script = ShutdownScript::try_from(script.clone()).unwrap(); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)).unwrap(); +// check_added_monitors!(nodes[1], 1); + +// let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// assert_eq!(node_0_shutdown.scriptpubkey, script); +// } + +// #[test] +// fn test_already_set_user_shutdown_script() { +// let mut config = test_default_channel_config(); +// config.channel_handshake_config.announce_for_forwarding = true; +// config.channel_handshake_limits.force_announced_channel_preference = false; +// let user_cfgs = [None, Some(config), None]; +// let chanmon_cfgs = create_chanmon_cfgs(3); +// let node_cfgs = create_node_cfgs(3, &chanmon_cfgs); +// let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs); +// let nodes = create_network(3, &node_cfgs, &node_chanmgrs); + +// // Segwit v0 script of the form OP_0 <20-byte hash> +// let script = Builder::new().push_int(0) +// .push_slice(&[0; 20]) +// .into_script(); + +// let shutdown_script = ShutdownScript::try_from(script).unwrap(); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// let result = nodes[1].node.close_channel_with_feerate_and_script(&chan.2, &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)); + +// assert_eq!(result, Err(APIError::APIMisuseError { err: "Cannot override shutdown script for a channel with one already set".to_string() })); +// } + +// #[derive(PartialEq)] +// enum TimeoutStep { +// AfterShutdown, +// AfterClosingSigned, +// NoTimeout, +// } + +// fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) { +// // The range-based closing signed negotiation allows the funder to restart the process with a +// // new range if the previous range did not overlap. This allows implementations to request user +// // intervention allowing users to enter a new fee range. We do not implement the sending side +// // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid +// // force-closing" value and relying on that instead. +// // +// // Here we run test the fundee side of that restart mechanism, implementing the funder side of +// // it manually. +// 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 mut nodes = create_network(2, &node_cfgs, &node_chanmgrs); +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// send_payment(&nodes[0], &[&nodes[1]], 8_000_000); + +// nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// { +// // Now we set nodes[1] to require a relatively high feerate for closing. This should result +// // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try +// // again. +// let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock *= 10; +// } + +// let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks +// // is the current prevailing feerate. +// assert!(node_0_closing_signed.fee_satoshis <= 500); + +// if timeout_step != TimeoutStep::AfterShutdown { +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id) +// .starts_with("Unable to come to consensus about closing feerate")); + +// // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which +// // nodes[1] should happily accept and respond to. +// node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10; +// { +// let mut node_0_per_peer_lock; +// let mut node_0_peer_state_lock; +// get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context_mut().closing_fee_limits.as_mut().unwrap().1 *= 10; +// } +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// if timeout_step == TimeoutStep::NoTimeout { +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap()); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// } + +// if timeout_step != TimeoutStep::NoTimeout { +// assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty()); +// } else { +// assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1); +// } + +// nodes[1].node.timer_tick_occurred(); +// nodes[1].node.timer_tick_occurred(); + +// let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); +// assert_eq!(txn.len(), 1); +// assert_eq!(txn[0].output.len(), 2); + +// if timeout_step != TimeoutStep::NoTimeout { +// assert!((txn[0].output[0].script_pubkey.is_p2wpkh() && +// txn[0].output[1].script_pubkey.is_p2wsh()) || +// (txn[0].output[1].script_pubkey.is_p2wpkh() && +// txn[0].output[0].script_pubkey.is_p2wsh())); +// check_closed_broadcast!(nodes[1], true); +// check_added_monitors!(nodes[1], 1); +// check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() } +// , [nodes[0].node.get_our_node_id()], 100000); +// } else { +// assert!(txn[0].output[0].script_pubkey.is_p2wpkh()); +// assert!(txn[0].output[1].script_pubkey.is_p2wpkh()); + +// let events = nodes[1].node.get_and_clear_pending_msg_events(); +// assert_eq!(events.len(), 1); +// match events[0] { +// MessageSendEvent::BroadcastChannelUpdate { ref msg } => { +// assert_eq!(msg.contents.channel_flags & 2, 2); +// }, +// _ => panic!("Unexpected event"), +// } +// } +// } + +// #[test] +// fn test_closing_signed_reinit_timeout() { +// do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown); +// do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned); +// do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout); +// } + +// fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) { +// // A simpe test of the legacy shutdown fee negotiation logic. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + +// if high_initiator_fee { +// // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This +// // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee. +// let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock *= 10; +// } + +// nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// node_0_closing_signed.fee_range = None; +// if high_initiator_fee { +// assert!(node_0_closing_signed.fee_satoshis > 500); +// } else { +// assert!(node_0_closing_signed.fee_satoshis < 500); +// } + +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// node_1_closing_signed.as_mut().unwrap().fee_range = None; + +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()); +// let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// assert!(node_0_none.is_none()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn simple_legacy_shutdown_test() { +// do_simple_legacy_shutdown_test(false); +// do_simple_legacy_shutdown_test(true); +// } + +// #[test] +// fn simple_target_feerate_shutdown() { +// // Simple test of target in `close_channel_with_target_feerate`. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let chan = create_announced_chan_between_nodes(&nodes, 0, 1); +// let chan_id = chan.2; + +// nodes[0].node.close_channel_with_feerate_and_script(&chan_id, &nodes[1].node.get_our_node_id(), Some(253 * 10), None).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); +// nodes[1].node.close_channel_with_feerate_and_script(&chan_id, &nodes[0].node.get_our_node_id(), Some(253 * 5), None).unwrap(); +// let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); + +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_0_shutdown); +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_1_shutdown); + +// let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &node_0_closing_signed); +// let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// let node_1_closing_signed = node_1_closing_signed_opt.unwrap(); + +// // nodes[1] was passed a target which was larger than the current channel feerate, which it +// // should ignore in favor of the channel fee, as there is no use demanding a minimum higher +// // than what will be paid on a force-close transaction. Note that we have to consider rounding, +// // so only check that we're within 10 sats. +// assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >= +// node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5); +// assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <= +// node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5); + +// // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our +// // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should +// // be the nodes[0] only available fee. +// assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, +// node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis); +// assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis, +// node_0_closing_signed.fee_satoshis); +// assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis); + +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &node_1_closing_signed); +// let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// assert!(node_0_none.is_none()); +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } + +// fn do_outbound_update_no_early_closing_signed(use_htlc: bool) { +// // Previously, if we have a pending inbound HTLC (or fee update) on a channel which has +// // initiated shutdown, we'd send our initial closing_signed immediately after receiving the +// // peer's last RAA to remove the HTLC/fee update, but before receiving their final +// // commitment_signed for a commitment without the HTLC/with the new fee. This caused at least +// // LDK peers to force-close as we initiated closing_signed prior to the channel actually being +// // fully empty of pending updates/HTLCs. +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// send_payment(&nodes[0], &[&nodes[1]], 1_000_000); +// let payment_hash_opt = if use_htlc { +// Some(route_payment(&nodes[1], &[&nodes[0]], 10_000).1) +// } else { +// None +// }; + +// if use_htlc { +// nodes[0].node.fail_htlc_backwards(&payment_hash_opt.unwrap()); +// expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[0], +// [HTLCHandlingFailureType::Receive { payment_hash: payment_hash_opt.unwrap() }]); +// } else { +// *chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap() *= 10; +// nodes[0].node.timer_tick_occurred(); +// } +// let updates = get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id()); +// check_added_monitors(&nodes[0], 1); + +// nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap(); +// let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id()); +// nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap(); +// let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id()); + +// nodes[0].node.handle_shutdown(nodes[1].node.get_our_node_id(), &node_0_shutdown); +// nodes[1].node.handle_shutdown(nodes[0].node.get_our_node_id(), &node_1_shutdown); + +// if use_htlc { +// nodes[1].node.handle_update_fail_htlc(nodes[0].node.get_our_node_id(), &updates.update_fail_htlcs[0]); +// } else { +// nodes[1].node.handle_update_fee(nodes[0].node.get_our_node_id(), &updates.update_fee.unwrap()); +// } +// nodes[1].node.handle_commitment_signed_batch_test(nodes[0].node.get_our_node_id(), &updates.commitment_signed); +// check_added_monitors(&nodes[1], 1); +// let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id()); + +// nodes[0].node.handle_revoke_and_ack(nodes[1].node.get_our_node_id(), &bs_raa); +// check_added_monitors(&nodes[0], 1); + +// // At this point the Channel on nodes[0] has no record of any HTLCs but the latest +// // broadcastable commitment does contain the HTLC (but only the ChannelMonitor knows this). +// // Thus, the channel should not yet initiate closing_signed negotiation (but previously did). +// assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); + +// chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress); +// nodes[0].node.handle_commitment_signed_batch_test(nodes[1].node.get_our_node_id(), &bs_cs); +// check_added_monitors(&nodes[0], 1); +// assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); + +// expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ResolvingHTLCs); +// assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new()); +// let (latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone(); +// nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(chan_id, latest_update); + +// let as_raa_closing_signed = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(as_raa_closing_signed.len(), 2); + +// if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &as_raa_closing_signed[0] { +// nodes[1].node.handle_revoke_and_ack(nodes[0].node.get_our_node_id(), &msg); +// check_added_monitors(&nodes[1], 1); +// if use_htlc { +// expect_payment_failed!(nodes[1], payment_hash_opt.unwrap(), true); +// } +// } else { panic!("Unexpected message {:?}", as_raa_closing_signed[0]); } + +// if let MessageSendEvent::SendClosingSigned { msg, .. } = &as_raa_closing_signed[1] { +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &msg); +// } else { panic!("Unexpected message {:?}", as_raa_closing_signed[1]); } + +// let bs_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id()); +// nodes[0].node.handle_closing_signed(nodes[1].node.get_our_node_id(), &bs_closing_signed); +// let (_, as_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id()); +// nodes[1].node.handle_closing_signed(nodes[0].node.get_our_node_id(), &as_2nd_closing_signed.unwrap()); +// let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id()); +// assert!(node_1_none.is_none()); + +// check_closed_event!(nodes[0], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[1].node.get_our_node_id()], 100000); +// check_closed_event!(nodes[1], 1, ClosureReason::LocallyInitiatedCooperativeClosure, [nodes[0].node.get_our_node_id()], 100000); +// } + +// #[test] +// fn outbound_update_no_early_closing_signed() { +// do_outbound_update_no_early_closing_signed(true); +// do_outbound_update_no_early_closing_signed(false); +// } + +// #[test] +// fn batch_funding_failure() { +// // Provides test coverage of batch funding failure, which previously deadlocked +// 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 nodes = create_network(4, &node_cfgs, &node_chanmgrs); + +// let temp_chan_id_a = exchange_open_accept_chan(&nodes[0], &nodes[1], 1_000_000, 0); +// let temp_chan_id_b = exchange_open_accept_chan(&nodes[0], &nodes[2], 1_000_000, 0); + +// let events = nodes[0].node.get_and_clear_pending_events(); +// assert_eq!(events.len(), 2); +// // Build a transaction which only has the output for one of the two channels we're trying to +// // confirm. Previously this led to a deadlock in channel closure handling. +// let mut tx = Transaction { version: Version::TWO, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() }; +// let mut chans = Vec::new(); +// for (idx, ev) in events.iter().enumerate() { +// if let Event::FundingGenerationReady { temporary_channel_id, counterparty_node_id, output_script, .. } = ev { +// if idx == 0 { +// tx.output.push(TxOut { value: Amount::from_sat(1_000_000), script_pubkey: output_script.clone() }); +// } +// chans.push((temporary_channel_id, counterparty_node_id)); +// } else { panic!(); } +// } + +// let err = "Error in transaction funding: Misuse error: No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); +// let temp_err = "No output matched the script_pubkey and value in the FundingGenerationReady event".to_string(); +// let post_funding_chan_id_a = ChannelId::v1_from_funding_txid(tx.compute_txid().as_ref(), 0); +// let close = [ +// ExpectedCloseEvent::from_id_reason(post_funding_chan_id_a, true, ClosureReason::ProcessingError { err: err.clone() }), +// ExpectedCloseEvent::from_id_reason(temp_chan_id_b, false, ClosureReason::ProcessingError { err: temp_err }), +// ]; + +// nodes[0].node.batch_funding_transaction_generated(&chans, tx).unwrap_err(); + +// let msgs = nodes[0].node.get_and_clear_pending_msg_events(); +// assert_eq!(msgs.len(), 3); +// // We currently spuriously send `FundingCreated` for the first channel and then immediately +// // fail both channels, which isn't ideal but should be fine. +// assert!(msgs.iter().any(|msg| { +// if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { +// msg: msgs::ErrorMessage { channel_id, .. }, .. +// }, .. } = msg { +// *channel_id == temp_chan_id_b +// } else { false } +// })); +// let funding_created_pos = msgs.iter().position(|msg| { +// if let MessageSendEvent::SendFundingCreated { msg: msgs::FundingCreated { temporary_channel_id, .. }, .. } = msg { +// assert_eq!(*temporary_channel_id, temp_chan_id_a); +// true +// } else { false } +// }).unwrap(); +// let funded_channel_close_pos = msgs.iter().position(|msg| { +// if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendErrorMessage { +// msg: msgs::ErrorMessage { channel_id, .. }, .. +// }, .. } = msg { +// *channel_id == post_funding_chan_id_a +// } else { false } +// }).unwrap(); + +// // The error message uses the funded channel_id so must come after the funding_created +// assert!(funded_channel_close_pos > funding_created_pos); + +// check_closed_events(&nodes[0], &close); +// assert_eq!(nodes[0].node.list_channels().len(), 0); +// } + +// #[test] +// fn test_force_closure_on_low_stale_fee() { +// // Check that we force-close channels if they have a low fee and that has gotten stale (without +// // update). +// 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); + +// let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2; + +// // Start by connecting lots of blocks to give LDK some feerate history +// for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS * 2 { +// connect_blocks(&nodes[1], 1); +// } + +// // Now connect a handful of blocks with a "high" feerate +// { +// let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock *= 2; +// } +// for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS - 1 { +// connect_blocks(&nodes[1], 1); +// } +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// // Now, note that one more block would cause us to force-close, it won't because we've dropped +// // the feerate +// { +// let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock /= 2; +// } +// connect_blocks(&nodes[1], super::channelmanager::FEERATE_TRACKING_BLOCKS as u32 * 2); +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// // Now, connect another FEERATE_TRACKING_BLOCKS - 1 blocks at a high feerate, note that none of +// // these will cause a force-closure because LDK only looks at the minimium feerate over the +// // last FEERATE_TRACKING_BLOCKS blocks. +// { +// let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap(); +// *feerate_lock *= 2; +// } + +// for _ in 0..super::channelmanager::FEERATE_TRACKING_BLOCKS - 1 { +// connect_blocks(&nodes[1], 1); +// } +// assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); + +// // Finally, connect one more block and check the force-close happened. +// connect_blocks(&nodes[1], 1); +// check_added_monitors!(nodes[1], 1); +// check_closed_broadcast(&nodes[1], 1, true); +// let reason = ClosureReason::PeerFeerateTooLow { peer_feerate_sat_per_kw: 253, required_feerate_sat_per_kw: 253 * 2 }; +// check_closed_events(&nodes[1], &[ExpectedCloseEvent::from_id_reason(chan_id, false, reason)]); +// } diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 6eb2f1d4bc7..654fffc0905 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -448,11 +448,11 @@ impl<'a> TestChainMonitor<'a> { } } - pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { - let (_, latest_update) = - self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); - self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); - } + // pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { + // let (_, latest_update) = + // self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); + // self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); + // } } impl<'a> chain::Watch for TestChainMonitor<'a> { fn watch_channel( From 82cf6088e054f856976a6eb252ba4f47fc62080c Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 16 Jun 2025 21:46:16 +0200 Subject: [PATCH 19/26] todos removed --- lightning/src/chain/chainmonitor.rs | 8 +++-- lightning/src/util/async_poll.rs | 1 + lightning/src/util/persist.rs | 49 +++++++++++++++++++++++------ 3 files changed, 45 insertions(+), 13 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 95d7736d9c9..a4759bf0429 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -392,11 +392,13 @@ where } /// See [`ChainMonitor::get_and_clear_pending_events`]. + #[cfg(any(test, feature = "_test_utils"))] pub fn get_and_clear_pending_events(&self) -> Vec { self.0.get_and_clear_pending_events() } /// See [`ChainMonitor::remove_monitor`]. + #[cfg(any(test, feature = "_test_utils"))] pub fn remove_monitor(&self, channel_id: &ChannelId) -> ChannelMonitor { self.0.remove_monitor(channel_id) } @@ -487,19 +489,19 @@ where fn watch_channel( &self, channel_id: ChannelId, monitor: ChannelMonitor, ) -> Result { - todo!() + self.0.watch_channel(channel_id, monitor) } fn update_channel( &self, channel_id: ChannelId, update: &ChannelMonitorUpdate, ) -> ChannelMonitorUpdateStatus { - todo!() + self.0.update_channel(channel_id, update) } fn release_pending_monitor_events( &self, ) -> Vec<(OutPoint, ChannelId, Vec, PublicKey)> { - todo!() + self.0.release_pending_monitor_events() } } diff --git a/lightning/src/util/async_poll.rs b/lightning/src/util/async_poll.rs index 9590ca39436..422f9e89456 100644 --- a/lightning/src/util/async_poll.rs +++ b/lightning/src/util/async_poll.rs @@ -132,6 +132,7 @@ pub trait FutureSpawner: Send + Sync + 'static { } /// A no-op implementation of `FutureSpawner` for synchronous contexts. +#[derive(Clone)] pub struct FutureSpawnerSync {} impl FutureSpawner for FutureSpawnerSync { diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index f3fb6457bad..f2a6d0cc849 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -736,37 +736,66 @@ where FE::Target: FeeEstimator; impl< - K: Deref, - L: Deref, - ES: Deref, - SP: Deref, - BI: Deref, - FE: Deref, + K: Deref + Send + Sync + 'static, + L: Deref + Send + Sync + 'static, + ES: Deref + Send + Sync + 'static, + SP: Deref + Send + Sync + 'static, + BI: Deref + Send + Sync + 'static, + FE: Deref + Send + Sync + 'static, ChannelSigner: EcdsaChannelSigner + Send + Sync, > PersistSync for MonitorUpdatingPersisterSync where K::Target: KVStoreSync, L::Target: Logger, ES::Target: EntropySource + Sized, - SP::Target: SignerProvider + Sized, + SP::Target: SignerProvider + Sync + Sized, BI::Target: BroadcasterInterface, FE::Target: FeeEstimator, { fn persist_new_channel( &self, monitor_name: MonitorName, monitor: &ChannelMonitor, ) -> Result<(), ()> { - todo!() + let mut fut = Box::pin(self.0.persist_new_channel(monitor_name, monitor)); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } } fn update_persisted_channel( &self, monitor_name: MonitorName, monitor_update: Option<&ChannelMonitorUpdate>, monitor: &ChannelMonitor, ) -> Result<(), ()> { - todo!() + let mut fut = + Box::pin(self.0.update_persisted_channel(monitor_name, monitor_update, monitor)); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } } fn archive_persisted_channel(&self, monitor_name: MonitorName) { - todo!() + let mut fut = Box::pin( + , L, ES, SP, BI, FE> as Persist< + ChannelSigner, + >>::archive_persisted_channel(&self.0, monitor_name), + ); + let mut waker = dummy_waker(); + let mut ctx = task::Context::from_waker(&mut waker); + match fut.as_mut().poll(&mut ctx) { + task::Poll::Ready(result) => result, + task::Poll::Pending => { + unreachable!("Can't poll a future in a sync context, this should never happen"); + }, + } } } From 72047fcdc1dc6925bd1d98ecd4a478835e4511af Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 11:32:22 +0200 Subject: [PATCH 20/26] try to get tests working, borrow problems --- lightning/Cargo.toml | 2 + lightning/src/ln/functional_test_utils.rs | 68 +++++ lightning/src/util/persist.rs | 340 +++++++++++----------- lightning/src/util/test_utils.rs | 90 ++++-- 4 files changed, 303 insertions(+), 197 deletions(-) diff --git a/lightning/Cargo.toml b/lightning/Cargo.toml index 94919efe66d..0bdd1236f59 100644 --- a/lightning/Cargo.toml +++ b/lightning/Cargo.toml @@ -48,6 +48,8 @@ backtrace = { version = "0.3", optional = true } libm = { version = "0.2", default-features = false } inventory = { version = "0.3", optional = true } +tokio = { version = "1.35", features = [ "macros", "rt", "rt-multi-thread", "sync", "time" ] } + [dev-dependencies] regex = "1.5.6" diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index ebed3af4880..14741423d90 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -390,6 +390,16 @@ pub struct TestChanMonCfg { pub scorer: RwLock, } +pub struct TestChanMonCfgArc { + pub tx_broadcaster: Arc, + pub fee_estimator: Arc, + pub chain_source: Arc, + pub persister: Arc, + pub logger: Arc, + pub keys_manager: Arc, + pub scorer: Arc>, +} + pub struct NodeCfg<'a> { pub chain_source: &'a test_utils::TestChainSource, pub tx_broadcaster: &'a test_utils::TestBroadcaster, @@ -3339,10 +3349,42 @@ pub fn create_chanmon_cfgs_with_keys(node_count: usize, predefined_keys_ids: Opt chan_mon_cfgs } + +pub fn create_chanmon_cfgs_with_keys_arc(node_count: usize, predefined_keys_ids: Option>) -> Vec { + let mut chan_mon_cfgs = Vec::new(); + for i in 0..node_count { + let tx_broadcaster = Arc::new(test_utils::TestBroadcaster::new(Network::Testnet)); + let fee_estimator = Arc::new(test_utils::TestFeeEstimator::new(253)); + let chain_source = Arc::new(test_utils::TestChainSource::new(Network::Testnet)); + let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i))); + let persister = Arc::new(test_utils::TestPersister::new()); + let seed = [i as u8; 32]; + let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet)); + let scorer = Arc::new(RwLock::new(test_utils::TestScorer::new())); + + // Set predefined keys_id if provided + if let Some(keys_ids) = &predefined_keys_ids { + if let Some(keys_id) = keys_ids.get(i) { + keys_manager.set_next_keys_id(*keys_id); + } + } + + chan_mon_cfgs.push(TestChanMonCfgArc { tx_broadcaster, fee_estimator, chain_source, logger, persister, keys_manager, scorer }); + } + + chan_mon_cfgs +} + pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec) -> Vec> { create_node_cfgs_with_persisters(node_count, chanmon_cfgs, chanmon_cfgs.iter().map(|c| &c.persister).collect()) } +pub fn create_node_cfgs_arc<'a>(node_count: usize, chanmon_cfgs: &'a Vec) -> Vec> { + let persisters = chanmon_cfgs.iter().map(|c| Arc::clone(&c.persister)).collect(); + + create_node_cfgs_with_persisters_arc(node_count, chanmon_cfgs, persisters) +} + pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a Vec, persisters: Vec<&'a impl test_utils::SyncPersist>) -> Vec> { let mut nodes = Vec::new(); @@ -3368,6 +3410,32 @@ pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a nodes } + +pub fn create_node_cfgs_with_persisters_arc<'a>(node_count: usize, chanmon_cfgs: &'a Vec, persisters: Vec>) -> Vec> { + let mut nodes = Vec::new(); + + for i in 0..node_count { + let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[i].chain_source), &*Arc::clone(&chanmon_cfgs[i].tx_broadcaster), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].fee_estimator, &*persisters[i], &chanmon_cfgs[i].keys_manager); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, &*Arc::clone(&chanmon_cfgs[i].logger))); + let seed = [i as u8; 32]; + nodes.push(NodeCfg { + chain_source: &chanmon_cfgs[i].chain_source, + logger: &chanmon_cfgs[i].logger, + tx_broadcaster: &chanmon_cfgs[i].tx_broadcaster, + fee_estimator: &chanmon_cfgs[i].fee_estimator, + router: test_utils::TestRouter::new(network_graph.clone(), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].scorer), + message_router: test_utils::TestMessageRouter::new(network_graph.clone(), &chanmon_cfgs[i].keys_manager), + chain_monitor, + keys_manager: &chanmon_cfgs[i].keys_manager, + node_seed: seed, + network_graph, + override_init_features: Rc::new(RefCell::new(None)), + }); + } + + nodes +} + pub fn test_default_channel_config() -> UserConfig { let mut default_config = UserConfig::default(); // Set cltv_expiry_delta slightly lower to keep the final CLTV values inside one byte in our diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index f2a6d0cc849..1aecf4606c3 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -9,7 +9,6 @@ //! and [`ChannelMonitor`] all in one place. //! //! [`ChannelManager`]: crate::ln::channelmanager::ChannelManager - use bitcoin::hashes::hex::FromHex; use bitcoin::{BlockHash, Txid}; use core::future::Future; @@ -1645,39 +1644,42 @@ mod tests { } // Exercise the `MonitorUpdatingPersister` with real channels and payments. - #[test] - fn persister_with_real_monitors() { + #[tokio::test] + async fn persister_with_real_monitors() { // This value is used later to limit how many iterations we perform. let persister_0_max_pending_updates = 7; // Intentionally set this to a smaller value to test a different alignment. let persister_1_max_pending_updates = 3; - let chanmon_cfgs = create_chanmon_cfgs(4); - let kv_store_0 = &TestStore::new(false); - let logger = &TestLogger::new(); - let persister_0 = MonitorUpdatingPersisterSync::new( + let chanmon_cfgs = create_chanmon_cfgs_with_keys_arc(4, None); + let sync_kv_store_0 = Arc::new(TestStore::new(false)); + let kv_store_0 = KVStoreSyncWrapper::new(Arc::clone(&sync_kv_store_0)); + let logger = Arc::new(TestLogger::new()); + let persister_0 = MonitorUpdatingPersister::new( kv_store_0, logger, persister_0_max_pending_updates, - &chanmon_cfgs[0].keys_manager, - &chanmon_cfgs[0].keys_manager, - &chanmon_cfgs[0].tx_broadcaster, - &chanmon_cfgs[0].fee_estimator, + Arc::clone(&chanmon_cfgs[0].keys_manager), + Arc::clone(&chanmon_cfgs[0].keys_manager), + Arc::clone(&chanmon_cfgs[0].tx_broadcaster), + Arc::clone(&chanmon_cfgs[0].fee_estimator), ); - let kv_store_1 = &TestStore::new(false); - let logger = &TestLogger::new(); - let persister_1 = MonitorUpdatingPersisterSync::new( + let sync_kv_store_1 = Arc::new(TestStore::new(false)); + let kv_store_1 = KVStoreSyncWrapper::new(Arc::clone(&sync_kv_store_1)); + + let logger = Arc::new(TestLogger::new()); + let persister_1 = MonitorUpdatingPersister::new( kv_store_1, logger, persister_1_max_pending_updates, - &chanmon_cfgs[1].keys_manager, - &chanmon_cfgs[1].keys_manager, - &chanmon_cfgs[1].tx_broadcaster, - &chanmon_cfgs[1].fee_estimator, + Arc::clone(&chanmon_cfgs[1].keys_manager), + Arc::clone(&chanmon_cfgs[1].keys_manager), + Arc::clone(&chanmon_cfgs[1].tx_broadcaster), + Arc::clone(&chanmon_cfgs[1].fee_estimator), ); - let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let mut node_cfgs = create_node_cfgs_arc(2, &chanmon_cfgs); let chain_mon_0 = test_utils::TestChainMonitor::new( Some(&chanmon_cfgs[0].chain_source), - &chanmon_cfgs[0].tx_broadcaster, + &*chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].logger, &chanmon_cfgs[0].fee_estimator, &persister_0, @@ -1685,7 +1687,7 @@ mod tests { ); let chain_mon_1 = test_utils::TestChainMonitor::new( Some(&chanmon_cfgs[1].chain_source), - &chanmon_cfgs[1].tx_broadcaster, + &*chanmon_cfgs[1].tx_broadcaster, &chanmon_cfgs[1].logger, &chanmon_cfgs[1].fee_estimator, &persister_1, @@ -1699,17 +1701,17 @@ mod tests { // Check that the persisted channel data is empty before any channels are // open. let mut persisted_chan_data_0 = - persister_0.read_all_channel_monitors_with_updates().unwrap(); + persister_0.read_all_channel_monitors_with_updates().await.unwrap(); assert_eq!(persisted_chan_data_0.len(), 0); let mut persisted_chan_data_1 = - persister_1.read_all_channel_monitors_with_updates().unwrap(); + persister_1.read_all_channel_monitors_with_updates().await.unwrap(); assert_eq!(persisted_chan_data_1.len(), 0); // Helper to make sure the channel is on the expected update ID. macro_rules! check_persisted_data { ($expected_update_id: expr) => { persisted_chan_data_0 = - persister_0.read_all_channel_monitors_with_updates().unwrap(); + persister_0.read_all_channel_monitors_with_updates().await.unwrap(); // check that we stored only one monitor assert_eq!(persisted_chan_data_0.len(), 1); for (_, mon) in persisted_chan_data_0.iter() { @@ -1718,7 +1720,7 @@ mod tests { let monitor_name = mon.persistence_key(); assert_eq!( - kv_store_0 + sync_kv_store_0 .list( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string() @@ -1730,13 +1732,13 @@ mod tests { ); } persisted_chan_data_1 = - persister_1.read_all_channel_monitors_with_updates().unwrap(); + persister_1.read_all_channel_monitors_with_updates().await.unwrap(); assert_eq!(persisted_chan_data_1.len(), 1); for (_, mon) in persisted_chan_data_1.iter() { assert_eq!(mon.get_latest_update_id(), $expected_update_id); let monitor_name = mon.persistence_key(); assert_eq!( - kv_store_1 + sync_kv_store_1 .list( CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, &monitor_name.to_string() @@ -1809,148 +1811,152 @@ mod tests { // Test that if the `MonitorUpdatingPersister`'s can't actually write, trying to persist a // monitor or update with it results in the persister returning an UnrecoverableError status. - #[test] - fn unrecoverable_error_on_write_failure() { - // Set up a dummy channel and force close. This will produce a monitor - // that we can then use to test persistence. - 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 nodes = create_network(2, &node_cfgs, &node_chanmgrs); - let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - let err_msg = "Channel force-closed".to_string(); - let node_id_0 = nodes[0].node.get_our_node_id(); - nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &node_id_0, err_msg).unwrap(); - let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - check_closed_event(&nodes[1], 1, reason, false, &[node_id_0], 100000); - { - let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); - let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap(); - let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0]; - - let kv_store = &TestStore::new(true); - let logger = &TestLogger::new(); - let ro_persister = MonitorUpdatingPersisterSync::new( - kv_store, - logger, - 11, - node_cfgs[0].keys_manager, - node_cfgs[0].keys_manager, - node_cfgs[0].tx_broadcaster, - node_cfgs[0].fee_estimator, - ); - let monitor_name = added_monitors[0].1.persistence_key(); - match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1) { - Err(()) => { - // correct result - }, - Ok(()) => { - panic!("Completed persisting new channel when shouldn't have") - }, - } - match ro_persister.update_persisted_channel( - monitor_name, - Some(cmu), - &added_monitors[0].1, - ) { - Err(()) => { - // correct result - }, - Ok(()) => { - panic!("Completed updating channel when shouldn't have") - }, - } - added_monitors.clear(); - } - nodes[1].node.get_and_clear_pending_msg_events(); - } + // #[tokio::test] + // async fn unrecoverable_error_on_write_failure() { + // // Set up a dummy channel and force close. This will produce a monitor + // // that we can then use to test persistence. + // let chanmon_cfgs = create_chanmon_cfgs_with_keys_arc(2, None); + // let node_cfgs = create_node_cfgs_arc(2, &chanmon_cfgs); + // let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + // let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + // let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + // let err_msg = "Channel force-closed".to_string(); + // let node_id_0 = nodes[0].node.get_our_node_id(); + // nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &node_id_0, err_msg).unwrap(); + // let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; + // check_closed_event(&nodes[1], 1, reason, false, &[node_id_0], 100000); + // { + // let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); + // let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap(); + // let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0]; + + // let kv_store_sync = Arc::new(TestStore::new(true)); + // let kv_store = KVStoreSyncWrapper::new(kv_store_sync); + // let logger = Arc::new(TestLogger::new()); + // let ro_persister = MonitorUpdatingPersister::new( + // kv_store, + // logger, + // 11, + // node_cfgs[0].keys_manager, + // node_cfgs[0].keys_manager, + // node_cfgs[0].tx_broadcaster, + // node_cfgs[0].fee_estimator, + // ); + // let monitor_name = added_monitors[0].1.persistence_key(); + // match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1).await { + // Err(()) => { + // // correct result + // }, + // Ok(()) => { + // panic!("Completed persisting new channel when shouldn't have") + // }, + // } + // match ro_persister + // .update_persisted_channel(monitor_name, Some(cmu), &added_monitors[0].1) + // .await + // { + // Err(()) => { + // // correct result + // }, + // Ok(()) => { + // panic!("Completed updating channel when shouldn't have") + // }, + // } + // added_monitors.clear(); + // } + // nodes[1].node.get_and_clear_pending_msg_events(); + // } // Confirm that the `clean_stale_updates` function finds and deletes stale updates. - #[test] - fn clean_stale_updates_works() { - let test_max_pending_updates = 7; - let chanmon_cfgs = create_chanmon_cfgs(3); - let kv_store_0 = &TestStore::new(false); - let logger = &TestLogger::new(); - let persister_0 = MonitorUpdatingPersisterSync::new( - kv_store_0, - logger, - test_max_pending_updates, - &chanmon_cfgs[0].keys_manager, - &chanmon_cfgs[0].keys_manager, - &chanmon_cfgs[0].tx_broadcaster, - &chanmon_cfgs[0].fee_estimator, - ); - let kv_store_1 = &TestStore::new(false); - let logger = &TestLogger::new(); - let persister_1 = MonitorUpdatingPersisterSync::new( - kv_store_1, - logger, - test_max_pending_updates, - &chanmon_cfgs[1].keys_manager, - &chanmon_cfgs[1].keys_manager, - &chanmon_cfgs[1].tx_broadcaster, - &chanmon_cfgs[1].fee_estimator, - ); - let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); - let chain_mon_0 = test_utils::TestChainMonitor::new( - Some(&chanmon_cfgs[0].chain_source), - &chanmon_cfgs[0].tx_broadcaster, - &chanmon_cfgs[0].logger, - &chanmon_cfgs[0].fee_estimator, - &persister_0, - &chanmon_cfgs[0].keys_manager, - ); - let chain_mon_1 = test_utils::TestChainMonitor::new( - Some(&chanmon_cfgs[1].chain_source), - &chanmon_cfgs[1].tx_broadcaster, - &chanmon_cfgs[1].logger, - &chanmon_cfgs[1].fee_estimator, - &persister_1, - &chanmon_cfgs[1].keys_manager, - ); - node_cfgs[0].chain_monitor = chain_mon_0; - node_cfgs[1].chain_monitor = chain_mon_1; - let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); - let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - - // Check that the persisted channel data is empty before any channels are - // open. - let persisted_chan_data = persister_0.read_all_channel_monitors_with_updates().unwrap(); - assert_eq!(persisted_chan_data.len(), 0); - - // Create some initial channel - let _ = create_announced_chan_between_nodes(&nodes, 0, 1); - - // Send a few payments to advance the updates a bit - send_payment(&nodes[0], &vec![&nodes[1]][..], 8_000_000); - send_payment(&nodes[1], &vec![&nodes[0]][..], 4_000_000); - - // Get the monitor and make a fake stale update at update_id=1 (lowest height of an update possible) - let persisted_chan_data = persister_0.read_all_channel_monitors_with_updates().unwrap(); - let (_, monitor) = &persisted_chan_data[0]; - let monitor_name = monitor.persistence_key(); - kv_store_0 - .write( - CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, - &monitor_name.to_string(), - UpdateName::from(1).as_str(), - &[0u8; 1], - ) - .unwrap(); - - // Do the stale update cleanup - persister_0.cleanup_stale_updates(false).unwrap(); - - // Confirm the stale update is unreadable/gone - assert!(kv_store_0 - .read( - CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, - &monitor_name.to_string(), - UpdateName::from(1).as_str() - ) - .is_err()); - } + // #[tokio::test] + // async fn clean_stale_updates_works() { + // let test_max_pending_updates = 7; + // let chanmon_cfgs = create_chanmon_cfgs(3); + // let kv_store_0_sync = Arc::new(TestStore::new(false)); + // let kv_store_0 = KVStoreSyncWrapper::new(kv_store_0_sync); + // let logger = Arc::new(TestLogger::new()); + // let persister_0 = MonitorUpdatingPersister::new( + // kv_store_0, + // logger, + // test_max_pending_updates, + // &chanmon_cfgs[0].keys_manager, + // &chanmon_cfgs[0].keys_manager, + // &chanmon_cfgs[0].tx_broadcaster, + // &chanmon_cfgs[0].fee_estimator, + // ); + // let kv_store_1_sync = &TestStore::new(false); + // let kv_store_1 = KVStoreSyncWrapper::new(kv_store_1_sync); + // let logger = &TestLogger::new(); + // let persister_1 = MonitorUpdatingPersister::new( + // kv_store_1, + // logger, + // test_max_pending_updates, + // &chanmon_cfgs[1].keys_manager, + // &chanmon_cfgs[1].keys_manager, + // &chanmon_cfgs[1].tx_broadcaster, + // &chanmon_cfgs[1].fee_estimator, + // ); + // let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + // let chain_mon_0 = test_utils::TestChainMonitor::new( + // Some(&chanmon_cfgs[0].chain_source), + // &chanmon_cfgs[0].tx_broadcaster, + // &chanmon_cfgs[0].logger, + // &chanmon_cfgs[0].fee_estimator, + // &persister_0, + // &chanmon_cfgs[0].keys_manager, + // ); + // let chain_mon_1 = test_utils::TestChainMonitor::new( + // Some(&chanmon_cfgs[1].chain_source), + // &chanmon_cfgs[1].tx_broadcaster, + // &chanmon_cfgs[1].logger, + // &chanmon_cfgs[1].fee_estimator, + // &persister_1, + // &chanmon_cfgs[1].keys_manager, + // ); + // node_cfgs[0].chain_monitor = chain_mon_0; + // node_cfgs[1].chain_monitor = chain_mon_1; + // let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + // let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + + // // Check that the persisted channel data is empty before any channels are + // // open. + // let persisted_chan_data = + // persister_0.read_all_channel_monitors_with_updates().await.unwrap(); + // assert_eq!(persisted_chan_data.len(), 0); + + // // Create some initial channel + // let _ = create_announced_chan_between_nodes(&nodes, 0, 1); + + // // Send a few payments to advance the updates a bit + // send_payment(&nodes[0], &vec![&nodes[1]][..], 8_000_000); + // send_payment(&nodes[1], &vec![&nodes[0]][..], 4_000_000); + + // // Get the monitor and make a fake stale update at update_id=1 (lowest height of an update possible) + // let persisted_chan_data = + // persister_0.read_all_channel_monitors_with_updates().await.unwrap(); + // let (_, monitor) = &persisted_chan_data[0]; + // let monitor_name = monitor.persistence_key(); + // kv_store_0_sync + // .write( + // CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, + // &monitor_name.to_string(), + // UpdateName::from(1).as_str(), + // &[0u8; 1], + // ) + // .unwrap(); + + // // Do the stale update cleanup + // persister_0.cleanup_stale_updates(false).await.unwrap(); + + // // Confirm the stale update is unreadable/gone + // assert!(kv_store_0_sync + // .read( + // CHANNEL_MONITOR_UPDATE_PERSISTENCE_PRIMARY_NAMESPACE, + // &monitor_name.to_string(), + // UpdateName::from(1).as_str() + // ) + // .is_err()); + // } fn persist_fn(_persist: P) -> bool where diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 654fffc0905..36d25c28349 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -15,7 +15,7 @@ use crate::chain::chaininterface; use crate::chain::chaininterface::ConfirmationTarget; #[cfg(any(test, feature = "_externalize_tests"))] use crate::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW; -use crate::chain::chainmonitor::{ChainMonitor, ChainMonitorSync, Persist, PersistSync}; +use crate::chain::chainmonitor::{ChainMonitor, Persist}; use crate::chain::channelmonitor::{ ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, MonitorEvent, }; @@ -50,7 +50,9 @@ use crate::sign; use crate::sign::{ChannelSigner, PeerStorageKey}; use crate::sync::RwLock; use crate::types::features::{ChannelFeatures, InitFeatures, NodeFeatures}; -use crate::util::async_poll::FutureSpawnerSync; +use crate::util::async_poll::AsyncResult; +use crate::util::async_poll::AsyncVoid; +use crate::util::async_poll::FutureSpawner; use crate::util::config::UserConfig; use crate::util::dyn_signer::{ DynKeysInterface, DynKeysInterfaceTrait, DynPhantomKeysInterface, DynSigner, @@ -85,6 +87,7 @@ use crate::io; use crate::prelude::*; use crate::sign::{EntropySource, NodeSigner, RandomBytes, Recipient, SignerProvider}; use crate::sync::{Arc, Mutex}; +use core::future::Future; use core::mem; use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use core::time::Duration; @@ -382,11 +385,11 @@ impl SignerProvider for OnlyReadsKeysInterface { #[cfg(feature = "std")] pub trait SyncBroadcaster: chaininterface::BroadcasterInterface + Sync {} #[cfg(feature = "std")] -pub trait SyncPersist: PersistSync + Sync {} +pub trait SyncPersist: Persist + Sync {} #[cfg(feature = "std")] impl SyncBroadcaster for T {} #[cfg(feature = "std")] -impl + Sync> SyncPersist for T {} +impl + Sync> SyncPersist for T {} #[cfg(not(feature = "std"))] pub trait SyncBroadcaster: chaininterface::BroadcasterInterface {} @@ -397,11 +400,19 @@ impl SyncBroadcaster for T {} #[cfg(not(feature = "std"))] impl> SyncPersist for T {} +#[derive(Clone)] +pub struct TokioSpawner; +impl FutureSpawner for TokioSpawner { + fn spawn + Send + 'static>(&self, future: T) { + tokio::spawn(future); + } +} + pub struct TestChainMonitor<'a> { pub added_monitors: Mutex)>>, pub monitor_updates: Mutex>>, pub latest_monitor_update_id: Mutex>, - pub chain_monitor: ChainMonitorSync< + pub chain_monitor: ChainMonitor< TestChannelSigner, &'a TestChainSource, &'a dyn SyncBroadcaster, @@ -409,6 +420,7 @@ pub struct TestChainMonitor<'a> { &'a TestLogger, &'a dyn SyncPersist, &'a TestKeysInterface, + TokioSpawner, >, pub keys_manager: &'a TestKeysInterface, /// If this is set to Some(), the next update_channel call (not watch_channel) must be a @@ -431,7 +443,7 @@ impl<'a> TestChainMonitor<'a> { added_monitors: Mutex::new(Vec::new()), monitor_updates: Mutex::new(new_hash_map()), latest_monitor_update_id: Mutex::new(new_hash_map()), - chain_monitor: ChainMonitorSync::new( + chain_monitor: ChainMonitor::new( chain_source, broadcaster, logger, @@ -439,6 +451,7 @@ impl<'a> TestChainMonitor<'a> { persister, keys_manager, keys_manager.get_peer_storage_key(), + TokioSpawner {}, ), keys_manager, expect_channel_force_closed: Mutex::new(None), @@ -448,11 +461,11 @@ impl<'a> TestChainMonitor<'a> { } } - // pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { - // let (_, latest_update) = - // self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); - // self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); - // } + pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { + let (_, latest_update) = + self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); + self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); + } } impl<'a> chain::Watch for TestChainMonitor<'a> { fn watch_channel( @@ -611,10 +624,10 @@ impl WatchtowerPersister { } #[cfg(any(test, feature = "_externalize_tests"))] -impl PersistSync for WatchtowerPersister { +impl Persist for WatchtowerPersister { fn persist_new_channel( &self, monitor_name: MonitorName, data: &ChannelMonitor, - ) -> Result<(), ()> { + ) -> AsyncResult<'static, ()> { let res = self.persister.persist_new_channel(monitor_name, data); assert!(self @@ -648,7 +661,7 @@ impl PersistSync for Watchtower fn update_persisted_channel( &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, data: &ChannelMonitor, - ) -> Result<(), ()> { + ) -> AsyncResult<'static, ()> { let res = self.persister.update_persisted_channel(monitor_name, update, data); if let Some(update) = update { @@ -689,11 +702,11 @@ impl PersistSync for Watchtower res } - fn archive_persisted_channel(&self, monitor_name: MonitorName) { - >::archive_persisted_channel( + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { + >::archive_persisted_channel( &self.persister, monitor_name, - ); + ) } } @@ -707,6 +720,7 @@ pub struct TestPersister { /// When we get an update_persisted_channel call with no ChannelMonitorUpdate, we insert the /// monitor's funding outpoint here. pub chain_sync_monitor_persistences: Mutex>, + // Map -> single shot tokio channels tokio sync one shot } impl TestPersister { pub fn new() -> Self { @@ -721,24 +735,33 @@ impl TestPersister { self.update_rets.lock().unwrap().push_back(next_ret); } } -impl PersistSync for TestPersister { +impl Persist for TestPersister { fn persist_new_channel( &self, _monitor_name: MonitorName, _data: &ChannelMonitor, - ) -> Result<(), ()> { + ) -> AsyncResult<'static, ()> { if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { - return match update_ret { - chain::ChannelMonitorUpdateStatus::Completed => Ok(()), - chain::ChannelMonitorUpdateStatus::InProgress => Err(()), - chain::ChannelMonitorUpdateStatus::UnrecoverableError => Err(()), - }; + match update_ret { + chain::ChannelMonitorUpdateStatus::Completed => {}, + chain::ChannelMonitorUpdateStatus::InProgress => { + return Box::pin(async move { + tokio::task::yield_now().await; + + Ok(()) + }); + }, + chain::ChannelMonitorUpdateStatus::UnrecoverableError => { + return Box::pin(async move { Err(()) }) + }, + } } - Ok(()) + + Box::pin(async move { Ok(()) }) } fn update_persisted_channel( &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, _data: &ChannelMonitor, - ) -> Result<(), ()> { + ) -> AsyncResult<'static, ()> { let mut ret = chain::ChannelMonitorUpdateStatus::Completed; if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { ret = update_ret; @@ -756,16 +779,23 @@ impl PersistSync for TestPersis } match ret { - chain::ChannelMonitorUpdateStatus::Completed => Ok(()), - chain::ChannelMonitorUpdateStatus::InProgress => Err(()), - chain::ChannelMonitorUpdateStatus::UnrecoverableError => Err(()), + chain::ChannelMonitorUpdateStatus::Completed => Box::pin(async move { Ok(()) }), + chain::ChannelMonitorUpdateStatus::InProgress => Box::pin(async move { + tokio::task::yield_now().await; + Ok(()) + }), + chain::ChannelMonitorUpdateStatus::UnrecoverableError => { + Box::pin(async move { Err(()) }) + }, } } - fn archive_persisted_channel(&self, monitor_name: MonitorName) { + fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { // remove the channel from the offchain_monitor_updates and chain_sync_monitor_persistences. self.offchain_monitor_updates.lock().unwrap().remove(&monitor_name); self.chain_sync_monitor_persistences.lock().unwrap().retain(|x| x != &monitor_name); + + Box::pin(async move { () }) } } From c72c8834da116c7d5500a90e7404295db51765f8 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 12:14:06 +0200 Subject: [PATCH 21/26] one shot channels for TestPersisteR --- lightning/src/util/test_utils.rs | 78 ++++++++++++++++++++------------ 1 file changed, 49 insertions(+), 29 deletions(-) diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 36d25c28349..35a79e6670a 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -57,6 +57,7 @@ use crate::util::config::UserConfig; use crate::util::dyn_signer::{ DynKeysInterface, DynKeysInterfaceTrait, DynPhantomKeysInterface, DynSigner, }; +use crate::util::errors::APIError; use crate::util::logger::{Logger, Record}; #[cfg(feature = "std")] use crate::util::mut_global::MutGlobal; @@ -82,6 +83,7 @@ use bitcoin::secp256k1::schnorr; use bitcoin::secp256k1::{self, PublicKey, Scalar, Secp256k1, SecretKey}; use lightning_invoice::RawBolt11Invoice; +use tokio::sync::oneshot; use crate::io; use crate::prelude::*; @@ -720,53 +722,78 @@ pub struct TestPersister { /// When we get an update_persisted_channel call with no ChannelMonitorUpdate, we insert the /// monitor's funding outpoint here. pub chain_sync_monitor_persistences: Mutex>, - // Map -> single shot tokio channels tokio sync one shot + + pub pending_persists: Mutex>>, } + impl TestPersister { pub fn new() -> Self { let update_rets = Mutex::new(VecDeque::new()); let offchain_monitor_updates = Mutex::new(new_hash_map()); let chain_sync_monitor_persistences = Mutex::new(VecDeque::new()); - Self { update_rets, offchain_monitor_updates, chain_sync_monitor_persistences } + Self { + update_rets, + offchain_monitor_updates, + chain_sync_monitor_persistences, + pending_persists: Mutex::new(new_hash_map()), + } } /// Queue an update status to return. pub fn set_update_ret(&self, next_ret: chain::ChannelMonitorUpdateStatus) { self.update_rets.lock().unwrap().push_back(next_ret); } -} -impl Persist for TestPersister { - fn persist_new_channel( - &self, _monitor_name: MonitorName, _data: &ChannelMonitor, + + /// Signal completion of a channel monitor update. + pub fn channel_monitor_updated( + &self, channel_id: ChannelId, update_id: u64, + ) -> Result<(), APIError> { + let tx = self.pending_persists.lock().unwrap().remove(&(channel_id, update_id)); + tx.unwrap().send(()).map_err(|_| APIError::APIMisuseError { + err: format!( + "Failed to send channel monitor update completion for channel {}, update {}", + channel_id, update_id + ), + }) + } + + fn handle_update_rets( + &self, channel_id: ChannelId, update_id: u64, ) -> AsyncResult<'static, ()> { if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { match update_ret { chain::ChannelMonitorUpdateStatus::Completed => {}, chain::ChannelMonitorUpdateStatus::InProgress => { - return Box::pin(async move { - tokio::task::yield_now().await; + let (tx, rx) = tokio::sync::oneshot::channel::<()>(); - Ok(()) - }); + self.pending_persists.lock().unwrap().insert((channel_id, update_id), tx); + + return Box::pin(async { rx.await.map_err(|_| ()) }); }, chain::ChannelMonitorUpdateStatus::UnrecoverableError => { - return Box::pin(async move { Err(()) }) + return Box::pin(async { Err(()) }) }, } } - Box::pin(async move { Ok(()) }) + Box::pin(async { Ok(()) }) + } +} + +impl Persist for TestPersister { + fn persist_new_channel( + &self, _monitor_name: MonitorName, data: &ChannelMonitor, + ) -> AsyncResult<'static, ()> { + let update_id = data.get_latest_update_id(); + let channel_id = data.channel_id(); + + self.handle_update_rets(channel_id, update_id) } fn update_persisted_channel( &self, monitor_name: MonitorName, update: Option<&ChannelMonitorUpdate>, _data: &ChannelMonitor, ) -> AsyncResult<'static, ()> { - let mut ret = chain::ChannelMonitorUpdateStatus::Completed; - if let Some(update_ret) = self.update_rets.lock().unwrap().pop_front() { - ret = update_ret; - } - if let Some(update) = update { self.offchain_monitor_updates .lock() @@ -774,20 +801,13 @@ impl Persist for TestPersister .entry(monitor_name) .or_insert(new_hash_set()) .insert(update.update_id); - } else { - self.chain_sync_monitor_persistences.lock().unwrap().push_back(monitor_name); - } - match ret { - chain::ChannelMonitorUpdateStatus::Completed => Box::pin(async move { Ok(()) }), - chain::ChannelMonitorUpdateStatus::InProgress => Box::pin(async move { - tokio::task::yield_now().await; - Ok(()) - }), - chain::ChannelMonitorUpdateStatus::UnrecoverableError => { - Box::pin(async move { Err(()) }) - }, + return self.handle_update_rets(update.channel_id.unwrap(), update.update_id); } + + self.chain_sync_monitor_persistences.lock().unwrap().push_back(monitor_name); + + return self.persist_new_channel(monitor_name, _data); } fn archive_persisted_channel(&self, monitor_name: MonitorName) -> AsyncVoid { From 0685410977452acfc6fb00c63ce95e388c729f07 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 13:41:13 +0200 Subject: [PATCH 22/26] test fixed --- lightning/src/ln/functional_test_utils.rs | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index 14741423d90..2c7b489a40f 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -3379,12 +3379,6 @@ pub fn create_node_cfgs<'a>(node_count: usize, chanmon_cfgs: &'a Vec(node_count: usize, chanmon_cfgs: &'a Vec) -> Vec> { - let persisters = chanmon_cfgs.iter().map(|c| Arc::clone(&c.persister)).collect(); - - create_node_cfgs_with_persisters_arc(node_count, chanmon_cfgs, persisters) -} - pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a Vec, persisters: Vec<&'a impl test_utils::SyncPersist>) -> Vec> { let mut nodes = Vec::new(); @@ -3411,12 +3405,16 @@ pub fn create_node_cfgs_with_persisters<'a>(node_count: usize, chanmon_cfgs: &'a } -pub fn create_node_cfgs_with_persisters_arc<'a>(node_count: usize, chanmon_cfgs: &'a Vec, persisters: Vec>) -> Vec> { + +pub fn create_node_cfgs_arc<'a>(node_count: usize, chanmon_cfgs: &'a Vec) -> Vec> { let mut nodes = Vec::new(); for i in 0..node_count { - let chain_monitor = test_utils::TestChainMonitor::new(Some(&chanmon_cfgs[i].chain_source), &*Arc::clone(&chanmon_cfgs[i].tx_broadcaster), &chanmon_cfgs[i].logger, &chanmon_cfgs[i].fee_estimator, &*persisters[i], &chanmon_cfgs[i].keys_manager); - let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, &*Arc::clone(&chanmon_cfgs[i].logger))); + let chain_monitor = test_utils::TestChainMonitor::new( + Some(&chanmon_cfgs[i].chain_source), &*chanmon_cfgs[i].tx_broadcaster, &chanmon_cfgs[i].logger, + &chanmon_cfgs[i].fee_estimator, &*chanmon_cfgs[i].persister, &chanmon_cfgs[i].keys_manager + ); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, &*chanmon_cfgs[i].logger)); let seed = [i as u8; 32]; nodes.push(NodeCfg { chain_source: &chanmon_cfgs[i].chain_source, From 80f0189182c88eb229c2e135111f95b8811662f9 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 14:49:15 +0200 Subject: [PATCH 23/26] re-rename channel_monitor_updated --- lightning/src/chain/chainmonitor.rs | 65 +++++------------------------ lightning/src/util/test_utils.rs | 10 ++--- 2 files changed, 16 insertions(+), 59 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index a4759bf0429..306165c1e3d 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -716,7 +716,7 @@ where persist_res, move || { // TODO: Log error if the monitor is not persisted. - let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, + let _ = ChainMonitor::::channel_monitor_updated(&monitors, &pending_monitor_updates_cb, &event_notifier, channel_id, max_update_id); }, future_spawner.deref(), @@ -895,56 +895,7 @@ where /// /// Returns an [`APIError::APIMisuseError`] if `funding_txo` does not match any currently /// registered [`ChannelMonitor`]s. - pub fn channel_monitor_updated( - &self, channel_id: ChannelId, completed_update_id: u64, - ) -> Result<(), APIError> { - let monitors = self.monitors.read().unwrap(); - let monitor_data = if let Some(mon) = monitors.get(&channel_id) { - mon - } else { - return Err(APIError::APIMisuseError { - err: format!("No ChannelMonitor matching channel ID {} found", channel_id), - }); - }; - let mut pending_monitor_updates = monitor_data.pending_monitor_updates.lock().unwrap(); - pending_monitor_updates.retain(|update_id| *update_id != completed_update_id); - - // Note that we only check for pending non-chainsync monitor updates and we don't track monitor - // updates resulting from chainsync in `pending_monitor_updates`. - let monitor_is_pending_updates = monitor_data.has_pending_updates(&pending_monitor_updates); - log_debug!( - self.logger, - "Completed off-chain monitor update {} for channel with channel ID {}, {}", - completed_update_id, - channel_id, - if monitor_is_pending_updates { - "still have pending off-chain updates" - } else { - "all off-chain updates complete, returning a MonitorEvent" - } - ); - if monitor_is_pending_updates { - // If there are still monitor updates pending, we cannot yet construct a - // Completed event. - return Ok(()); - } - let funding_txo = monitor_data.monitor.get_funding_txo(); - self.pending_monitor_events.lock().unwrap().push(( - funding_txo, - channel_id, - vec![MonitorEvent::Completed { - funding_txo, - channel_id, - monitor_update_id: monitor_data.monitor.get_latest_update_id(), - }], - monitor_data.monitor.get_counterparty_node_id(), - )); - - self.event_notifier.notify(); - Ok(()) - } - - fn channel_monitor_updated_internal( + fn channel_monitor_updated( monitors: &RwLock>>, pending_monitor_events: &Mutex, PublicKey)>>, event_notifier: &Notifier, channel_id: ChannelId, completed_update_id: u64, @@ -1423,8 +1374,14 @@ where persist_res, move || { // TODO: Log error if the monitor is not persisted. - let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, - channel_id, update_id); + let _ = + ChainMonitor::::channel_monitor_updated( + &monitors, + &pending_monitor_updates_cb, + &event_notifier, + channel_id, + update_id, + ); }, future_spawner.deref(), ) { @@ -1535,7 +1492,7 @@ where persist_res, move || { // TODO: Log error if the monitor is not persisted. - let _ = ChainMonitor::::channel_monitor_updated_internal(&monitors, &pending_monitor_updates_cb, &event_notifier, + let _ = ChainMonitor::::channel_monitor_updated(&monitors, &pending_monitor_updates_cb, &event_notifier, channel_id, update_id); }, future_spawner.deref(), diff --git a/lightning/src/util/test_utils.rs b/lightning/src/util/test_utils.rs index 35a79e6670a..b73d6179a25 100644 --- a/lightning/src/util/test_utils.rs +++ b/lightning/src/util/test_utils.rs @@ -463,11 +463,11 @@ impl<'a> TestChainMonitor<'a> { } } - pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { - let (_, latest_update) = - self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); - self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); - } + // pub fn complete_sole_pending_chan_update(&self, channel_id: &ChannelId) { + // let (_, latest_update) = + // self.latest_monitor_update_id.lock().unwrap().get(channel_id).unwrap().clone(); + // self.chain_monitor.channel_monitor_updated(*channel_id, latest_update).unwrap(); + // } } impl<'a> chain::Watch for TestChainMonitor<'a> { fn watch_channel( From 4490f376831b80c4cec45817e6670abcd6535b92 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 15:18:10 +0200 Subject: [PATCH 24/26] wip --- lightning/src/chain/chainmonitor.rs | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 306165c1e3d..4ad9dfee6fb 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -1669,8 +1669,8 @@ mod tests { const CHAINSYNC_MONITOR_PARTITION_FACTOR: u32 = 5; - #[test] - fn test_async_ooo_offchain_updates() { + #[tokio::test] + async fn test_async_ooo_offchain_updates() { // Test that if we have multiple offchain updates being persisted and they complete // out-of-order, the ChainMonitor waits until all have completed before informing the // ChannelManager. @@ -1724,12 +1724,21 @@ mod tests { .unwrap() .1 .contains(&next_update)); + // TODO: RE-ENABLE // nodes[1] // .chain_monitor // .chain_monitor // .channel_monitor_updated(channel_id, next_update.clone()) // .unwrap(); + + // Race condition here? + chanmon_cfgs[1].persister.channel_monitor_updated(channel_id, next_update.clone()).unwrap(); + + // Sleep 1s + // tokio::time::sleep(std::time::Duration::from_secs(1)).await; + tokio::task::yield_now().await; + // Should not contain the previously pending next_update when pending updates listed. #[cfg(not(c_bindings))] assert!(!nodes[1] @@ -1758,6 +1767,13 @@ mod tests { // .chain_monitor // .channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()) // .unwrap(); + chanmon_cfgs[1] + .persister + .channel_monitor_updated(channel_id, update_iter.next().unwrap().clone()) + .unwrap(); + + tokio::task::yield_now().await; + //tokio::time::sleep(std::time::Duration::from_secs(1)).await; let claim_events = nodes[1].node.get_and_clear_pending_events(); assert_eq!(claim_events.len(), 2); From 8f66fb480c2b0e50d94a114cc89570e889400ba9 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 15:29:26 +0200 Subject: [PATCH 25/26] wip 2 --- lightning/src/util/persist.rs | 110 +++++++++++++++++----------------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index 1aecf4606c3..ccdb61e6380 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -1811,61 +1811,61 @@ mod tests { // Test that if the `MonitorUpdatingPersister`'s can't actually write, trying to persist a // monitor or update with it results in the persister returning an UnrecoverableError status. - // #[tokio::test] - // async fn unrecoverable_error_on_write_failure() { - // // Set up a dummy channel and force close. This will produce a monitor - // // that we can then use to test persistence. - // let chanmon_cfgs = create_chanmon_cfgs_with_keys_arc(2, None); - // let node_cfgs = create_node_cfgs_arc(2, &chanmon_cfgs); - // let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); - // let nodes = create_network(2, &node_cfgs, &node_chanmgrs); - // let chan = create_announced_chan_between_nodes(&nodes, 0, 1); - // let err_msg = "Channel force-closed".to_string(); - // let node_id_0 = nodes[0].node.get_our_node_id(); - // nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &node_id_0, err_msg).unwrap(); - // let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; - // check_closed_event(&nodes[1], 1, reason, false, &[node_id_0], 100000); - // { - // let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); - // let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap(); - // let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0]; - - // let kv_store_sync = Arc::new(TestStore::new(true)); - // let kv_store = KVStoreSyncWrapper::new(kv_store_sync); - // let logger = Arc::new(TestLogger::new()); - // let ro_persister = MonitorUpdatingPersister::new( - // kv_store, - // logger, - // 11, - // node_cfgs[0].keys_manager, - // node_cfgs[0].keys_manager, - // node_cfgs[0].tx_broadcaster, - // node_cfgs[0].fee_estimator, - // ); - // let monitor_name = added_monitors[0].1.persistence_key(); - // match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1).await { - // Err(()) => { - // // correct result - // }, - // Ok(()) => { - // panic!("Completed persisting new channel when shouldn't have") - // }, - // } - // match ro_persister - // .update_persisted_channel(monitor_name, Some(cmu), &added_monitors[0].1) - // .await - // { - // Err(()) => { - // // correct result - // }, - // Ok(()) => { - // panic!("Completed updating channel when shouldn't have") - // }, - // } - // added_monitors.clear(); - // } - // nodes[1].node.get_and_clear_pending_msg_events(); - // } + #[tokio::test] + async fn unrecoverable_error_on_write_failure() { + // Set up a dummy channel and force close. This will produce a monitor + // that we can then use to test persistence. + let chanmon_cfgs = create_chanmon_cfgs_with_keys_arc(2, None); + let node_cfgs = create_node_cfgs_arc(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let chan = create_announced_chan_between_nodes(&nodes, 0, 1); + let err_msg = "Channel force-closed".to_string(); + let node_id_0 = nodes[0].node.get_our_node_id(); + nodes[1].node.force_close_broadcasting_latest_txn(&chan.2, &node_id_0, err_msg).unwrap(); + let reason = ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(true) }; + check_closed_event(&nodes[1], 1, reason, false, &[node_id_0], 100000); + { + let mut added_monitors = nodes[1].chain_monitor.added_monitors.lock().unwrap(); + let cmu_map = nodes[1].chain_monitor.monitor_updates.lock().unwrap(); + let cmu = &cmu_map.get(&added_monitors[0].1.channel_id()).unwrap()[0]; + + let kv_store_sync = Arc::new(TestStore::new(true)); + let kv_store = KVStoreSyncWrapper::new(kv_store_sync); + let logger = Arc::new(TestLogger::new()); + let ro_persister = MonitorUpdatingPersister::new( + kv_store, + logger, + 11, + node_cfgs[0].keys_manager, + node_cfgs[0].keys_manager, + node_cfgs[0].tx_broadcaster, + node_cfgs[0].fee_estimator, + ); + let monitor_name = added_monitors[0].1.persistence_key(); + match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1).await { + Err(()) => { + // correct result + }, + Ok(()) => { + panic!("Completed persisting new channel when shouldn't have") + }, + } + // match ro_persister + // .update_persisted_channel(monitor_name, Some(cmu), &added_monitors[0].1) + // .await + // { + // Err(()) => { + // // correct result + // }, + // Ok(()) => { + // panic!("Completed updating channel when shouldn't have") + // }, + // } + // added_monitors.clear(); + } + nodes[1].node.get_and_clear_pending_msg_events(); + } // Confirm that the `clean_stale_updates` function finds and deletes stale updates. // #[tokio::test] From 5e844b9205c469b586035cd320a1e95318286487 Mon Sep 17 00:00:00 2001 From: Joost Jager Date: Mon, 23 Jun 2025 15:44:35 +0200 Subject: [PATCH 26/26] test fixed --- lightning/src/util/persist.rs | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/lightning/src/util/persist.rs b/lightning/src/util/persist.rs index ccdb61e6380..11d8113d562 100644 --- a/lightning/src/util/persist.rs +++ b/lightning/src/util/persist.rs @@ -1837,10 +1837,10 @@ mod tests { kv_store, logger, 11, - node_cfgs[0].keys_manager, - node_cfgs[0].keys_manager, - node_cfgs[0].tx_broadcaster, - node_cfgs[0].fee_estimator, + Arc::clone(&chanmon_cfgs[0].keys_manager), + Arc::clone(&chanmon_cfgs[0].keys_manager), + Arc::clone(&chanmon_cfgs[0].tx_broadcaster), + Arc::clone(&chanmon_cfgs[0].fee_estimator), ); let monitor_name = added_monitors[0].1.persistence_key(); match ro_persister.persist_new_channel(monitor_name, &added_monitors[0].1).await { @@ -1851,18 +1851,18 @@ mod tests { panic!("Completed persisting new channel when shouldn't have") }, } - // match ro_persister - // .update_persisted_channel(monitor_name, Some(cmu), &added_monitors[0].1) - // .await - // { - // Err(()) => { - // // correct result - // }, - // Ok(()) => { - // panic!("Completed updating channel when shouldn't have") - // }, - // } - // added_monitors.clear(); + match ro_persister + .update_persisted_channel(monitor_name, Some(cmu), &added_monitors[0].1) + .await + { + Err(()) => { + // correct result + }, + Ok(()) => { + panic!("Completed updating channel when shouldn't have") + }, + } + added_monitors.clear(); } nodes[1].node.get_and_clear_pending_msg_events(); }