X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-block-sync%2Fsrc%2Finit.rs;h=abefd1bcddf4891b4ebd1a9648fbaf168e7deb72;hb=da79fb05fa13f0a7db1bb7ef03f1a4ce9e3b8b35;hp=b8418fe89629998579dc1158d853f2c68a0f0448;hpb=6be8ccb2a34c6095307a9c8aec6bc77b0496c5a2;p=rust-lightning diff --git a/lightning-block-sync/src/init.rs b/lightning-block-sync/src/init.rs index b8418fe89..abefd1bcd 100644 --- a/lightning-block-sync/src/init.rs +++ b/lightning-block-sync/src/init.rs @@ -1,10 +1,12 @@ -use crate::{BlockSource, BlockSourceResult, Cache, ChainListener, ChainNotifier}; +use crate::{BlockSource, BlockSourceResult, Cache, ChainNotifier}; use crate::poll::{ChainPoller, Validate, ValidatedBlockHeader}; use bitcoin::blockdata::block::{Block, BlockHeader}; use bitcoin::hash_types::BlockHash; use bitcoin::network::constants::Network; +use lightning::chain; + /// Performs a one-time sync of chain listeners using a single *trusted* block source, bringing each /// listener's view of the chain from its paired block hash to `block_source`'s best chain tip. /// @@ -13,7 +15,87 @@ use bitcoin::network::constants::Network; /// paired with. /// /// Useful during startup to bring the [`ChannelManager`] and each [`ChannelMonitor`] in sync before -/// switching to [`SpvClient`]. +/// switching to [`SpvClient`]. For example: +/// +/// ``` +/// use bitcoin::hash_types::BlockHash; +/// use bitcoin::network::constants::Network; +/// +/// use lightning::chain; +/// use lightning::chain::Watch; +/// use lightning::chain::chainmonitor::ChainMonitor; +/// use lightning::chain::channelmonitor; +/// use lightning::chain::channelmonitor::ChannelMonitor; +/// use lightning::chain::chaininterface::BroadcasterInterface; +/// use lightning::chain::chaininterface::FeeEstimator; +/// use lightning::chain::keysinterface; +/// use lightning::chain::keysinterface::KeysInterface; +/// use lightning::ln::channelmanager::ChannelManager; +/// use lightning::ln::channelmanager::ChannelManagerReadArgs; +/// use lightning::util::config::UserConfig; +/// use lightning::util::logger::Logger; +/// use lightning::util::ser::ReadableArgs; +/// +/// use lightning_block_sync::*; +/// +/// use std::cell::RefCell; +/// use std::io::Cursor; +/// +/// async fn init_sync< +/// B: BlockSource, +/// K: KeysInterface, +/// S: keysinterface::Sign, +/// T: BroadcasterInterface, +/// F: FeeEstimator, +/// L: Logger, +/// C: chain::Filter, +/// P: channelmonitor::Persist, +/// >( +/// block_source: &mut B, +/// chain_monitor: &ChainMonitor, +/// config: UserConfig, +/// keys_manager: &K, +/// tx_broadcaster: &T, +/// fee_estimator: &F, +/// logger: &L, +/// persister: &P, +/// ) { +/// let serialized_monitor = "..."; +/// let (monitor_block_hash, mut monitor) = <(BlockHash, ChannelMonitor)>::read( +/// &mut Cursor::new(&serialized_monitor), keys_manager).unwrap(); +/// +/// let serialized_manager = "..."; +/// let (manager_block_hash, mut manager) = { +/// let read_args = ChannelManagerReadArgs::new( +/// keys_manager, +/// fee_estimator, +/// chain_monitor, +/// tx_broadcaster, +/// logger, +/// config, +/// vec![&mut monitor], +/// ); +/// <(BlockHash, ChannelManager, &T, &K, &F, &L>)>::read( +/// &mut Cursor::new(&serialized_manager), read_args).unwrap() +/// }; +/// +/// let mut cache = UnboundedCache::new(); +/// let mut monitor_listener = (RefCell::new(monitor), &*tx_broadcaster, &*fee_estimator, &*logger); +/// let listeners = vec![ +/// (monitor_block_hash, &mut monitor_listener as &mut dyn chain::Listen), +/// (manager_block_hash, &mut manager as &mut dyn chain::Listen), +/// ]; +/// let chain_tip = +/// init::sync_listeners(block_source, Network::Bitcoin, &mut cache, listeners).await.unwrap(); +/// +/// let monitor = monitor_listener.0.into_inner(); +/// chain_monitor.watch_channel(monitor.get_funding_txo().0, monitor); +/// +/// let chain_poller = poll::ChainPoller::new(block_source, Network::Bitcoin); +/// let mut chain_listener = (chain_monitor, &manager); +/// let spv_client = SpvClient::new(chain_tip, chain_poller, &mut cache, &chain_listener); +/// } +/// ``` /// /// [`SpvClient`]: ../struct.SpvClient.html /// [`ChannelManager`]: ../../lightning/ln/channelmanager/struct.ChannelManager.html @@ -22,7 +104,7 @@ pub async fn sync_listeners( block_source: &mut B, network: Network, header_cache: &mut C, - mut chain_listeners: Vec<(BlockHash, &mut dyn ChainListener)>, + mut chain_listeners: Vec<(BlockHash, &mut dyn chain::Listen)>, ) -> BlockSourceResult { let (best_block_hash, best_block_height) = block_source.get_best_block().await?; let new_header = block_source @@ -49,32 +131,29 @@ pub async fn sync_listeners( for (old_header, chain_listener) in chain_listeners_with_old_headers.drain(..) { // Disconnect any stale blocks, but keep them in the cache for the next iteration. let header_cache = &mut ReadOnlyCache(header_cache); - let mut chain_notifier = ChainNotifier { header_cache }; - let difference = - chain_notifier.find_difference(new_header, &old_header, &mut chain_poller).await?; - chain_notifier.disconnect_blocks( - difference.disconnected_blocks, - &mut DynamicChainListener(chain_listener), - ); + let (common_ancestor, connected_blocks) = { + let chain_listener = &DynamicChainListener(chain_listener); + let mut chain_notifier = ChainNotifier { header_cache, chain_listener }; + let difference = + chain_notifier.find_difference(new_header, &old_header, &mut chain_poller).await?; + chain_notifier.disconnect_blocks(difference.disconnected_blocks); + (difference.common_ancestor, difference.connected_blocks) + }; // Keep track of the most common ancestor and all blocks connected across all listeners. - chain_listeners_at_height.push((difference.common_ancestor.height, chain_listener)); - if difference.connected_blocks.len() > most_connected_blocks.len() { - most_common_ancestor = Some(difference.common_ancestor); - most_connected_blocks = difference.connected_blocks; + chain_listeners_at_height.push((common_ancestor.height, chain_listener)); + if connected_blocks.len() > most_connected_blocks.len() { + most_common_ancestor = Some(common_ancestor); + most_connected_blocks = connected_blocks; } } // Connect new blocks for all listeners at once to avoid re-fetching blocks. if let Some(common_ancestor) = most_common_ancestor { - let mut chain_notifier = ChainNotifier { header_cache }; - let mut chain_listener = ChainListenerSet(chain_listeners_at_height); - chain_notifier.connect_blocks( - common_ancestor, - most_connected_blocks, - &mut chain_poller, - &mut chain_listener, - ).await.or_else(|(e, _)| Err(e))?; + let chain_listener = &ChainListenerSet(chain_listeners_at_height); + let mut chain_notifier = ChainNotifier { header_cache, chain_listener }; + chain_notifier.connect_blocks(common_ancestor, most_connected_blocks, &mut chain_poller) + .await.or_else(|(e, _)| Err(e))?; } Ok(new_header) @@ -101,31 +180,31 @@ impl<'a, C: Cache> Cache for ReadOnlyCache<'a, C> { } /// Wrapper for supporting dynamically sized chain listeners. -struct DynamicChainListener<'a>(&'a mut dyn ChainListener); +struct DynamicChainListener<'a>(&'a mut dyn chain::Listen); -impl<'a> ChainListener for DynamicChainListener<'a> { - fn block_connected(&mut self, _block: &Block, _height: u32) { +impl<'a> chain::Listen for DynamicChainListener<'a> { + fn block_connected(&self, _block: &Block, _height: u32) { unreachable!() } - fn block_disconnected(&mut self, header: &BlockHeader, height: u32) { + fn block_disconnected(&self, header: &BlockHeader, height: u32) { self.0.block_disconnected(header, height) } } /// A set of dynamically sized chain listeners, each paired with a starting block height. -struct ChainListenerSet<'a>(Vec<(u32, &'a mut dyn ChainListener)>); +struct ChainListenerSet<'a>(Vec<(u32, &'a mut dyn chain::Listen)>); -impl<'a> ChainListener for ChainListenerSet<'a> { - fn block_connected(&mut self, block: &Block, height: u32) { - for (starting_height, chain_listener) in self.0.iter_mut() { +impl<'a> chain::Listen for ChainListenerSet<'a> { + fn block_connected(&self, block: &Block, height: u32) { + for (starting_height, chain_listener) in self.0.iter() { if height > *starting_height { chain_listener.block_connected(block, height); } } } - fn block_disconnected(&mut self, _header: &BlockHeader, _height: u32) { + fn block_disconnected(&self, _header: &BlockHeader, _height: u32) { unreachable!() } } @@ -152,9 +231,9 @@ mod tests { .expect_block_connected(*chain.at_height(4)); let listeners = vec![ - (chain.at_height(1).block_hash, &mut listener_1 as &mut dyn ChainListener), - (chain.at_height(2).block_hash, &mut listener_2 as &mut dyn ChainListener), - (chain.at_height(3).block_hash, &mut listener_3 as &mut dyn ChainListener), + (chain.at_height(1).block_hash, &mut listener_1 as &mut dyn chain::Listen), + (chain.at_height(2).block_hash, &mut listener_2 as &mut dyn chain::Listen), + (chain.at_height(3).block_hash, &mut listener_3 as &mut dyn chain::Listen), ]; let mut cache = chain.header_cache(0..=4); match sync_listeners(&mut chain, Network::Bitcoin, &mut cache, listeners).await { @@ -187,9 +266,9 @@ mod tests { .expect_block_connected(*main_chain.at_height(4)); let listeners = vec![ - (fork_chain_1.tip().block_hash, &mut listener_1 as &mut dyn ChainListener), - (fork_chain_2.tip().block_hash, &mut listener_2 as &mut dyn ChainListener), - (fork_chain_3.tip().block_hash, &mut listener_3 as &mut dyn ChainListener), + (fork_chain_1.tip().block_hash, &mut listener_1 as &mut dyn chain::Listen), + (fork_chain_2.tip().block_hash, &mut listener_2 as &mut dyn chain::Listen), + (fork_chain_3.tip().block_hash, &mut listener_3 as &mut dyn chain::Listen), ]; let mut cache = fork_chain_1.header_cache(2..=4); cache.extend(fork_chain_2.header_cache(3..=4)); @@ -230,9 +309,9 @@ mod tests { .expect_block_connected(*main_chain.at_height(4)); let listeners = vec![ - (fork_chain_1.tip().block_hash, &mut listener_1 as &mut dyn ChainListener), - (fork_chain_2.tip().block_hash, &mut listener_2 as &mut dyn ChainListener), - (fork_chain_3.tip().block_hash, &mut listener_3 as &mut dyn ChainListener), + (fork_chain_1.tip().block_hash, &mut listener_1 as &mut dyn chain::Listen), + (fork_chain_2.tip().block_hash, &mut listener_2 as &mut dyn chain::Listen), + (fork_chain_3.tip().block_hash, &mut listener_3 as &mut dyn chain::Listen), ]; let mut cache = fork_chain_1.header_cache(2..=4); cache.extend(fork_chain_2.header_cache(3..=4)); @@ -254,7 +333,7 @@ mod tests { .expect_block_disconnected(*old_tip) .expect_block_connected(*new_tip); - let listeners = vec![(old_tip.block_hash, &mut listener as &mut dyn ChainListener)]; + let listeners = vec![(old_tip.block_hash, &mut listener as &mut dyn chain::Listen)]; let mut cache = fork_chain.header_cache(2..=2); match sync_listeners(&mut main_chain, Network::Bitcoin, &mut cache, listeners).await { Ok(_) => {