Move fee rate cache updating to ChainSource

Author: tnull

src/builder.rs

@@ -590,11 +590,7 @@ fn build_with_store_internal(
 			let esplora_client = client_builder.build_async().unwrap();
 			let tx_broadcaster =
 				Arc::new(TransactionBroadcaster::new(esplora_client.clone(), Arc::clone(&logger)));
-			let fee_estimator = Arc::new(OnchainFeeEstimator::new(
-				esplora_client,
-				Arc::clone(&config),
-				Arc::clone(&logger),
-			));
+			let fee_estimator = Arc::new(OnchainFeeEstimator::new());
 
 			let wallet = Arc::new(Wallet::new(
 				bdk_wallet,
@@ -607,8 +603,11 @@ fn build_with_store_internal(
 			let chain_source = Arc::new(ChainSource::new_esplora(
 				server_url.clone(),
 				Arc::clone(&wallet),
+				Arc::clone(&fee_estimator),
+				Arc::clone(&config),
 				Arc::clone(&logger),
 			));
+
 			(wallet, chain_source, tx_broadcaster, fee_estimator)
 		},
 		None => {
@@ -619,11 +618,7 @@ fn build_with_store_internal(
 			let esplora_client = client_builder.build_async().unwrap();
 			let tx_broadcaster =
 				Arc::new(TransactionBroadcaster::new(esplora_client.clone(), Arc::clone(&logger)));
-			let fee_estimator = Arc::new(OnchainFeeEstimator::new(
-				esplora_client,
-				Arc::clone(&config),
-				Arc::clone(&logger),
-			));
+			let fee_estimator = Arc::new(OnchainFeeEstimator::new());
 
 			let wallet = Arc::new(Wallet::new(
 				bdk_wallet,
@@ -636,6 +631,8 @@ fn build_with_store_internal(
 			let chain_source = Arc::new(ChainSource::new_esplora(
 				server_url.clone(),
 				Arc::clone(&wallet),
+				Arc::clone(&fee_estimator),
+				Arc::clone(&config),
 				Arc::clone(&logger),
 			));
 
@@ -1021,7 +1018,6 @@ fn build_with_store_internal(
 		wallet,
 		chain_source,
 		tx_broadcaster,
-		fee_estimator,
 		event_queue,
 		channel_manager,
 		chain_monitor,

src/chain/mod.rs

@@ -6,10 +6,14 @@
 // accordance with one or both of these licenses.
 
 use crate::config::{
-	BDK_CLIENT_CONCURRENCY, BDK_CLIENT_STOP_GAP, BDK_WALLET_SYNC_TIMEOUT_SECS,
-	LDK_WALLET_SYNC_TIMEOUT_SECS,
+	Config, BDK_CLIENT_CONCURRENCY, BDK_CLIENT_STOP_GAP, BDK_WALLET_SYNC_TIMEOUT_SECS,
+	FEE_RATE_CACHE_UPDATE_TIMEOUT_SECS, LDK_WALLET_SYNC_TIMEOUT_SECS,
 };
-use crate::logger::{log_error, log_info, FilesystemLogger, Logger};
+use crate::fee_estimator::{
+	apply_post_estimation_adjustments, get_all_conf_targets, get_num_block_defaults_for_target,
+	OnchainFeeEstimator,
+};
+use crate::logger::{log_error, log_info, log_trace, FilesystemLogger, Logger};
 use crate::types::Wallet;
 use crate::Error;
 
@@ -21,6 +25,9 @@ use bdk_esplora::EsploraAsyncExt;
 
 use esplora_client::AsyncClient as EsploraAsyncClient;
 
+use bitcoin::{FeeRate, Network};
+
+use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
@@ -90,13 +97,16 @@ pub(crate) enum ChainSource {
 		onchain_wallet_sync_status: Mutex<WalletSyncStatus>,
 		tx_sync: Arc<EsploraSyncClient<Arc<FilesystemLogger>>>,
 		lightning_wallet_sync_status: Mutex<WalletSyncStatus>,
+		fee_estimator: Arc<OnchainFeeEstimator>,
+		config: Arc<Config>,
 		logger: Arc<FilesystemLogger>,
 	},
 }
 
 impl ChainSource {
 	pub(crate) fn new_esplora(
-		server_url: String, onchain_wallet: Arc<Wallet>, logger: Arc<FilesystemLogger>,
+		server_url: String, onchain_wallet: Arc<Wallet>, fee_estimator: Arc<OnchainFeeEstimator>,
+		config: Arc<Config>, logger: Arc<FilesystemLogger>,
 	) -> Self {
 		let mut client_builder = esplora_client::Builder::new(&server_url.clone());
 		client_builder = client_builder.timeout(DEFAULT_ESPLORA_CLIENT_TIMEOUT_SECS);
@@ -111,6 +121,8 @@ impl ChainSource {
 			onchain_wallet_sync_status,
 			tx_sync,
 			lightning_wallet_sync_status,
+			fee_estimator,
+			config,
 			logger,
 		}
 	}
@@ -218,6 +230,74 @@ impl ChainSource {
 			},
 		}
 	}
+
+	pub(crate) async fn update_fee_rate_estimates(&self) -> Result<(), Error> {
+		match self {
+			Self::Esplora { esplora_client, fee_estimator, config, logger, .. } => {
+				let estimates = tokio::time::timeout(
+					Duration::from_secs(FEE_RATE_CACHE_UPDATE_TIMEOUT_SECS),
+					esplora_client.get_fee_estimates(),
+				)
+				.await
+				.map_err(|e| {
+					log_error!(logger, "Updating fee rate estimates timed out: {}", e);
+					Error::FeerateEstimationUpdateTimeout
+				})?
+				.map_err(|e| {
+					log_error!(logger, "Failed to retrieve fee rate estimates: {}", e);
+					Error::FeerateEstimationUpdateFailed
+				})?;
+
+				if estimates.is_empty() && config.network == Network::Bitcoin {
+					// Ensure we fail if we didn't receive any estimates.
+					log_error!(
+						logger,
+						"Failed to retrieve fee rate estimates: empty fee estimates are dissallowed on Mainnet.",
+					);
+					return Err(Error::FeerateEstimationUpdateFailed);
+				}
+
+				let confirmation_targets = get_all_conf_targets();
+
+				let mut new_fee_rate_cache = HashMap::with_capacity(10);
+				for target in confirmation_targets {
+					let num_blocks = get_num_block_defaults_for_target(target);
+
+					let converted_estimate_sat_vb =
+						esplora_client::convert_fee_rate(num_blocks, estimates.clone()).map_err(
+							|e| {
+								log_error!(
+									logger,
+									"Failed to convert fee rate estimates for {:?}: {}",
+									target,
+									e
+								);
+								Error::FeerateEstimationUpdateFailed
+							},
+						)?;
+
+					let fee_rate =
+						FeeRate::from_sat_per_kwu((converted_estimate_sat_vb * 250.0) as u64);
+
+					// LDK 0.0.118 introduced changes to the `ConfirmationTarget` semantics that
+					// require some post-estimation adjustments to the fee rates, which we do here.
+					let adjusted_fee_rate = apply_post_estimation_adjustments(target, fee_rate);
+
+					new_fee_rate_cache.insert(target, adjusted_fee_rate);
+
+					log_trace!(
+						logger,
+						"Fee rate estimation updated for {:?}: {} sats/kwu",
+						target,
+						adjusted_fee_rate.to_sat_per_kwu(),
+					);
+				}
+
+				fee_estimator.set_fee_rate_cache(new_fee_rate_cache);
+				Ok(())
+			},
+		}
+	}
 }
 
 impl Filter for ChainSource {

src/fee_estimator.rs

@@ -5,23 +5,14 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
-use crate::config::FEE_RATE_CACHE_UPDATE_TIMEOUT_SECS;
-use crate::logger::{log_error, log_trace, Logger};
-use crate::{Config, Error};
-
 use lightning::chain::chaininterface::ConfirmationTarget as LdkConfirmationTarget;
 use lightning::chain::chaininterface::FeeEstimator as LdkFeeEstimator;
 use lightning::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW;
 
 use bitcoin::FeeRate;
-use esplora_client::AsyncClient as EsploraClient;
-
-use bitcoin::Network;
 
 use std::collections::HashMap;
-use std::ops::Deref;
-use std::sync::{Arc, RwLock};
-use std::time::Duration;
+use std::sync::RwLock;
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 pub(crate) enum ConfirmationTarget {
@@ -43,87 +34,22 @@ impl From<LdkConfirmationTarget> for ConfirmationTarget {
 	}
 }
 
-pub(crate) struct OnchainFeeEstimator<L: Deref>
-where
-	L::Target: Logger,
-{
+pub(crate) struct OnchainFeeEstimator {
 	fee_rate_cache: RwLock<HashMap<ConfirmationTarget, FeeRate>>,
-	esplora_client: EsploraClient,
-	config: Arc<Config>,
-	logger: L,
 }
 
-impl<L: Deref> OnchainFeeEstimator<L>
-where
-	L::Target: Logger,
-{
-	pub(crate) fn new(esplora_client: EsploraClient, config: Arc<Config>, logger: L) -> Self {
+impl OnchainFeeEstimator {
+	pub(crate) fn new() -> Self {
 		let fee_rate_cache = RwLock::new(HashMap::new());
-		Self { fee_rate_cache, esplora_client, config, logger }
+		Self { fee_rate_cache }
 	}
 
-	pub(crate) async fn update_fee_estimates(&self) -> Result<(), Error> {
-		let estimates = tokio::time::timeout(
-			Duration::from_secs(FEE_RATE_CACHE_UPDATE_TIMEOUT_SECS),
-			self.esplora_client.get_fee_estimates(),
-		)
-		.await
-		.map_err(|e| {
-			log_error!(self.logger, "Updating fee rate estimates timed out: {}", e);
-			Error::FeerateEstimationUpdateTimeout
-		})?
-		.map_err(|e| {
-			log_error!(self.logger, "Failed to retrieve fee rate estimates: {}", e);
-			Error::FeerateEstimationUpdateFailed
-		})?;
-
-		if estimates.is_empty() && self.config.network == Network::Bitcoin {
-			// Ensure we fail if we didn't receive any estimates.
-			log_error!(
-				self.logger,
-				"Failed to retrieve fee rate estimates: empty fee estimates are dissallowed on Mainnet.",
-			);
-			return Err(Error::FeerateEstimationUpdateFailed);
-		}
-
-		let confirmation_targets = get_all_conf_targets();
-		for target in confirmation_targets {
-			let num_blocks = get_num_block_defaults_for_target(target);
-
-			let converted_estimate_sat_vb =
-				esplora_client::convert_fee_rate(num_blocks, estimates.clone()).map_err(|e| {
-					log_error!(
-						self.logger,
-						"Failed to convert fee rate estimates for {:?}: {}",
-						target,
-						e
-					);
-					Error::FeerateEstimationUpdateFailed
-				})?;
-
-			let fee_rate = FeeRate::from_sat_per_kwu((converted_estimate_sat_vb * 250.0) as u64);
-
-			// LDK 0.0.118 introduced changes to the `ConfirmationTarget` semantics that
-			// require some post-estimation adjustments to the fee rates, which we do here.
-			let adjusted_fee_rate = apply_post_estimation_adjustments(target, fee_rate);
-
-			let mut locked_fee_rate_cache = self.fee_rate_cache.write().unwrap();
-			locked_fee_rate_cache.insert(target, adjusted_fee_rate);
-			log_trace!(
-				self.logger,
-				"Fee rate estimation updated for {:?}: {} sats/kwu",
-				target,
-				adjusted_fee_rate.to_sat_per_kwu(),
-			);
-		}
-		Ok(())
+	pub(crate) fn set_fee_rate_cache(&self, fee_rate_cache: HashMap<ConfirmationTarget, FeeRate>) {
+		*self.fee_rate_cache.write().unwrap() = fee_rate_cache;
 	}
 }
 
-impl<L: Deref> FeeEstimator for OnchainFeeEstimator<L>
-where
-	L::Target: Logger,
-{
+impl FeeEstimator for OnchainFeeEstimator {
 	fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate {
 		let locked_fee_rate_cache = self.fee_rate_cache.read().unwrap();
 
@@ -140,10 +66,7 @@ where
 	}
 }
 
-impl<L: Deref> LdkFeeEstimator for OnchainFeeEstimator<L>
-where
-	L::Target: Logger,
-{
+impl LdkFeeEstimator for OnchainFeeEstimator {
 	fn get_est_sat_per_1000_weight(&self, confirmation_target: LdkConfirmationTarget) -> u32 {
 		self.estimate_fee_rate(confirmation_target.into()).to_sat_per_kwu() as u32
 	}

src/io/utils.rs

@@ -9,10 +9,11 @@ use super::*;
 use crate::config::WALLET_KEYS_SEED_LEN;
 
 use crate::chain::ChainSource;
+use crate::fee_estimator::OnchainFeeEstimator;
 use crate::logger::{log_error, FilesystemLogger};
 use crate::peer_store::PeerStore;
 use crate::sweep::DeprecatedSpendableOutputInfo;
-use crate::types::{Broadcaster, DynStore, FeeEstimator, KeysManager, Sweeper};
+use crate::types::{Broadcaster, DynStore, KeysManager, Sweeper};
 use crate::wallet::ser::{ChangeSetDeserWrapper, ChangeSetSerWrapper};
 use crate::{Error, EventQueue, PaymentDetails};
 
@@ -220,7 +221,7 @@ where
 
 /// Read `OutputSweeper` state from the store.
 pub(crate) fn read_output_sweeper(
-	broadcaster: Arc<Broadcaster>, fee_estimator: Arc<FeeEstimator>,
+	broadcaster: Arc<Broadcaster>, fee_estimator: Arc<OnchainFeeEstimator>,
 	chain_data_source: Arc<ChainSource>, keys_manager: Arc<KeysManager>, kv_store: Arc<DynStore>,
 	logger: Arc<FilesystemLogger>,
 ) -> Result<Sweeper, std::io::Error> {