Merge pull request #674 from TheBlueMatt/2020-08-keyif-rand-names

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

diff --git a/lightning/src/chain/chaininterface.rs b/lightning/src/chain/chaininterface.rs
index 5cd87c49f6df717f017802363782e348bc1664f7..644c3214aca9f464d4a99a628ea6cba072c2f0ba 100644 (file)
--- a/lightning/src/chain/chaininterface.rs
+++ b/lightning/src/chain/chaininterface.rs
@@ -1,3 +1,12 @@
+// This file is Copyright its original authors, visible in version control
+// history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
+// or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
+// You may not use this file except in accordance with one or both of these
+// licenses.
+
 //! Traits and utility impls which allow other parts of rust-lightning to interact with the
 //! blockchain.
 //!
@@ -53,9 +62,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 +95,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)
@@ -277,8 +286,12 @@ impl<'a, CL: Deref<Target = ChainListener + 'a> + 'a, C: Deref> BlockNotifier<'a
        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 +301,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 +370,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 {