X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fchain%2Fchainmonitor.rs;h=ecdd6c3f28395d814ebb98f6315810a70038409e;hb=f57c8856b59a0e2a2030ec43b7a736e211e3d0c9;hp=0cf2d56a14eb5a79bb489b7fb7c27e80c7305597;hpb=c9321c5ec07ee2daa895b5136e9472a42d4eff1d;p=rust-lightning diff --git a/lightning/src/chain/chainmonitor.rs b/lightning/src/chain/chainmonitor.rs index 0cf2d56a..ecdd6c3f 100644 --- a/lightning/src/chain/chainmonitor.rs +++ b/lightning/src/chain/chainmonitor.rs @@ -13,26 +13,22 @@ //! update [`ChannelMonitor`]s accordingly. If any on-chain events need further processing, it will //! make those available as [`MonitorEvent`]s to be consumed. //! -//! `ChainMonitor` is parameterized by an optional chain source, which must implement the +//! [`ChainMonitor`] is parameterized by an optional chain source, which must implement the //! [`chain::Filter`] trait. This provides a mechanism to signal new relevant outputs back to light //! clients, such that transactions spending those outputs are included in block data. //! -//! `ChainMonitor` may be used directly to monitor channels locally or as a part of a distributed -//! setup to monitor channels remotely. In the latter case, a custom `chain::Watch` implementation +//! [`ChainMonitor`] may be used directly to monitor channels locally or as a part of a distributed +//! setup to monitor channels remotely. In the latter case, a custom [`chain::Watch`] implementation //! would be responsible for routing each update to a remote server and for retrieving monitor -//! events. The remote server would make use of `ChainMonitor` for block processing and for -//! servicing `ChannelMonitor` updates from the client. -//! -//! [`ChainMonitor`]: struct.ChainMonitor.html -//! [`chain::Filter`]: ../trait.Filter.html -//! [`chain::Watch`]: ../trait.Watch.html -//! [`ChannelMonitor`]: ../channelmonitor/struct.ChannelMonitor.html -//! [`MonitorEvent`]: ../channelmonitor/enum.MonitorEvent.html +//! events. The remote server would make use of [`ChainMonitor`] for block processing and for +//! servicing [`ChannelMonitor`] updates from the client. use bitcoin::blockdata::block::{Block, BlockHeader}; +use bitcoin::hash_types::Txid; +use bitcoin::blockdata::transaction::TxOut; use chain; -use chain::Filter; +use chain::{Filter, WatchedOutput}; use chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use chain::channelmonitor; use chain::channelmonitor::{ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateErr, MonitorEvent, Persist}; @@ -53,9 +49,8 @@ use std::ops::Deref; /// or used independently to monitor channels remotely. See the [module-level documentation] for /// details. /// -/// [`chain::Watch`]: ../trait.Watch.html -/// [`ChannelManager`]: ../../ln/channelmanager/struct.ChannelManager.html -/// [module-level documentation]: index.html +/// [`ChannelManager`]: crate::ln::channelmanager::ChannelManager +/// [module-level documentation]: crate::chain::chainmonitor pub struct ChainMonitor where C::Target: chain::Filter, T::Target: BroadcasterInterface, @@ -88,30 +83,99 @@ where C::Target: chain::Filter, /// calls must not exclude any transactions matching the new outputs nor any in-block /// descendants of such transactions. It is not necessary to re-fetch the block to obtain /// updated `txdata`. - /// - /// [`ChannelMonitor::block_connected`]: ../channelmonitor/struct.ChannelMonitor.html#method.block_connected - /// [`chain::Watch::release_pending_monitor_events`]: ../trait.Watch.html#tymethod.release_pending_monitor_events - /// [`chain::Filter`]: ../trait.Filter.html pub fn block_connected(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) { + self.process_chain_data(header, txdata, |monitor, txdata| { + monitor.block_connected( + header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &*self.logger) + }); + } + + /// Dispatches to per-channel monitors, which are responsible for updating their on-chain view + /// of a channel and reacting accordingly to newly confirmed transactions. For details, see + /// [`ChannelMonitor::transactions_confirmed`]. + /// + /// Used instead of [`block_connected`] by clients that are notified of transactions rather than + /// blocks. May be called before or after [`update_best_block`] for transactions in the + /// corresponding block. See [`update_best_block`] for further calling expectations. + /// + /// [`block_connected`]: Self::block_connected + /// [`update_best_block`]: Self::update_best_block + pub fn transactions_confirmed(&self, header: &BlockHeader, txdata: &TransactionData, height: u32) { + self.process_chain_data(header, txdata, |monitor, txdata| { + monitor.transactions_confirmed( + header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &*self.logger) + }); + } + + /// Dispatches to per-channel monitors, which are responsible for updating their on-chain view + /// of a channel and reacting accordingly based on the new chain tip. For details, see + /// [`ChannelMonitor::update_best_block`]. + /// + /// Used instead of [`block_connected`] by clients that are notified of transactions rather than + /// blocks. May be called before or after [`transactions_confirmed`] for the corresponding + /// block. + /// + /// Must be called after new blocks become available for the most recent block. Intermediary + /// blocks, however, may be safely skipped. In the event of a chain re-organization, this only + /// needs to be called for the most recent block assuming `transaction_unconfirmed` is called + /// for any affected transactions. + /// + /// [`block_connected`]: Self::block_connected + /// [`transactions_confirmed`]: Self::transactions_confirmed + /// [`transaction_unconfirmed`]: Self::transaction_unconfirmed + pub fn update_best_block(&self, header: &BlockHeader, height: u32) { + self.process_chain_data(header, &[], |monitor, txdata| { + // While in practice there shouldn't be any recursive calls when given empty txdata, + // it's still possible if a chain::Filter implementation returns a transaction. + debug_assert!(txdata.is_empty()); + monitor.update_best_block( + header, height, &*self.broadcaster, &*self.fee_estimator, &*self.logger) + }); + } + + fn process_chain_data(&self, header: &BlockHeader, txdata: &TransactionData, process: FN) + where + FN: Fn(&ChannelMonitor, &TransactionData) -> Vec<(Txid, Vec<(u32, TxOut)>)> + { + let mut dependent_txdata = Vec::new(); let monitors = self.monitors.read().unwrap(); for monitor in monitors.values() { - let mut txn_outputs = monitor.block_connected(header, txdata, height, &*self.broadcaster, &*self.fee_estimator, &*self.logger); + let mut txn_outputs = process(monitor, txdata); + // Register any new outputs with the chain source for filtering, storing any dependent + // transactions from within the block that previously had not been included in txdata. if let Some(ref chain_source) = self.chain_source { + let block_hash = header.block_hash(); for (txid, outputs) in txn_outputs.drain(..) { for (idx, output) in outputs.iter() { - chain_source.register_output(&OutPoint { txid, index: *idx as u16 }, &output.script_pubkey); + // Register any new outputs with the chain source for filtering and recurse + // if it indicates that there are dependent transactions within the block + // that had not been previously included in txdata. + let output = WatchedOutput { + block_hash: Some(block_hash), + outpoint: OutPoint { txid, index: *idx as u16 }, + script_pubkey: output.script_pubkey.clone(), + }; + if let Some(tx) = chain_source.register_output(output) { + dependent_txdata.push(tx); + } } } } } + + // Recursively call for any dependent transactions that were identified by the chain source. + if !dependent_txdata.is_empty() { + dependent_txdata.sort_unstable_by_key(|(index, _tx)| *index); + dependent_txdata.dedup_by_key(|(index, _tx)| *index); + let txdata: Vec<_> = dependent_txdata.iter().map(|(index, tx)| (*index, tx)).collect(); + self.process_chain_data(header, &txdata, process); + } } /// Dispatches to per-channel monitors, which are responsible for updating their on-chain view /// of a channel based on the disconnected block. See [`ChannelMonitor::block_disconnected`] for /// details. - /// - /// [`ChannelMonitor::block_disconnected`]: ../channelmonitor/struct.ChannelMonitor.html#method.block_disconnected pub fn block_disconnected(&self, header: &BlockHeader, disconnected_height: u32) { let monitors = self.monitors.read().unwrap(); for monitor in monitors.values() { @@ -119,6 +183,36 @@ where C::Target: chain::Filter, } } + /// Dispatches to per-channel monitors, which are responsible for updating their on-chain view + /// of a channel based on transactions unconfirmed as a result of a chain reorganization. See + /// [`ChannelMonitor::transaction_unconfirmed`] for details. + /// + /// Used instead of [`block_disconnected`] by clients that are notified of transactions rather + /// than blocks. May be called before or after [`update_best_block`] for transactions in the + /// corresponding block. See [`update_best_block`] for further calling expectations. + /// + /// [`block_disconnected`]: Self::block_disconnected + /// [`update_best_block`]: Self::update_best_block + pub fn transaction_unconfirmed(&self, txid: &Txid) { + let monitors = self.monitors.read().unwrap(); + for monitor in monitors.values() { + monitor.transaction_unconfirmed(txid, &*self.broadcaster, &*self.fee_estimator, &*self.logger); + } + } + + /// Returns the set of txids that should be monitored for re-organization out of the chain. + pub fn get_relevant_txids(&self) -> Vec { + let mut txids = Vec::new(); + let monitors = self.monitors.read().unwrap(); + for monitor in monitors.values() { + txids.append(&mut monitor.get_relevant_txids()); + } + + txids.sort_unstable(); + txids.dedup(); + txids + } + /// Creates a new `ChainMonitor` used to watch on-chain activity pertaining to channels. /// /// When an optional chain source implementing [`chain::Filter`] is provided, the chain monitor @@ -126,8 +220,6 @@ where C::Target: chain::Filter, /// pre-filter blocks or only fetch blocks matching a compact filter. Otherwise, clients may /// always need to fetch full blocks absent another means for determining which blocks contain /// transactions relevant to the watched channels. - /// - /// [`chain::Filter`]: ../trait.Filter.html pub fn new(chain_source: Option, broadcaster: T, logger: L, feeest: F, persister: P) -> Self { Self { monitors: RwLock::new(HashMap::new()), @@ -174,8 +266,6 @@ where C::Target: chain::Filter, /// /// Note that we persist the given `ChannelMonitor` while holding the `ChainMonitor` /// monitors lock. - /// - /// [`chain::Filter`]: ../trait.Filter.html fn watch_channel(&self, funding_outpoint: OutPoint, monitor: ChannelMonitor) -> Result<(), ChannelMonitorUpdateErr> { let mut monitors = self.monitors.write().unwrap(); let entry = match monitors.entry(funding_outpoint) { @@ -262,3 +352,56 @@ impl even pending_events } } + +#[cfg(test)] +mod tests { + use ::{check_added_monitors, get_local_commitment_txn}; + use ln::features::InitFeatures; + use ln::functional_test_utils::*; + use util::events::EventsProvider; + use util::events::MessageSendEventsProvider; + use util::test_utils::{OnRegisterOutput, TxOutReference}; + + /// Tests that in-block dependent transactions are processed by `block_connected` when not + /// included in `txdata` but returned by [`chain::Filter::register_output`]. For instance, + /// a (non-anchor) commitment transaction's HTLC output may be spent in the same block as the + /// commitment transaction itself. An Electrum client may filter the commitment transaction but + /// needs to return the HTLC transaction so it can be processed. + #[test] + fn connect_block_checks_dependent_transactions() { + let chanmon_cfgs = create_chanmon_cfgs(2); + let node_cfgs = create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]); + let nodes = create_network(2, &node_cfgs, &node_chanmgrs); + let channel = create_announced_chan_between_nodes( + &nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); + + // Send a payment, saving nodes[0]'s revoked commitment and HTLC-Timeout transactions. + let (commitment_tx, htlc_tx) = { + let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 5_000_000).0; + let mut txn = get_local_commitment_txn!(nodes[0], channel.2); + claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 5_000_000); + + assert_eq!(txn.len(), 2); + (txn.remove(0), txn.remove(0)) + }; + + // Set expectations on nodes[1]'s chain source to return dependent transactions. + let htlc_output = TxOutReference(commitment_tx.clone(), 0); + let to_local_output = TxOutReference(commitment_tx.clone(), 1); + let htlc_timeout_output = TxOutReference(htlc_tx.clone(), 0); + nodes[1].chain_source + .expect(OnRegisterOutput { with: htlc_output, returns: Some((1, htlc_tx)) }) + .expect(OnRegisterOutput { with: to_local_output, returns: None }) + .expect(OnRegisterOutput { with: htlc_timeout_output, returns: None }); + + // Notify nodes[1] that nodes[0]'s revoked commitment transaction was mined. The chain + // source should return the dependent HTLC transaction when the HTLC output is registered. + mine_transaction(&nodes[1], &commitment_tx); + + // Clean up so uninteresting assertions don't fail. + check_added_monitors!(nodes[1], 1); + nodes[1].node.get_and_clear_pending_msg_events(); + nodes[1].node.get_and_clear_pending_events(); + } +}