Immutable BlockSource interface

[rust-lightning] / lightning-block-sync / src / init.rs

diff --git a/lightning-block-sync/src/init.rs b/lightning-block-sync/src/init.rs
index 0bdc2a0255b85d4e902fc90e7c8924bf7d3990d7..6611d185da393e3da10e11b720468adc06084a4c 100644 (file)
--- a/lightning-block-sync/src/init.rs
+++ b/lightning-block-sync/src/init.rs
@@ -16,7 +16,7 @@ use lightning::chain;
 /// start when there are no chain listeners to sync yet.
 ///
 /// [`SpvClient`]: crate::SpvClient
-pub async fn validate_best_block_header<B: BlockSource>(block_source: &mut B) ->
+pub async fn validate_best_block_header<B: BlockSource>(block_source: &B) ->
 BlockSourceResult<ValidatedBlockHeader> {
        let (best_block_hash, best_block_height) = block_source.get_best_block().await?;
        block_source
@@ -67,7 +67,7 @@ BlockSourceResult<ValidatedBlockHeader> {
 ///    C: chain::Filter,
 ///    P: chainmonitor::Persist<S>,
 /// >(
-///    block_source: &mut B,
+///    block_source: &B,
 ///    chain_monitor: &ChainMonitor<S, &C, &T, &F, &L, &P>,
 ///    config: UserConfig,
 ///    keys_manager: &K,
@@ -101,8 +101,8 @@ BlockSourceResult<ValidatedBlockHeader> {
 ///    let mut cache = UnboundedCache::new();
 ///    let mut monitor_listener = (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),
+///            (monitor_block_hash, &monitor_listener as &dyn chain::Listen),
+///            (manager_block_hash, &manager as &dyn chain::Listen),
 ///    ];
 ///    let chain_tip = init::synchronize_listeners(
 ///            block_source, Network::Bitcoin, &mut cache, listeners).await.unwrap();
@@ -121,11 +121,11 @@ BlockSourceResult<ValidatedBlockHeader> {
 /// [`SpvClient`]: crate::SpvClient
 /// [`ChannelManager`]: lightning::ln::channelmanager::ChannelManager
 /// [`ChannelMonitor`]: lightning::chain::channelmonitor::ChannelMonitor
-pub async fn synchronize_listeners<B: BlockSource, C: Cache>(
-       block_source: &mut B,
+pub async fn synchronize_listeners<'a, B: BlockSource, C: Cache, L: chain::Listen + ?Sized>(
+       block_source: &B,
        network: Network,
        header_cache: &mut C,
-       mut chain_listeners: Vec<(BlockHash, &mut dyn chain::Listen)>,
+       mut chain_listeners: Vec<(BlockHash, &'a L)>,
 ) -> BlockSourceResult<ValidatedBlockHeader> {
        let best_header = validate_best_block_header(block_source).await?;
 
@@ -198,9 +198,9 @@ impl<'a, C: Cache> Cache for ReadOnlyCache<'a, C> {
 }
 
 /// Wrapper for supporting dynamically sized chain listeners.
-struct DynamicChainListener<'a>(&'a mut dyn chain::Listen);
+struct DynamicChainListener<'a, L: chain::Listen + ?Sized>(&'a L);
 
-impl<'a> chain::Listen for DynamicChainListener<'a> {
+impl<'a, L: chain::Listen + ?Sized> chain::Listen for DynamicChainListener<'a, L> {
        fn block_connected(&self, _block: &Block, _height: u32) {
                unreachable!()
        }
@@ -211,9 +211,9 @@ impl<'a> chain::Listen for DynamicChainListener<'a> {
 }
 
 /// A set of dynamically sized chain listeners, each paired with a starting block height.
-struct ChainListenerSet<'a>(Vec<(u32, &'a mut dyn chain::Listen)>);
+struct ChainListenerSet<'a, L: chain::Listen + ?Sized>(Vec<(u32, &'a L)>);
 
-impl<'a> chain::Listen for ChainListenerSet<'a> {
+impl<'a, L: chain::Listen + ?Sized> chain::Listen for ChainListenerSet<'a, L> {
        fn block_connected(&self, block: &Block, height: u32) {
                for (starting_height, chain_listener) in self.0.iter() {
                        if height > *starting_height {
@@ -238,20 +238,20 @@ mod tests {
        async fn sync_from_same_chain() {
                let mut chain = Blockchain::default().with_height(4);
 
-               let mut listener_1 = MockChainListener::new()
+               let listener_1 = MockChainListener::new()
                        .expect_block_connected(*chain.at_height(2))
                        .expect_block_connected(*chain.at_height(3))
                        .expect_block_connected(*chain.at_height(4));
-               let mut listener_2 = MockChainListener::new()
+               let listener_2 = MockChainListener::new()
                        .expect_block_connected(*chain.at_height(3))
                        .expect_block_connected(*chain.at_height(4));
-               let mut listener_3 = MockChainListener::new()
+               let listener_3 = MockChainListener::new()
                        .expect_block_connected(*chain.at_height(4));
 
                let listeners = vec![
-                       (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),
+                       (chain.at_height(1).block_hash, &listener_1 as &dyn chain::Listen),
+                       (chain.at_height(2).block_hash, &listener_2 as &dyn chain::Listen),
+                       (chain.at_height(3).block_hash, &listener_3 as &dyn chain::Listen),
                ];
                let mut cache = chain.header_cache(0..=4);
                match synchronize_listeners(&mut chain, Network::Bitcoin, &mut cache, listeners).await {
@@ -267,26 +267,26 @@ mod tests {
                let fork_chain_2 = main_chain.fork_at_height(2);
                let fork_chain_3 = main_chain.fork_at_height(3);
 
-               let mut listener_1 = MockChainListener::new()
+               let listener_1 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_1.at_height(4))
                        .expect_block_disconnected(*fork_chain_1.at_height(3))
                        .expect_block_disconnected(*fork_chain_1.at_height(2))
                        .expect_block_connected(*main_chain.at_height(2))
                        .expect_block_connected(*main_chain.at_height(3))
                        .expect_block_connected(*main_chain.at_height(4));
-               let mut listener_2 = MockChainListener::new()
+               let listener_2 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_2.at_height(4))
                        .expect_block_disconnected(*fork_chain_2.at_height(3))
                        .expect_block_connected(*main_chain.at_height(3))
                        .expect_block_connected(*main_chain.at_height(4));
-               let mut listener_3 = MockChainListener::new()
+               let listener_3 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_3.at_height(4))
                        .expect_block_connected(*main_chain.at_height(4));
 
                let listeners = vec![
-                       (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),
+                       (fork_chain_1.tip().block_hash, &listener_1 as &dyn chain::Listen),
+                       (fork_chain_2.tip().block_hash, &listener_2 as &dyn chain::Listen),
+                       (fork_chain_3.tip().block_hash, &listener_3 as &dyn chain::Listen),
                ];
                let mut cache = fork_chain_1.header_cache(2..=4);
                cache.extend(fork_chain_2.header_cache(3..=4));
@@ -304,21 +304,21 @@ mod tests {
                let fork_chain_2 = fork_chain_1.fork_at_height(2);
                let fork_chain_3 = fork_chain_2.fork_at_height(3);
 
-               let mut listener_1 = MockChainListener::new()
+               let listener_1 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_1.at_height(4))
                        .expect_block_disconnected(*fork_chain_1.at_height(3))
                        .expect_block_disconnected(*fork_chain_1.at_height(2))
                        .expect_block_connected(*main_chain.at_height(2))
                        .expect_block_connected(*main_chain.at_height(3))
                        .expect_block_connected(*main_chain.at_height(4));
-               let mut listener_2 = MockChainListener::new()
+               let listener_2 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_2.at_height(4))
                        .expect_block_disconnected(*fork_chain_2.at_height(3))
                        .expect_block_disconnected(*fork_chain_2.at_height(2))
                        .expect_block_connected(*main_chain.at_height(2))
                        .expect_block_connected(*main_chain.at_height(3))
                        .expect_block_connected(*main_chain.at_height(4));
-               let mut listener_3 = MockChainListener::new()
+               let listener_3 = MockChainListener::new()
                        .expect_block_disconnected(*fork_chain_3.at_height(4))
                        .expect_block_disconnected(*fork_chain_3.at_height(3))
                        .expect_block_disconnected(*fork_chain_3.at_height(2))
@@ -327,9 +327,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 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),
+                       (fork_chain_1.tip().block_hash, &listener_1 as &dyn chain::Listen),
+                       (fork_chain_2.tip().block_hash, &listener_2 as &dyn chain::Listen),
+                       (fork_chain_3.tip().block_hash, &listener_3 as &dyn chain::Listen),
                ];
                let mut cache = fork_chain_1.header_cache(2..=4);
                cache.extend(fork_chain_2.header_cache(3..=4));
@@ -347,11 +347,11 @@ mod tests {
                let new_tip = main_chain.tip();
                let old_tip = fork_chain.tip();
 
-               let mut listener = MockChainListener::new()
+               let listener = MockChainListener::new()
                        .expect_block_disconnected(*old_tip)
                        .expect_block_connected(*new_tip);
 
-               let listeners = vec![(old_tip.block_hash, &mut listener as &mut dyn chain::Listen)];
+               let listeners = vec![(old_tip.block_hash, &listener as &dyn chain::Listen)];
                let mut cache = fork_chain.header_cache(2..=2);
                match synchronize_listeners(&mut main_chain, Network::Bitcoin, &mut cache, listeners).await {
                        Ok(_) => {