Merge pull request #658 from lightning-signer/self-delay

[rust-lightning] / lightning / src / chain / chaininterface.rs

diff --git a/lightning/src/chain/chaininterface.rs b/lightning/src/chain/chaininterface.rs
index 89c57dc44c06a39ce0067f8572fc6cdba7da2de6..2e874296f5ab94d363c9244db192fa72a3bfb76d 100644 (file)
--- a/lightning/src/chain/chaininterface.rs
+++ b/lightning/src/chain/chaininterface.rs
@@ -53,9 +53,9 @@ pub trait ChainWatchInterface: Sync + Send {
        /// final two the output within the transaction.
        fn get_chain_utxo(&self, genesis_hash: BlockHash, unspent_tx_output_identifier: u64) -> Result<(Script, u64), ChainError>;
 
-       /// Gets the list of transactions and transaction indices that the ChainWatchInterface is
+       /// Gets the list of transaction indices within a given block that the ChainWatchInterface is
        /// watching for.
-       fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>);
+       fn filter_block(&self, block: &Block) -> Vec<usize>;
 
        /// Returns a usize that changes when the ChainWatchInterface's watched data is modified.
        /// Users of `filter_block` should pre-save a copy of `reentered`'s return value and use it to
@@ -86,7 +86,7 @@ pub trait ChainListener: Sync + Send {
        ///
        /// This also means those counting confirmations using block_connected callbacks should watch
        /// for duplicate headers and not count them towards confirmations!
-       fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]);
+       fn block_connected(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[usize]);
        /// Notifies a listener that a block was disconnected.
        /// Unlike block_connected, this *must* never be called twice for the same disconnect event.
        /// Height must be the one of the block which was disconnected (not new height of the best chain)
@@ -274,11 +274,15 @@ impl<'a, CL: Deref<Target = ChainListener + 'a> + 'a, C: Deref> BlockNotifier<'a
        ///
        /// Handles re-scanning the block and calling block_connected again if listeners register new
        /// watch data during the callbacks for you (see ChainListener::block_connected for more info).
-       pub fn block_connected<'b>(&self, block: &'b Block, height: u32) {
+       pub fn block_connected(&self, block: &Block, height: u32) {
                let mut reentered = true;
                while reentered {
-                       let (matched, matched_index) = self.chain_monitor.filter_block(block);
-                       reentered = self.block_connected_checked(&block.header, height, matched.as_slice(), matched_index.as_slice());
+                       let matched_indexes = self.chain_monitor.filter_block(block);
+                       let mut matched_txn = Vec::new();
+                       for index in matched_indexes.iter() {
+                               matched_txn.push(&block.txdata[*index]);
+                       }
+                       reentered = self.block_connected_checked(&block.header, height, matched_txn.as_slice(), matched_indexes.as_slice());
                }
        }
 
@@ -288,7 +292,7 @@ impl<'a, CL: Deref<Target = ChainListener + 'a> + 'a, C: Deref> BlockNotifier<'a
        /// Returns true if notified listeners registered additional watch data (implying that the
        /// block must be re-scanned and this function called again prior to further block_connected
        /// calls, see ChainListener::block_connected for more info).
-       pub fn block_connected_checked(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[u32]) -> bool {
+       pub fn block_connected_checked(&self, header: &BlockHeader, height: u32, txn_matched: &[&Transaction], indexes_of_txn_matched: &[usize]) -> bool {
                let last_seen = self.chain_monitor.reentered();
 
                let listeners = self.listeners.lock().unwrap();
@@ -357,19 +361,17 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil {
                Err(ChainError::NotSupported)
        }
 
-       fn filter_block<'a>(&self, block: &'a Block) -> (Vec<&'a Transaction>, Vec<u32>) {
-               let mut matched = Vec::new();
+       fn filter_block(&self, block: &Block) -> Vec<usize> {
                let mut matched_index = Vec::new();
                {
                        let watched = self.watched.lock().unwrap();
                        for (index, transaction) in block.txdata.iter().enumerate() {
                                if self.does_match_tx_unguarded(transaction, &watched) {
-                                       matched.push(transaction);
-                                       matched_index.push(index as u32);
+                                       matched_index.push(index);
                                }
                        }
                }
-               (matched, matched_index)
+               matched_index
        }
 
        fn reentered(&self) -> usize {