Expose the script_pubkey being monitored in chain watch (fixes #44)

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

diff --git a/src/chain/chaininterface.rs b/src/chain/chaininterface.rs
index f456afda691b023c3285ffe466aecb9bfd411f76..f99f581f133a4fea18642c152444418d250a25f1 100644 (file)
--- a/src/chain/chaininterface.rs
+++ b/src/chain/chaininterface.rs
@@ -16,7 +16,7 @@ pub trait ChainWatchInterface: Sync + Send {
 
        /// Provides an outpoint which must be watched for, providing any transactions which spend the
        /// given outpoint.
-       fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32));
+       fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32), out_script: &Script);
 
        /// Indicates that a listener needs to see all transactions.
        fn watch_all_txn(&self);
@@ -25,11 +25,9 @@ pub trait ChainWatchInterface: Sync + Send {
        //TODO: unregister
 }
 
-/// An interface to send a transaction to connected Bitcoin peers.
-/// This is for final settlement. An error might indicate that no peers can be reached or
-/// that peers rejected the transaction.
+/// An interface to send a transaction to the Bitcoin network.
 pub trait BroadcasterInterface: Sync + Send {
-       /// Sends a transaction out to (hopefully) be mined
+       /// Sends a transaction out to (hopefully) be mined.
        fn broadcast_transaction(&self, tx: &Transaction);
 }
 
@@ -78,7 +76,7 @@ impl ChainWatchInterface for ChainWatchInterfaceUtil {
                self.reentered.fetch_add(1, Ordering::Relaxed);
        }
 
-       fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32)) {
+       fn install_watch_outpoint(&self, outpoint: (Sha256dHash, u32), _out_script: &Script) {
                let mut watched = self.watched.lock().unwrap();
                watched.1.push(outpoint);
                self.reentered.fetch_add(1, Ordering::Relaxed);
@@ -105,8 +103,9 @@ impl ChainWatchInterfaceUtil {
                }
        }
 
-       /// notify listener that a block was connected
-       /// notification will repeat if notified listener register new listeners
+       /// Notify listeners that a block was connected.
+       /// 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_with_filtering(&self, block: &Block, height: u32) {
                let mut reentered = true;
                while reentered {
@@ -125,7 +124,7 @@ impl ChainWatchInterfaceUtil {
                }
        }
 
-       /// notify listener that a block was disconnected
+       /// Notify listeners that a block was disconnected.
        pub fn block_disconnected(&self, header: &BlockHeader) {
                let listeners = self.listeners.lock().unwrap().clone();
                for listener in listeners.iter() {
@@ -136,8 +135,10 @@ impl ChainWatchInterfaceUtil {
                }
        }
 
-       /// call listeners for connected blocks if they are still around.
-       /// returns true if notified listeners registered additional listener
+       /// Notify listeners that a block was connected.
+       /// 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 {
                let last_seen = self.reentered.load(Ordering::Relaxed);
 
@@ -151,13 +152,13 @@ impl ChainWatchInterfaceUtil {
                return last_seen != self.reentered.load(Ordering::Relaxed);
        }
 
-       /// Checks if a given transaction matches the current filter
+       /// Checks if a given transaction matches the current filter.
        pub fn does_match_tx(&self, tx: &Transaction) -> bool {
                let watched = self.watched.lock().unwrap();
                self.does_match_tx_unguarded (tx, &watched)
        }
 
-       fn does_match_tx_unguarded (&self, tx: &Transaction, watched: &MutexGuard<(Vec<Script>, Vec<(Sha256dHash, u32)>, bool)>) -> bool {
+       fn does_match_tx_unguarded(&self, tx: &Transaction, watched: &MutexGuard<(Vec<Script>, Vec<(Sha256dHash, u32)>, bool)>) -> bool {
                if watched.2 {
                        return true;
                }