]> git.bitcoin.ninja Git - rust-lightning/commitdiff
f - more descriptive var names + outpoints, not txn 2018-09-159-clarification-cleanup
authorMatt Corallo <git@bluematt.me>
Fri, 7 Sep 2018 15:39:37 +0000 (11:39 -0400)
committerMatt Corallo <git@bluematt.me>
Fri, 7 Sep 2018 17:34:58 +0000 (13:34 -0400)
src/ln/channelmanager.rs
src/ln/channelmonitor.rs

index 600342f0b35126b02d0ee5d03d0d4c80d7c4ef82..1d69420ce3aecbea3f2ff761bd028dcebab0116b 100644 (file)
@@ -3297,7 +3297,8 @@ mod tests {
                        nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
                        {
                                let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
-                               assert_eq!(node_txn.len(), 2);
+                               assert_eq!(node_txn.len(), 3);
+                               assert_eq!(node_txn.pop().unwrap(), node_txn[0]); // An outpoint registration will result in a 2nd block_connected
                                assert_eq!(node_txn[0].input.len(), 1);
 
                                let mut funding_tx_map = HashMap::new();
index 66780b30c6f0b828cff456c808f219dbe4bd25c6..ddcaa5d249e2c6a69819a7ea6a813070373b0cc7 100644 (file)
@@ -69,9 +69,11 @@ impl<Key : Send + cmp::Eq + hash::Hash> ChainListener for SimpleManyChannelMonit
        fn block_connected(&self, _header: &BlockHeader, height: u32, txn_matched: &[&Transaction], _indexes_of_txn_matched: &[u32]) {
                let monitors = self.monitors.lock().unwrap();
                for monitor in monitors.values() {
-                       let outputs = monitor.block_connected(txn_matched, height, &*self.broadcaster);
-                       for output in outputs {
-                               self.chain_monitor.install_watch_script(&output.script_pubkey);
+                       let txn_outputs = monitor.block_connected(txn_matched, height, &*self.broadcaster);
+                       for (ref txid, ref outputs) in txn_outputs {
+                               for (idx, output) in outputs.iter().enumerate() {
+                                       self.chain_monitor.install_watch_outpoint((txid.clone(), idx as u32), &output.script_pubkey);
+                               }
                        }
                }
        }
@@ -467,7 +469,7 @@ impl ChannelMonitor {
        /// optional, without it this monitor cannot be used in an SPV client, but you may wish to
        /// avoid this (or call unset_funding_info) on a monitor you wish to send to a watchtower as it
        /// provides slightly better privacy.
-       /// It is the responsability of the caller to register outpoint and script with passing the former 
+       /// It is the responsability of the caller to register outpoint and script with passing the former
        /// value as key to update current monitor
        pub(super) fn set_funding_info(&mut self, funding_info: (OutPoint, Script)) {
                self.funding_txo = Some(funding_info);
@@ -912,23 +914,24 @@ impl ChannelMonitor {
        /// height > height + CLTV_SHARED_CLAIM_BUFFER. In any case, will install monitoring for
        /// HTLC-Success/HTLC-Timeout transactions, and claim them using the revocation key (if
        /// applicable) as well.
-       fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec<Transaction>, Vec<TxOut>) {
+       fn check_spend_remote_transaction(&self, tx: &Transaction, height: u32) -> (Vec<Transaction>, (Sha256dHash, Vec<TxOut>)) {
                // Most secp and related errors trying to create keys means we have no hope of constructing
                // a spend transaction...so we return no transactions to broadcast
                let mut txn_to_broadcast = Vec::new();
-               let mut outputs = Vec::new();
+               let mut watch_outputs = Vec::new();
+
+               let commitment_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers!
+               let per_commitment_option = self.remote_claimable_outpoints.get(&commitment_txid);
+
                macro_rules! ignore_error {
                        ( $thing : expr ) => {
                                match $thing {
                                        Ok(a) => a,
-                                       Err(_) => return (txn_to_broadcast, outputs)
+                                       Err(_) => return (txn_to_broadcast, (commitment_txid, watch_outputs))
                                }
                        };
                }
 
-               let commitment_txid = tx.txid(); //TODO: This is gonna be a performance bottleneck for watchtowers!
-               let per_commitment_option = self.remote_claimable_outpoints.get(&commitment_txid);
-
                let commitment_number = 0xffffffffffff - ((((tx.input[0].sequence as u64 & 0xffffff) << 3*8) | (tx.lock_time as u64 & 0xffffff)) ^ self.commitment_transaction_number_obscure_factor);
                if commitment_number >= self.get_min_seen_secret() {
                        let secret = self.get_secret(commitment_number).unwrap();
@@ -947,7 +950,7 @@ impl ChannelMonitor {
                        };
                        let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.delayed_payment_base_key));
                        let a_htlc_key = match self.their_htlc_base_key {
-                               None => return (txn_to_broadcast, outputs),
+                               None => return (txn_to_broadcast, (commitment_txid, watch_outputs)),
                                Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &their_htlc_base_key)),
                        };
 
@@ -1014,7 +1017,7 @@ impl ChannelMonitor {
                                        if htlc.transaction_output_index as usize >= tx.output.len() ||
                                                        tx.output[htlc.transaction_output_index as usize].value != htlc.amount_msat / 1000 ||
                                                        tx.output[htlc.transaction_output_index as usize].script_pubkey != expected_script.to_v0_p2wsh() {
-                                               return (txn_to_broadcast, outputs); // Corrupted per_commitment_data, fuck this user
+                                               return (txn_to_broadcast, (commitment_txid, watch_outputs)); // Corrupted per_commitment_data, fuck this user
                                        }
                                        let input = TxIn {
                                                previous_output: BitcoinOutPoint {
@@ -1049,10 +1052,10 @@ impl ChannelMonitor {
 
                        if !inputs.is_empty() || !txn_to_broadcast.is_empty() { // ie we're confident this is actually ours
                                // We're definitely a remote commitment transaction!
-                               outputs.append(&mut tx.output.clone());
+                               watch_outputs.append(&mut tx.output.clone());
                                self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
                        }
-                       if inputs.is_empty() { return (txn_to_broadcast, outputs); } // Nothing to be done...probably a false positive/local tx
+                       if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs)); } // Nothing to be done...probably a false positive/local tx
 
                        let outputs = vec!(TxOut {
                                script_pubkey: self.destination_script.clone(),
@@ -1082,7 +1085,7 @@ impl ChannelMonitor {
                        // already processed the block, resulting in the remote_commitment_txn_on_chain entry
                        // not being generated by the above conditional. Thus, to be safe, we go ahead and
                        // insert it here.
-                       outputs.append(&mut tx.output.clone());
+                       watch_outputs.append(&mut tx.output.clone());
                        self.remote_commitment_txn_on_chain.lock().unwrap().insert(commitment_txid, commitment_number);
 
                        if let Some(revocation_points) = self.their_cur_revocation_points {
@@ -1103,7 +1106,7 @@ impl ChannelMonitor {
                                                },
                                        };
                                        let a_htlc_key = match self.their_htlc_base_key {
-                                               None => return (txn_to_broadcast, outputs),
+                                               None => return (txn_to_broadcast, (commitment_txid, watch_outputs)),
                                                Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &their_htlc_base_key)),
                                        };
 
@@ -1166,7 +1169,7 @@ impl ChannelMonitor {
                                                }
                                        }
 
-                                       if inputs.is_empty() { return (txn_to_broadcast, outputs); } // Nothing to be done...probably a false positive/local tx
+                                       if inputs.is_empty() { return (txn_to_broadcast, (commitment_txid, watch_outputs)); } // Nothing to be done...probably a false positive/local tx
 
                                        let outputs = vec!(TxOut {
                                                script_pubkey: self.destination_script.clone(),
@@ -1194,7 +1197,7 @@ impl ChannelMonitor {
                        //TODO: For each input check if its in our remote_commitment_txn_on_chain map!
                }
 
-               (txn_to_broadcast, outputs)
+               (txn_to_broadcast, (commitment_txid, watch_outputs))
        }
 
        fn broadcast_by_local_state(&self, local_tx: &LocalSignedTx) -> Vec<Transaction> {
@@ -1255,13 +1258,15 @@ impl ChannelMonitor {
                Vec::new()
        }
 
-       fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface) -> Vec<TxOut> {
-               let mut outputs = Vec::new();
+       fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface)-> Vec<(Sha256dHash, Vec<TxOut>)> {
+               let mut watch_outputs = Vec::new();
                for tx in txn_matched {
                        for txin in tx.input.iter() {
                                if self.funding_txo.is_none() || (txin.previous_output.txid == self.funding_txo.as_ref().unwrap().0.txid && txin.previous_output.vout == self.funding_txo.as_ref().unwrap().0.index as u32) {
-                                       let (mut txn, out) = self.check_spend_remote_transaction(tx, height);
-                                       outputs = out;
+                                       let (mut txn, new_outputs) = self.check_spend_remote_transaction(tx, height);
+                                       if !new_outputs.1.is_empty() {
+                                               watch_outputs.push(new_outputs);
+                                       }
                                        if txn.is_empty() {
                                                txn = self.check_spend_local_transaction(tx, height);
                                        }
@@ -1288,7 +1293,7 @@ impl ChannelMonitor {
                                }
                        }
                }
-               outputs
+               watch_outputs
        }
 
        pub fn would_broadcast_at_height(&self, height: u32) -> bool {