Fetch latest commitment txn via monitor, not channel in test

[rust-lightning] / lightning / src / ln / functional_test_utils.rs

diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
index ba918f82e860bf572b16dd886875743c315b1cd0..2da764b300b8bc2425aa7ff252fbba3749cdb7e9 100644 (file)
--- a/lightning/src/ln/functional_test_utils.rs
+++ b/lightning/src/ln/functional_test_utils.rs
@@ -131,14 +131,16 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> {
                        // same set of outputs to watch for on chain as we have now. Note that if we write
                        // tests that fully close channels and remove the monitors at some point this may break.
                        let feeest = test_utils::TestFeeEstimator { sat_per_kw: 253 };
-                       let old_monitors = self.chan_monitor.simple_monitor.monitors.lock().unwrap();
                        let mut deserialized_monitors = Vec::new();
-                       for (_, old_monitor) in old_monitors.iter() {
-                               let mut w = test_utils::TestVecWriter(Vec::new());
-                               old_monitor.write_for_disk(&mut w).unwrap();
-                               let (_, deserialized_monitor) = <(Sha256d, ChannelMonitor<EnforcingChannelKeys>)>::read(
-                                       &mut ::std::io::Cursor::new(&w.0), Arc::clone(&self.logger) as Arc<Logger>).unwrap();
-                               deserialized_monitors.push(deserialized_monitor);
+                       {
+                               let old_monitors = self.chan_monitor.simple_monitor.monitors.lock().unwrap();
+                               for (_, old_monitor) in old_monitors.iter() {
+                                       let mut w = test_utils::TestVecWriter(Vec::new());
+                                       old_monitor.write_for_disk(&mut w).unwrap();
+                                       let (_, deserialized_monitor) = <(Sha256d, ChannelMonitor<EnforcingChannelKeys>)>::read(
+                                               &mut ::std::io::Cursor::new(&w.0), Arc::clone(&self.logger) as Arc<Logger>).unwrap();
+                                       deserialized_monitors.push(deserialized_monitor);
+                               }
                        }
 
                        // Before using all the new monitors to check the watch outpoints, use the full set of
@@ -255,6 +257,22 @@ macro_rules! get_feerate {
        }
 }
 
+macro_rules! get_local_commitment_txn {
+       ($node: expr, $channel_id: expr) => {
+               {
+                       let mut monitors = $node.chan_monitor.simple_monitor.monitors.lock().unwrap();
+                       let mut commitment_txn = None;
+                       for (funding_txo, monitor) in monitors.iter_mut() {
+                               if funding_txo.to_channel_id() == $channel_id {
+                                       commitment_txn = Some(monitor.get_latest_local_commitment_txn());
+                                       break;
+                               }
+                       }
+                       commitment_txn.unwrap()
+               }
+       }
+}
+
 pub fn create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, expected_chan_value: u64, expected_user_chan_id: u64) -> ([u8; 32], Transaction, OutPoint) {
        let chan_id = *node.network_chan_count.borrow();
 
@@ -1098,9 +1116,9 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha
 /// HTLC transaction.
 pub fn test_revoked_htlc_claim_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, revoked_tx: Transaction, commitment_revoked_tx: Transaction)  {
        let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
-       // We should issue a 2nd transaction if one htlc is dropped from initial claiming tx
-       // but sometimes not as feerate is too-low
-       if node_txn.len() != 1 && node_txn.len() != 2 { assert!(false); }
+       // We may issue multiple claiming transaction on revoked outputs due to block rescan
+       // for revoked htlc outputs
+       if node_txn.len() != 1 && node_txn.len() != 2 && node_txn.len() != 3 { assert!(false); }
        node_txn.retain(|tx| {
                if tx.input.len() == 1 && tx.input[0].previous_output.txid == revoked_tx.txid() {
                        check_spends!(tx, revoked_tx);