From: Jeffrey Czyz Date: Mon, 1 Mar 2021 05:42:27 +0000 (-0800) Subject: Move ChannelMonitor state behind a Mutex X-Git-Tag: v0.0.13~16^2~3 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=b0978a86be4fcf5e3c76f07a2b1f6a343a543fa3;p=rust-lightning Move ChannelMonitor state behind a Mutex ChainMonitor accesses a set of ChannelMonitors behind a single Mutex. As a result, update_channel operations cannot be parallelized. It also requires using a RefCell around a ChannelMonitor when implementing chain::Listen. Moving the Mutex into ChannelMonitor avoids these problems and aligns it better with other interfaces. Note, however, that get_funding_txo and get_outputs_to_watch now clone the underlying data rather than returning references. --- diff --git a/fuzz/src/chanmon_consistency.rs b/fuzz/src/chanmon_consistency.rs index e180805f2..d6a106bb7 100644 --- a/fuzz/src/chanmon_consistency.rs +++ b/fuzz/src/chanmon_consistency.rs @@ -126,7 +126,7 @@ impl chain::Watch for TestChainMonitor { hash_map::Entry::Occupied(entry) => entry, hash_map::Entry::Vacant(_) => panic!("Didn't have monitor on update call"), }; - let mut deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor)>:: + let deserialized_monitor = <(BlockHash, channelmonitor::ChannelMonitor)>:: read(&mut Cursor::new(&map_entry.get().1), &OnlyReadsKeysInterface {}).unwrap().1; deserialized_monitor.update_monitor(&update, &&TestBroadcaster{}, &&FuzzEstimator{}, &self.logger).unwrap(); let mut ser = VecWriter(Vec::new()); diff --git a/lightning/src/chain/channelmonitor.rs b/lightning/src/chain/channelmonitor.rs index a830c8216..a99769472 100644 --- a/lightning/src/chain/channelmonitor.rs +++ b/lightning/src/chain/channelmonitor.rs @@ -53,8 +53,9 @@ use util::events::Event; use std::cell::RefCell; use std::collections::{HashMap, HashSet, hash_map}; use std::{cmp, mem}; -use std::ops::Deref; use std::io::Error; +use std::ops::Deref; +use std::sync::Mutex; /// An update generated by the underlying Channel itself which contains some new information the /// ChannelMonitor should be made aware of. @@ -626,6 +627,13 @@ impl Readable for ChannelMonitorUpdateStep { /// returned block hash and the the current chain and then reconnecting blocks to get to the /// best chain) upon deserializing the object! pub struct ChannelMonitor { + #[cfg(test)] + pub(crate) inner: Mutex>, + #[cfg(not(test))] + inner: Mutex>, +} + +pub(crate) struct ChannelMonitorImpl { latest_update_id: u64, commitment_transaction_number_obscure_factor: u64, @@ -724,6 +732,17 @@ pub struct ChannelMonitor { /// Used only in testing and fuzztarget to check serialization roundtrips don't change the /// underlying object impl PartialEq for ChannelMonitor { + fn eq(&self, other: &Self) -> bool { + let inner = self.inner.lock().unwrap(); + let other = other.inner.lock().unwrap(); + inner.eq(&other) + } +} + +#[cfg(any(test, feature = "fuzztarget", feature = "_test_utils"))] +/// Used only in testing and fuzztarget to check serialization roundtrips don't change the +/// underlying object +impl PartialEq for ChannelMonitorImpl { fn eq(&self, other: &Self) -> bool { if self.latest_update_id != other.latest_update_id || self.commitment_transaction_number_obscure_factor != other.commitment_transaction_number_obscure_factor || @@ -770,6 +789,12 @@ impl Writeable for ChannelMonitor { writer.write_all(&[SERIALIZATION_VERSION; 1])?; writer.write_all(&[MIN_SERIALIZATION_VERSION; 1])?; + self.inner.lock().unwrap().write(writer) + } +} + +impl Writeable for ChannelMonitorImpl { + fn write(&self, writer: &mut W) -> Result<(), Error> { self.latest_update_id.write(writer)?; // Set in initial Channel-object creation, so should always be set by now: @@ -999,54 +1024,255 @@ impl ChannelMonitor { outputs_to_watch.insert(funding_info.0.txid, vec![(funding_info.0.index as u32, funding_info.1.clone())]); ChannelMonitor { - latest_update_id: 0, - commitment_transaction_number_obscure_factor, + inner: Mutex::new(ChannelMonitorImpl { + latest_update_id: 0, + commitment_transaction_number_obscure_factor, - destination_script: destination_script.clone(), - broadcasted_holder_revokable_script: None, - counterparty_payment_script, - shutdown_script, + destination_script: destination_script.clone(), + broadcasted_holder_revokable_script: None, + counterparty_payment_script, + shutdown_script, - channel_keys_id, - holder_revocation_basepoint, - funding_info, - current_counterparty_commitment_txid: None, - prev_counterparty_commitment_txid: None, + channel_keys_id, + holder_revocation_basepoint, + funding_info, + current_counterparty_commitment_txid: None, + prev_counterparty_commitment_txid: None, - counterparty_tx_cache, - funding_redeemscript, - channel_value_satoshis, - their_cur_revocation_points: None, + counterparty_tx_cache, + funding_redeemscript, + channel_value_satoshis, + their_cur_revocation_points: None, - on_holder_tx_csv: counterparty_channel_parameters.selected_contest_delay, + on_holder_tx_csv: counterparty_channel_parameters.selected_contest_delay, - commitment_secrets: CounterpartyCommitmentSecrets::new(), - counterparty_claimable_outpoints: HashMap::new(), - counterparty_commitment_txn_on_chain: HashMap::new(), - counterparty_hash_commitment_number: HashMap::new(), + commitment_secrets: CounterpartyCommitmentSecrets::new(), + counterparty_claimable_outpoints: HashMap::new(), + counterparty_commitment_txn_on_chain: HashMap::new(), + counterparty_hash_commitment_number: HashMap::new(), - prev_holder_signed_commitment_tx: None, - current_holder_commitment_tx: holder_commitment_tx, - current_counterparty_commitment_number: 1 << 48, - current_holder_commitment_number, + prev_holder_signed_commitment_tx: None, + current_holder_commitment_tx: holder_commitment_tx, + current_counterparty_commitment_number: 1 << 48, + current_holder_commitment_number, - payment_preimages: HashMap::new(), - pending_monitor_events: Vec::new(), - pending_events: Vec::new(), + payment_preimages: HashMap::new(), + pending_monitor_events: Vec::new(), + pending_events: Vec::new(), - onchain_events_waiting_threshold_conf: HashMap::new(), - outputs_to_watch, + onchain_events_waiting_threshold_conf: HashMap::new(), + outputs_to_watch, - onchain_tx_handler, + onchain_tx_handler, - lockdown_from_offchain: false, - holder_tx_signed: false, + lockdown_from_offchain: false, + holder_tx_signed: false, - last_block_hash: Default::default(), - secp_ctx, + last_block_hash: Default::default(), + secp_ctx, + }), } } + #[cfg(test)] + fn provide_secret(&self, idx: u64, secret: [u8; 32]) -> Result<(), MonitorUpdateError> { + self.inner.lock().unwrap().provide_secret(idx, secret) + } + + /// Informs this monitor of the latest counterparty (ie non-broadcastable) commitment transaction. + /// The monitor watches for it to be broadcasted and then uses the HTLC information (and + /// possibly future revocation/preimage information) to claim outputs where possible. + /// We cache also the mapping hash:commitment number to lighten pruning of old preimages by watchtowers. + pub(crate) fn provide_latest_counterparty_commitment_tx( + &self, + txid: Txid, + htlc_outputs: Vec<(HTLCOutputInCommitment, Option>)>, + commitment_number: u64, + their_revocation_point: PublicKey, + logger: &L, + ) where L::Target: Logger { + self.inner.lock().unwrap().provide_latest_counterparty_commitment_tx( + txid, htlc_outputs, commitment_number, their_revocation_point, logger) + } + + #[cfg(test)] + fn provide_latest_holder_commitment_tx( + &self, + holder_commitment_tx: HolderCommitmentTransaction, + htlc_outputs: Vec<(HTLCOutputInCommitment, Option, Option)>, + ) -> Result<(), MonitorUpdateError> { + self.inner.lock().unwrap().provide_latest_holder_commitment_tx( + holder_commitment_tx, htlc_outputs) + } + + #[cfg(test)] + pub(crate) fn provide_payment_preimage( + &self, + payment_hash: &PaymentHash, + payment_preimage: &PaymentPreimage, + broadcaster: &B, + fee_estimator: &F, + logger: &L, + ) where + B::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + { + self.inner.lock().unwrap().provide_payment_preimage( + payment_hash, payment_preimage, broadcaster, fee_estimator, logger) + } + + pub(crate) fn broadcast_latest_holder_commitment_txn( + &self, + broadcaster: &B, + logger: &L, + ) where + B::Target: BroadcasterInterface, + L::Target: Logger, + { + self.inner.lock().unwrap().broadcast_latest_holder_commitment_txn(broadcaster, logger) + } + + /// Updates a ChannelMonitor on the basis of some new information provided by the Channel + /// itself. + /// + /// panics if the given update is not the next update by update_id. + pub fn update_monitor( + &self, + updates: &ChannelMonitorUpdate, + broadcaster: &B, + fee_estimator: &F, + logger: &L, + ) -> Result<(), MonitorUpdateError> + where + B::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + { + self.inner.lock().unwrap().update_monitor(updates, broadcaster, fee_estimator, logger) + } + + /// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this + /// ChannelMonitor. + pub fn get_latest_update_id(&self) -> u64 { + self.inner.lock().unwrap().get_latest_update_id() + } + + /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. + pub fn get_funding_txo(&self) -> (OutPoint, Script) { + self.inner.lock().unwrap().get_funding_txo().clone() + } + + /// Gets a list of txids, with their output scripts (in the order they appear in the + /// transaction), which we must learn about spends of via block_connected(). + /// + /// (C-not exported) because we have no HashMap bindings + pub fn get_outputs_to_watch(&self) -> HashMap> { + self.inner.lock().unwrap().get_outputs_to_watch().clone() + } + + /// Get the list of HTLCs who's status has been updated on chain. This should be called by + /// ChannelManager via [`chain::Watch::release_pending_monitor_events`]. + /// + /// [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events + pub fn get_and_clear_pending_monitor_events(&self) -> Vec { + self.inner.lock().unwrap().get_and_clear_pending_monitor_events() + } + + /// Gets the list of pending events which were generated by previous actions, clearing the list + /// in the process. + /// + /// This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to + /// EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do + /// no internal locking in ChannelMonitors. + pub fn get_and_clear_pending_events(&self) -> Vec { + self.inner.lock().unwrap().get_and_clear_pending_events() + } + + pub(crate) fn get_min_seen_secret(&self) -> u64 { + self.inner.lock().unwrap().get_min_seen_secret() + } + + pub(crate) fn get_cur_counterparty_commitment_number(&self) -> u64 { + self.inner.lock().unwrap().get_cur_counterparty_commitment_number() + } + + pub(crate) fn get_cur_holder_commitment_number(&self) -> u64 { + self.inner.lock().unwrap().get_cur_holder_commitment_number() + } + + /// Used by ChannelManager deserialization to broadcast the latest holder state if its copy of + /// the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of + /// fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows + /// a higher revocation secret than the holder commitment number we are aware of. Broadcasting these + /// transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to + /// broadcast them if counterparty don't close channel with his higher commitment transaction after a + /// substantial amount of time (a month or even a year) to get back funds. Best may be to contact + /// out-of-band the other node operator to coordinate with him if option is available to you. + /// In any-case, choice is up to the user. + pub fn get_latest_holder_commitment_txn(&self, logger: &L) -> Vec + where L::Target: Logger { + self.inner.lock().unwrap().get_latest_holder_commitment_txn(logger) + } + + /// Unsafe test-only version of get_latest_holder_commitment_txn used by our test framework + /// to bypass HolderCommitmentTransaction state update lockdown after signature and generate + /// revoked commitment transaction. + #[cfg(any(test, feature = "unsafe_revoked_tx_signing"))] + pub fn unsafe_get_latest_holder_commitment_txn(&self, logger: &L) -> Vec + where L::Target: Logger { + self.inner.lock().unwrap().unsafe_get_latest_holder_commitment_txn(logger) + } + + /// Processes transactions in a newly connected block, which may result in any of the following: + /// - update the monitor's state against resolved HTLCs + /// - punish the counterparty in the case of seeing a revoked commitment transaction + /// - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration + /// - detect settled outputs for later spending + /// - schedule and bump any in-flight claims + /// + /// Returns any new outputs to watch from `txdata`; after called, these are also included in + /// [`get_outputs_to_watch`]. + /// + /// [`get_outputs_to_watch`]: #method.get_outputs_to_watch + pub fn block_connected( + &self, + header: &BlockHeader, + txdata: &TransactionData, + height: u32, + broadcaster: B, + fee_estimator: F, + logger: L, + ) -> Vec<(Txid, Vec<(u32, TxOut)>)> + where + B::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + { + self.inner.lock().unwrap().block_connected( + header, txdata, height, broadcaster, fee_estimator, logger) + } + + /// Determines if the disconnected block contained any transactions of interest and updates + /// appropriately. + pub fn block_disconnected( + &self, + header: &BlockHeader, + height: u32, + broadcaster: B, + fee_estimator: F, + logger: L, + ) where + B::Target: BroadcasterInterface, + F::Target: FeeEstimator, + L::Target: Logger, + { + self.inner.lock().unwrap().block_disconnected( + header, height, broadcaster, fee_estimator, logger) + } +} + +impl ChannelMonitorImpl { /// Inserts a revocation secret into this channel monitor. Prunes old preimages if neither /// needed by holder commitment transactions HTCLs nor by counterparty ones. Unless we haven't already seen /// counterparty commitment transaction's secret, they are de facto pruned (we can use revocation key). @@ -1098,10 +1324,6 @@ impl ChannelMonitor { Ok(()) } - /// Informs this monitor of the latest counterparty (ie non-broadcastable) commitment transaction. - /// The monitor watches for it to be broadcasted and then uses the HTLC information (and - /// possibly future revocation/preimage information) to claim outputs where possible. - /// We cache also the mapping hash:commitment number to lighten pruning of old preimages by watchtowers. pub(crate) fn provide_latest_counterparty_commitment_tx(&mut self, txid: Txid, htlc_outputs: Vec<(HTLCOutputInCommitment, Option>)>, commitment_number: u64, their_revocation_point: PublicKey, logger: &L) where L::Target: Logger { // TODO: Encrypt the htlc_outputs data with the single-hash of the commitment transaction // so that a remote monitor doesn't learn anything unless there is a malicious close. @@ -1178,7 +1400,7 @@ impl ChannelMonitor { /// Provides a payment_hash->payment_preimage mapping. Will be automatically pruned when all /// commitment_tx_infos which contain the payment hash have been revoked. - pub(crate) fn provide_payment_preimage(&mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B, fee_estimator: &F, logger: &L) + fn provide_payment_preimage(&mut self, payment_hash: &PaymentHash, payment_preimage: &PaymentPreimage, broadcaster: &B, fee_estimator: &F, logger: &L) where B::Target: BroadcasterInterface, F::Target: FeeEstimator, L::Target: Logger, @@ -1231,10 +1453,6 @@ impl ChannelMonitor { self.pending_monitor_events.push(MonitorEvent::CommitmentTxBroadcasted(self.funding_info.0)); } - /// Updates a ChannelMonitor on the basis of some new information provided by the Channel - /// itself. - /// - /// panics if the given update is not the next update by update_id. pub fn update_monitor(&mut self, updates: &ChannelMonitorUpdate, broadcaster: &B, fee_estimator: &F, logger: &L) -> Result<(), MonitorUpdateError> where B::Target: BroadcasterInterface, F::Target: FeeEstimator, @@ -1287,21 +1505,14 @@ impl ChannelMonitor { Ok(()) } - /// Gets the update_id from the latest ChannelMonitorUpdate which was applied to this - /// ChannelMonitor. pub fn get_latest_update_id(&self) -> u64 { self.latest_update_id } - /// Gets the funding transaction outpoint of the channel this ChannelMonitor is monitoring for. pub fn get_funding_txo(&self) -> &(OutPoint, Script) { &self.funding_info } - /// Gets a list of txids, with their output scripts (in the order they appear in the - /// transaction), which we must learn about spends of via block_connected(). - /// - /// (C-not exported) because we have no HashMap bindings pub fn get_outputs_to_watch(&self) -> &HashMap> { // If we've detected a counterparty commitment tx on chain, we must include it in the set // of outputs to watch for spends of, otherwise we're likely to lose user funds. Because @@ -1312,22 +1523,12 @@ impl ChannelMonitor { &self.outputs_to_watch } - /// Get the list of HTLCs who's status has been updated on chain. This should be called by - /// ChannelManager via [`chain::Watch::release_pending_monitor_events`]. - /// - /// [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events pub fn get_and_clear_pending_monitor_events(&mut self) -> Vec { let mut ret = Vec::new(); mem::swap(&mut ret, &mut self.pending_monitor_events); ret } - /// Gets the list of pending events which were generated by previous actions, clearing the list - /// in the process. - /// - /// This is called by ChainMonitor::get_and_clear_pending_events() and is equivalent to - /// EventsProvider::get_and_clear_pending_events() except that it requires &mut self as we do - /// no internal locking in ChannelMonitors. pub fn get_and_clear_pending_events(&mut self) -> Vec { let mut ret = Vec::new(); mem::swap(&mut ret, &mut self.pending_events); @@ -1715,15 +1916,6 @@ impl ChannelMonitor { (claim_requests, (commitment_txid, watch_outputs)) } - /// Used by ChannelManager deserialization to broadcast the latest holder state if its copy of - /// the Channel was out-of-date. You may use it to get a broadcastable holder toxic tx in case of - /// fallen-behind, i.e when receiving a channel_reestablish with a proof that our counterparty side knows - /// a higher revocation secret than the holder commitment number we are aware of. Broadcasting these - /// transactions are UNSAFE, as they allow counterparty side to punish you. Nevertheless you may want to - /// broadcast them if counterparty don't close channel with his higher commitment transaction after a - /// substantial amount of time (a month or even a year) to get back funds. Best may be to contact - /// out-of-band the other node operator to coordinate with him if option is available to you. - /// In any-case, choice is up to the user. pub fn get_latest_holder_commitment_txn(&mut self, logger: &L) -> Vec where L::Target: Logger { log_trace!(logger, "Getting signed latest holder commitment transaction!"); self.holder_tx_signed = true; @@ -1749,11 +1941,8 @@ impl ChannelMonitor { return res; } - /// Unsafe test-only version of get_latest_holder_commitment_txn used by our test framework - /// to bypass HolderCommitmentTransaction state update lockdown after signature and generate - /// revoked commitment transaction. #[cfg(any(test,feature = "unsafe_revoked_tx_signing"))] - pub fn unsafe_get_latest_holder_commitment_txn(&mut self, logger: &L) -> Vec where L::Target: Logger { + fn unsafe_get_latest_holder_commitment_txn(&mut self, logger: &L) -> Vec where L::Target: Logger { log_trace!(logger, "Getting signed copy of latest holder commitment transaction!"); let commitment_tx = self.onchain_tx_handler.get_fully_signed_copy_holder_tx(&self.funding_redeemscript); let txid = commitment_tx.txid(); @@ -1775,17 +1964,6 @@ impl ChannelMonitor { return res } - /// Processes transactions in a newly connected block, which may result in any of the following: - /// - update the monitor's state against resolved HTLCs - /// - punish the counterparty in the case of seeing a revoked commitment transaction - /// - force close the channel and claim/timeout incoming/outgoing HTLCs if near expiration - /// - detect settled outputs for later spending - /// - schedule and bump any in-flight claims - /// - /// Returns any new outputs to watch from `txdata`; after called, these are also included in - /// [`get_outputs_to_watch`]. - /// - /// [`get_outputs_to_watch`]: #method.get_outputs_to_watch pub fn block_connected(&mut self, header: &BlockHeader, txdata: &TransactionData, height: u32, broadcaster: B, fee_estimator: F, logger: L)-> Vec<(Txid, Vec<(u32, TxOut)>)> where B::Target: BroadcasterInterface, F::Target: FeeEstimator, @@ -1907,8 +2085,6 @@ impl ChannelMonitor { watch_outputs } - /// Determines if the disconnected block contained any transactions of interest and updates - /// appropriately. pub fn block_disconnected(&mut self, header: &BlockHeader, height: u32, broadcaster: B, fee_estimator: F, logger: L) where B::Target: BroadcasterInterface, F::Target: FeeEstimator, @@ -2561,51 +2737,53 @@ impl<'a, Signer: Sign, K: KeysInterface> ReadableArgs<&'a K> secp_ctx.seeded_randomize(&keys_manager.get_secure_random_bytes()); Ok((last_block_hash.clone(), ChannelMonitor { - latest_update_id, - commitment_transaction_number_obscure_factor, + inner: Mutex::new(ChannelMonitorImpl { + latest_update_id, + commitment_transaction_number_obscure_factor, - destination_script, - broadcasted_holder_revokable_script, - counterparty_payment_script, - shutdown_script, + destination_script, + broadcasted_holder_revokable_script, + counterparty_payment_script, + shutdown_script, - channel_keys_id, - holder_revocation_basepoint, - funding_info, - current_counterparty_commitment_txid, - prev_counterparty_commitment_txid, + channel_keys_id, + holder_revocation_basepoint, + funding_info, + current_counterparty_commitment_txid, + prev_counterparty_commitment_txid, - counterparty_tx_cache, - funding_redeemscript, - channel_value_satoshis, - their_cur_revocation_points, + counterparty_tx_cache, + funding_redeemscript, + channel_value_satoshis, + their_cur_revocation_points, - on_holder_tx_csv, + on_holder_tx_csv, - commitment_secrets, - counterparty_claimable_outpoints, - counterparty_commitment_txn_on_chain, - counterparty_hash_commitment_number, + commitment_secrets, + counterparty_claimable_outpoints, + counterparty_commitment_txn_on_chain, + counterparty_hash_commitment_number, - prev_holder_signed_commitment_tx, - current_holder_commitment_tx, - current_counterparty_commitment_number, - current_holder_commitment_number, + prev_holder_signed_commitment_tx, + current_holder_commitment_tx, + current_counterparty_commitment_number, + current_holder_commitment_number, - payment_preimages, - pending_monitor_events, - pending_events, + payment_preimages, + pending_monitor_events, + pending_events, - onchain_events_waiting_threshold_conf, - outputs_to_watch, + onchain_events_waiting_threshold_conf, + outputs_to_watch, - onchain_tx_handler, + onchain_tx_handler, - lockdown_from_offchain, - holder_tx_signed, + lockdown_from_offchain, + holder_tx_signed, - last_block_hash, - secp_ctx, + last_block_hash, + secp_ctx, + }), })) } } @@ -2683,7 +2861,7 @@ mod tests { macro_rules! test_preimages_exist { ($preimages_slice: expr, $monitor: expr) => { for preimage in $preimages_slice { - assert!($monitor.payment_preimages.contains_key(&preimage.1)); + assert!($monitor.inner.lock().unwrap().payment_preimages.contains_key(&preimage.1)); } } } @@ -2720,12 +2898,12 @@ mod tests { }; // Prune with one old state and a holder commitment tx holding a few overlaps with the // old state. - let mut monitor = ChannelMonitor::new(Secp256k1::new(), keys, - &PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()), 0, &Script::new(), - (OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, Script::new()), - &channel_parameters, - Script::new(), 46, 0, - HolderCommitmentTransaction::dummy()); + let monitor = ChannelMonitor::new(Secp256k1::new(), keys, + &PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()), 0, &Script::new(), + (OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, Script::new()), + &channel_parameters, + Script::new(), 46, 0, + HolderCommitmentTransaction::dummy()); monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap(); let dummy_txid = dummy_tx.txid(); @@ -2741,14 +2919,14 @@ mod tests { let mut secret = [0; 32]; secret[0..32].clone_from_slice(&hex::decode("7cc854b54e3e0dcdb010d7a3fee464a9687be6e8db3be6854c475621e007a5dc").unwrap()); monitor.provide_secret(281474976710655, secret.clone()).unwrap(); - assert_eq!(monitor.payment_preimages.len(), 15); + assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 15); test_preimages_exist!(&preimages[0..10], monitor); test_preimages_exist!(&preimages[15..20], monitor); // Now provide a further secret, pruning preimages 15-17 secret[0..32].clone_from_slice(&hex::decode("c7518c8ae4660ed02894df8976fa1a3659c1a8b4b5bec0c4b872abeba4cb8964").unwrap()); monitor.provide_secret(281474976710654, secret.clone()).unwrap(); - assert_eq!(monitor.payment_preimages.len(), 13); + assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 13); test_preimages_exist!(&preimages[0..10], monitor); test_preimages_exist!(&preimages[17..20], monitor); @@ -2757,7 +2935,7 @@ mod tests { monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap(); secret[0..32].clone_from_slice(&hex::decode("2273e227a5b7449b6e70f1fb4652864038b1cbf9cd7c043a7d6456b7fc275ad8").unwrap()); monitor.provide_secret(281474976710653, secret.clone()).unwrap(); - assert_eq!(monitor.payment_preimages.len(), 12); + assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 12); test_preimages_exist!(&preimages[0..10], monitor); test_preimages_exist!(&preimages[18..20], monitor); @@ -2765,7 +2943,7 @@ mod tests { monitor.provide_latest_holder_commitment_tx(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..3])).unwrap(); secret[0..32].clone_from_slice(&hex::decode("27cddaa5624534cb6cb9d7da077cf2b22ab21e9b506fd4998a51d54502e99116").unwrap()); monitor.provide_secret(281474976710652, secret.clone()).unwrap(); - assert_eq!(monitor.payment_preimages.len(), 5); + assert_eq!(monitor.inner.lock().unwrap().payment_preimages.len(), 5); test_preimages_exist!(&preimages[0..5], monitor); } diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs index d9c7fc5ad..2bbe367de 100644 --- a/lightning/src/ln/channel.rs +++ b/lightning/src/ln/channel.rs @@ -1570,13 +1570,13 @@ impl Channel { let funding_redeemscript = self.get_funding_redeemscript(); let funding_txo_script = funding_redeemscript.to_v0_p2wsh(); let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()); - let mut channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), self.holder_signer.clone(), - &self.shutdown_pubkey, self.get_holder_selected_contest_delay(), - &self.destination_script, (funding_txo, funding_txo_script.clone()), - &self.channel_transaction_parameters, - funding_redeemscript.clone(), self.channel_value_satoshis, - obscure_factor, - holder_commitment_tx); + let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), self.holder_signer.clone(), + &self.shutdown_pubkey, self.get_holder_selected_contest_delay(), + &self.destination_script, (funding_txo, funding_txo_script.clone()), + &self.channel_transaction_parameters, + funding_redeemscript.clone(), self.channel_value_satoshis, + obscure_factor, + holder_commitment_tx); channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_commitment_txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger); @@ -1640,13 +1640,13 @@ impl Channel { let funding_txo = self.get_funding_txo().unwrap(); let funding_txo_script = funding_redeemscript.to_v0_p2wsh(); let obscure_factor = get_commitment_transaction_number_obscure_factor(&self.get_holder_pubkeys().payment_point, &self.get_counterparty_pubkeys().payment_point, self.is_outbound()); - let mut channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), self.holder_signer.clone(), - &self.shutdown_pubkey, self.get_holder_selected_contest_delay(), - &self.destination_script, (funding_txo, funding_txo_script), - &self.channel_transaction_parameters, - funding_redeemscript.clone(), self.channel_value_satoshis, - obscure_factor, - holder_commitment_tx); + let channel_monitor = ChannelMonitor::new(self.secp_ctx.clone(), self.holder_signer.clone(), + &self.shutdown_pubkey, self.get_holder_selected_contest_delay(), + &self.destination_script, (funding_txo, funding_txo_script), + &self.channel_transaction_parameters, + funding_redeemscript.clone(), self.channel_value_satoshis, + obscure_factor, + holder_commitment_tx); channel_monitor.provide_latest_counterparty_commitment_tx(counterparty_initial_bitcoin_tx.txid, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger); diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index ea33bb561..04afca261 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -8228,8 +8228,8 @@ fn test_bump_txn_sanitize_tracking_maps() { { let monitors = nodes[0].chain_monitor.chain_monitor.monitors.lock().unwrap(); if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) { - assert!(monitor.onchain_tx_handler.pending_claim_requests.is_empty()); - assert!(monitor.onchain_tx_handler.claimable_outpoints.is_empty()); + assert!(monitor.inner.lock().unwrap().onchain_tx_handler.pending_claim_requests.is_empty()); + assert!(monitor.inner.lock().unwrap().onchain_tx_handler.claimable_outpoints.is_empty()); } } } diff --git a/lightning/src/util/macro_logger.rs b/lightning/src/util/macro_logger.rs index ab2b6ceea..90a1bdb48 100644 --- a/lightning/src/util/macro_logger.rs +++ b/lightning/src/util/macro_logger.rs @@ -72,7 +72,7 @@ impl<'a, T> std::fmt::Display for DebugFundingInfo<'a, T> { } macro_rules! log_funding_info { ($key_storage: expr) => { - ::util::macro_logger::DebugFundingInfo($key_storage.get_funding_txo()) + ::util::macro_logger::DebugFundingInfo(&$key_storage.get_funding_txo()) } }