fix(cbf): wait for first tip and degrade gracefully on partial fetches

Block the startup fee update on the first FiltersSynced event so the
cache is populated before the background loop's first tick, and stop
failing the whole update when Kyoto cannot serve historical blocks
outside its known header range — use whatever recent blocks we have.

Author: febyeji

src/chain/cbf.rs

@@ -877,44 +877,66 @@ impl CbfChainSource {
 
 	/// Derive per-target fee rates from recent blocks' coinbase outputs.
 	///
-	/// Returns `Ok(None)` when no chain tip is available yet (first startup before sync).
+	/// On the very first startup call this waits for the initial `FiltersSynced` event so
+	/// the fee cache gets populated before the background loop's first tick; subsequent
+	/// calls find the tip already set and proceed immediately. The wait shares the
+	/// overall timeout budget with the block fetches below.
+	///
+	/// Returns `Ok(None)` when no chain tip can be established within the budget, or when
+	/// the tip block itself cannot be served by the CBF peer (initial sync / reorg). When
+	/// subsequent historical blocks are unavailable (Kyoto only serves blocks in its
+	/// known header chain range, so walking back far enough hits `UnknownHash`), the
+	/// function falls back to whatever blocks it already fetched rather than failing the
+	/// whole fee update.
 	async fn fee_rate_cache_from_cbf(
 		&self,
 	) -> Result<Option<HashMap<crate::fee_estimator::ConfirmationTarget, FeeRate>>, Error> {
 		let requester = self.requester()?;
 
-		let tip_hash = match *self.latest_tip.lock().unwrap() {
-			Some(hash) => hash,
-			None => {
-				log_debug!(self.logger, "No tip available yet for fee rate estimation, skipping.");
+		let now = Instant::now();
+		let timeout = Duration::from_secs(
+			self.sync_config.timeouts_config.fee_rate_cache_update_timeout_secs,
+		);
+
+		let tip_hash = loop {
+			if let Some(hash) = *self.latest_tip.lock().unwrap() {
+				break hash;
+			}
+			if now.elapsed() >= timeout {
+				log_debug!(
+					self.logger,
+					"No CBF tip available within timeout; skipping fee update.",
+				);
 				return Ok(None);
-			},
+			}
+			tokio::time::sleep(Duration::from_millis(100)).await;
 		};
 
-		let now = Instant::now();
-
 		// Fetch fee rates from the last N blocks for per-target estimation.
 		// We compute fee rates ourselves rather than using Requester::average_fee_rate,
 		// so we can sample multiple blocks and select percentiles per confirmation target.
 		let mut block_fee_rates: Vec<u64> = Vec::with_capacity(FEE_RATE_LOOKBACK_BLOCKS);
 		let mut current_hash = tip_hash;
 
-		let timeout = Duration::from_secs(
-			self.sync_config.timeouts_config.fee_rate_cache_update_timeout_secs,
-		);
-		let fetch_start = Instant::now();
+		let fetch_start = now;
 
 		for idx in 0..FEE_RATE_LOOKBACK_BLOCKS {
 			// Check if we've exceeded the overall timeout for fee estimation.
 			let remaining_timeout = timeout.saturating_sub(fetch_start.elapsed());
 			if remaining_timeout.is_zero() {
+				if !block_fee_rates.is_empty() {
+					break;
+				}
 				log_error!(self.logger, "Updating fee rate estimates timed out.");
 				return Err(Error::FeerateEstimationUpdateTimeout);
 			}
 
 			// Fetch the block via P2P. On the first iteration, a fetch failure
 			// likely means the cached tip is stale (initial sync or reorg), so
 			// we clear the tip and skip gracefully instead of returning an error.
+			// On later iterations we may walk past Kyoto's known header range and
+			// hit `UnknownHash`; in that case we use whatever blocks we already
+			// have rather than failing the whole fee update.
 			let indexed_block =
 				match tokio::time::timeout(remaining_timeout, requester.get_block(current_hash))
 					.await
@@ -932,12 +954,14 @@ impl CbfChainSource {
 						return Ok(None);
 					},
 					Ok(Err(e)) => {
-						log_error!(
+						log_debug!(
 							self.logger,
-							"Failed to fetch block for fee estimation: {:?}",
+							"CBF could not serve block {} during fee estimation after {} successful fetches: {:?}",
+							current_hash,
+							block_fee_rates.len(),
 							e
 						);
-						return Err(Error::FeerateEstimationUpdateFailed);
+						break;
 					},
 					Err(e) if idx == 0 => {
 						log_debug!(
@@ -951,8 +975,14 @@ impl CbfChainSource {
 						return Ok(None);
 					},
 					Err(e) => {
-						log_error!(self.logger, "Updating fee rate estimates timed out: {}", e);
-						return Err(Error::FeerateEstimationUpdateTimeout);
+						log_debug!(
+							self.logger,
+							"Timed out fetching block {} during fee estimation after {} successful fetches: {}",
+							current_hash,
+							block_fee_rates.len(),
+							e
+						);
+						break;
 					},
 				};