f no cache trait

Author: TheBlueMatt

lightning-block-sync/src/init.rs

@@ -3,7 +3,7 @@
 
 use crate::async_poll::{MultiResultFuturePoller, ResultFuture};
 use crate::poll::{ChainPoller, Poll, Validate, ValidatedBlockHeader};
-use crate::{BlockData, BlockSource, BlockSourceResult, Cache, ChainNotifier, HeaderCache};
+use crate::{BlockData, BlockSource, BlockSourceResult, ChainNotifier, HeaderCache};
 
 use bitcoin::block::Header;
 use bitcoin::network::Network;
@@ -152,13 +152,13 @@ where
 	let mut chain_listeners_at_height = Vec::new();
 	let mut most_connected_blocks = Vec::new();
 	let mut header_cache = HeaderCache::new();
+	header_cache.retain_on_disconnect = true;
 	for (old_best_block, chain_listener) in chain_listeners.drain(..) {
 		// Disconnect any stale blocks, but keep them in the cache for the next iteration.
 		let (common_ancestor, connected_blocks) = {
 			let chain_listener = &DynamicChainListener(chain_listener);
-			let mut cache_wrapper = HeaderCacheNoDisconnect(&mut header_cache);
 			let mut chain_notifier =
-				ChainNotifier { header_cache: &mut cache_wrapper, chain_listener };
+				ChainNotifier { header_cache: &mut header_cache, chain_listener };
 			let difference = chain_notifier
 				.find_difference_from_best_block(best_header, old_best_block, &mut chain_poller)
 				.await?;
@@ -228,6 +228,7 @@ where
 			.truncate(most_connected_blocks.len().saturating_sub(MAX_BLOCKS_AT_ONCE));
 	}
 
+	header_cache.retain_on_disconnect = false;
 	Ok((header_cache, best_header))
 }
 
@@ -246,40 +247,12 @@ impl<'a, L: chain::Listen + ?Sized> chain::Listen for DynamicChainListener<'a, L
 	}
 }
 
-/// Wrapper around HeaderCache that ignores `blocks_disconnected` calls, retaining disconnected
-/// blocks in the cache. This is useful during initial sync to keep headers available across
-/// multiple listeners.
-struct HeaderCacheNoDisconnect<'a>(&'a mut HeaderCache);
-
-impl<'a> crate::Cache for &mut HeaderCacheNoDisconnect<'a> {
-	fn look_up(
-		&self, block_hash: &bitcoin::hash_types::BlockHash,
-	) -> Option<&ValidatedBlockHeader> {
-		self.0.look_up(block_hash)
-	}
-
-	fn insert_during_diff(
-		&mut self, block_hash: bitcoin::hash_types::BlockHash, block_header: ValidatedBlockHeader,
-	) {
-		self.0.insert_during_diff(block_hash, block_header);
-	}
-
-	fn block_connected(
-		&mut self, block_hash: bitcoin::hash_types::BlockHash, block_header: ValidatedBlockHeader,
-	) {
-		self.0.block_connected(block_hash, block_header);
-	}
-
-	fn blocks_disconnected(&mut self, _fork_point: &ValidatedBlockHeader) {
-		// Intentionally ignore disconnections to retain blocks in cache
-	}
-}
 
 #[cfg(test)]
 mod tests {
 	use super::*;
 	use crate::test_utils::{Blockchain, MockChainListener};
-	use crate::Cache;
+
 
 	#[tokio::test]
 	async fn sync_from_same_chain() {

lightning-block-sync/src/lib.rs

@@ -193,12 +193,15 @@ pub const HEADER_CACHE_LIMIT: u32 = 6 * 24 * 7;
 /// Retains only the latest [`HEADER_CACHE_LIMIT`] block headers based on height.
 pub struct HeaderCache {
 	headers: std::collections::HashMap<BlockHash, ValidatedBlockHeader>,
+	/// When set, [`Self::blocks_disconnected`] will not evict headers above the fork point.
+	/// This is used during initial sync to retain headers across multiple listeners.
+	retain_on_disconnect: bool,
 }
 
 impl HeaderCache {
 	/// Creates a new empty header cache.
 	pub fn new() -> Self {
-		Self { headers: std::collections::HashMap::new() }
+		Self { headers: std::collections::HashMap::new(), retain_on_disconnect: false }
 	}
 
 	/// Retrieves the block header keyed by the given block hash.
@@ -234,9 +237,12 @@ impl HeaderCache {
 	/// Called when blocks have been disconnected from the best chain. Only the fork point
 	/// (best common ancestor) is provided.
 	///
-	/// Once disconnected, a block's header is no longer needed and thus can be removed.
+	/// Once disconnected, unless [`Self::retain_on_disconnect`] is set, a block's header is no
+	/// longer needed and thus can be removed.
 	pub(crate) fn blocks_disconnected(&mut self, fork_point: &ValidatedBlockHeader) {
-		self.headers.retain(|_, block_info| block_info.height <= fork_point.height);
+		if !self.retain_on_disconnect {
+			self.headers.retain(|_, block_info| block_info.height <= fork_point.height);
+		}
 	}
 }