Use the header cache across listeners during initial disconnect

In `lightning-blocksync::init::synchronize_listeners`, we may have
many listeners we want to do a chain diff on. When doing so, we
should make sure we utilize our header cache, rather than querying
our chain source for every header we need for each listener.

Here we do so, inserting into the cache as we do chain diffs.

On my node with a bitcoind on localhost, this brings the
calculate-differences step of `init::synchronize_listeners` from
~500ms to under 150ms.

Author: TheBlueMatt

lightning-block-sync/src/lib.rs

@@ -198,6 +198,10 @@ pub(crate) trait Cache {
 	/// Retrieves the block header keyed by the given block hash.
 	fn look_up(&self, block_hash: &BlockHash) -> Option<&ValidatedBlockHeader>;
 
+	/// Inserts the given block header during a find_difference operation, implying it might not be
+	/// the best header.
+	fn insert_during_diff(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader);
+
 	/// Called when a block has been connected to the best chain to ensure it is available to be
 	/// disconnected later if needed.
 	fn block_connected(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader);
@@ -226,6 +230,15 @@ impl Cache for HeaderCache {
 		self.0.get(block_hash)
 	}
 
+	fn insert_during_diff(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader) {
+		self.0.insert(block_hash, block_header);
+
+		// Remove headers older than our newest header minus a week.
+		let best_height = self.0.iter().map(|(_, header)| header.height).max().unwrap_or(0);
+		let cutoff_height = best_height.saturating_sub(6 * 24 * 7);
+		self.0.retain(|_, header| header.height >= cutoff_height);
+	}
+
 	fn block_connected(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader) {
 		self.0.insert(block_hash, block_header);
 
@@ -244,6 +257,10 @@ impl Cache for &mut HeaderCache {
 		self.0.get(block_hash)
 	}
 
+	fn insert_during_diff(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader) {
+		(*self).insert_during_diff(block_hash, block_header);
+	}
+
 	fn block_connected(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader) {
 		(*self).block_connected(block_hash, block_header);
 	}
@@ -380,7 +397,7 @@ where
 	/// First resolves `prev_best_block` to a `ValidatedBlockHeader` using the `previous_blocks`
 	/// field as fallback if needed, then finds the common ancestor.
 	async fn find_difference_from_best_block<P: Poll>(
-		&self, current_header: ValidatedBlockHeader, prev_best_block: BestBlock,
+		&mut self, current_header: ValidatedBlockHeader, prev_best_block: BestBlock,
 		chain_poller: &mut P,
 	) -> BlockSourceResult<ChainDifference> {
 		// Try to resolve the header for the previous best block. First try the block_hash,
@@ -405,6 +422,7 @@ where
 			)?;
 			if let Ok(header) = chain_poller.get_header(block_hash, Some(height)).await {
 				found_header = Some(header);
+				self.header_cache.insert_during_diff(*block_hash, header);
 				break;
 			}
 		}