Implement fee rate estmation updating

Author: tnull

Cargo.toml

@@ -73,6 +73,7 @@ tokio = { version = "1.37", default-features = false, features = [ "rt-multi-thr
 esplora-client = { version = "0.9", default-features = false }
 libc = "0.2"
 uniffi = { version = "0.26.0", features = ["build"], optional = true }
+serde = { version = "1.0.210", default-features = false, features = ["std", "derive"] }
 serde_json = { version = "1.0.128", default-features = false, features = ["std"] }
 
 [target.'cfg(vss)'.dependencies]

src/chain/bitcoind_rpc.rs

@@ -10,13 +10,16 @@ use crate::types::{ChainMonitor, ChannelManager, Sweeper, Wallet};
 use lightning::chain::Listen;
 
 use lightning_block_sync::http::HttpEndpoint;
+use lightning_block_sync::http::JsonResponse;
 use lightning_block_sync::poll::ValidatedBlockHeader;
 use lightning_block_sync::rpc::RpcClient;
 use lightning_block_sync::{
 	AsyncBlockSourceResult, BlockData, BlockHeaderData, BlockSource, Cache,
 };
 
-use bitcoin::{BlockHash, Transaction, Txid};
+use serde::Serialize;
+
+use bitcoin::{BlockHash, FeeRate, Transaction, Txid};
 
 use base64::prelude::{Engine, BASE64_STANDARD};
 
@@ -46,6 +49,27 @@ impl BitcoindRpcClient {
 		let tx_json = serde_json::json!(tx_serialized);
 		self.rpc_client.call_method::<Txid>("sendrawtransaction", &vec![tx_json]).await
 	}
+
+	pub(crate) async fn get_fee_estimate_for_target(
+		&self, num_blocks: usize, estimation_mode: FeeRateEstimationMode,
+	) -> std::io::Result<FeeRate> {
+		let num_blocks_json = serde_json::json!(num_blocks);
+		let estimation_mode_json = serde_json::json!(estimation_mode);
+		self.rpc_client
+			.call_method::<FeeResponse>(
+				"estimatesmartfee",
+				&vec![num_blocks_json, estimation_mode_json],
+			)
+			.await
+			.map(|resp| resp.0)
+	}
+
+	pub(crate) async fn get_mempool_minimum_fee_rate(&self) -> std::io::Result<FeeRate> {
+		self.rpc_client
+			.call_method::<MempoolMinFeeResponse>("getmempoolinfo", &vec![])
+			.await
+			.map(|resp| resp.0)
+	}
 }
 
 impl BlockSource for BitcoindRpcClient {
@@ -66,6 +90,55 @@ impl BlockSource for BitcoindRpcClient {
 	}
 }
 
+pub(crate) struct FeeResponse(pub FeeRate);
+
+impl TryInto<FeeResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<FeeResponse> {
+		if !self.0["errors"].is_null() {
+			return Err(std::io::Error::new(
+				std::io::ErrorKind::Other,
+				self.0["errors"].to_string(),
+			));
+		}
+		let fee_rate_btc_per_kvbyte = self.0["feerate"]
+			.as_f64()
+			.ok_or(std::io::Error::new(std::io::ErrorKind::Other, "Failed to parse fee rate"))?;
+		// Bitcoin Core gives us a feerate in BTC/KvB.
+		// Thus, we multiply by 25_000_000 (10^8 / 4) to get satoshis/kwu.
+		let fee_rate = {
+			let fee_rate_sat_per_kwu = (fee_rate_btc_per_kvbyte * 25_000_000.0).round() as u64;
+			FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu)
+		};
+		Ok(FeeResponse(fee_rate))
+	}
+}
+
+pub struct MempoolMinFeeResponse(pub FeeRate);
+
+impl TryInto<MempoolMinFeeResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<MempoolMinFeeResponse> {
+		let fee_rate_btc_per_kvbyte = self.0["mempoolminfee"]
+			.as_f64()
+			.ok_or(std::io::Error::new(std::io::ErrorKind::Other, "Failed to parse fee rate"))?;
+		// Bitcoin Core gives us a feerate in BTC/KvB.
+		// Thus, we multiply by 25_000_000 (10^8 / 4) to get satoshis/kwu.
+		let fee_rate = {
+			let fee_rate_sat_per_kwu = (fee_rate_btc_per_kvbyte * 25_000_000.0).round() as u64;
+			FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu)
+		};
+		Ok(MempoolMinFeeResponse(fee_rate))
+	}
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub(crate) enum FeeRateEstimationMode {
+	Economical,
+	Conservative,
+}
+
 const MAX_HEADER_CACHE_ENTRIES: usize = 100;
 
 pub(super) struct BoundedHeaderCache {

src/chain/mod.rs

@@ -8,7 +8,9 @@
 mod bitcoind_rpc;
 mod block_sync_init;
 
-use crate::chain::bitcoind_rpc::{BitcoindRpcClient, BoundedHeaderCache, ChainListener};
+use crate::chain::bitcoind_rpc::{
+	BitcoindRpcClient, BoundedHeaderCache, ChainListener, FeeRateEstimationMode,
+};
 use crate::chain::block_sync_init::synchronize_listeners;
 use crate::config::{
 	Config, EsploraSyncConfig, BDK_CLIENT_CONCURRENCY, BDK_CLIENT_STOP_GAP,
@@ -18,13 +20,14 @@ use crate::config::{
 };
 use crate::fee_estimator::{
 	apply_post_estimation_adjustments, get_all_conf_targets, get_num_block_defaults_for_target,
-	OnchainFeeEstimator,
+	ConfirmationTarget, OnchainFeeEstimator,
 };
 use crate::io::utils::write_node_metrics;
 use crate::logger::{log_bytes, log_error, log_info, log_trace, FilesystemLogger, Logger};
 use crate::types::{Broadcaster, ChainMonitor, ChannelManager, DynStore, Sweeper, Wallet};
 use crate::{Error, NodeMetrics};
 
+use lightning::chain::chaininterface::ConfirmationTarget as LdkConfirmationTarget;
 use lightning::chain::{Confirm, Filter, Listen};
 use lightning::util::ser::Writeable;
 
@@ -348,6 +351,13 @@ impl ChainSource {
 				chain_polling_interval
 					.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
 
+				let mut fee_rate_update_interval =
+					tokio::time::interval(Duration::from_secs(CHAIN_POLLING_INTERVAL_SECS));
+				// When starting up, we just blocked on updating, so skip the first tick.
+				fee_rate_update_interval.reset();
+				fee_rate_update_interval
+					.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+
 				// Start the polling loop.
 				loop {
 					tokio::select! {
@@ -382,6 +392,9 @@ impl ChainSource {
 								});
 							}
 						}
+						_ = fee_rate_update_interval.tick() => {
+							let _ = self.update_fee_rate_estimates().await;
+						}
 					}
 				}
 			},
@@ -704,7 +717,108 @@ impl ChainSource {
 
 				Ok(())
 			},
-			Self::BitcoindRpc { .. } => todo!(),
+			Self::BitcoindRpc {
+				bitcoind_rpc_client,
+				fee_estimator,
+				kv_store,
+				logger,
+				node_metrics,
+				..
+			} => {
+				macro_rules! get_fee_rate_update {
+					($estimation_fut: expr) => {{
+						tokio::time::timeout(
+							Duration::from_secs(FEE_RATE_CACHE_UPDATE_TIMEOUT_SECS),
+							$estimation_fut,
+						)
+						.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
+						})?
+					}};
+				}
+				let confirmation_targets = get_all_conf_targets();
+
+				let mut new_fee_rate_cache = HashMap::with_capacity(10);
+				let now = Instant::now();
+				for target in confirmation_targets {
+					let fee_rate = match target {
+						ConfirmationTarget::Lightning(
+							LdkConfirmationTarget::MinAllowedAnchorChannelRemoteFee,
+						) => {
+							let estimation_fut = bitcoind_rpc_client.get_mempool_minimum_fee_rate();
+							get_fee_rate_update!(estimation_fut)
+						},
+						ConfirmationTarget::Lightning(
+							LdkConfirmationTarget::MaximumFeeEstimate,
+						) => {
+							let num_blocks = get_num_block_defaults_for_target(target);
+							let estimation_mode = FeeRateEstimationMode::Conservative;
+							let estimation_fut = bitcoind_rpc_client
+								.get_fee_estimate_for_target(num_blocks, estimation_mode);
+							get_fee_rate_update!(estimation_fut)
+						},
+						ConfirmationTarget::Lightning(
+							LdkConfirmationTarget::UrgentOnChainSweep,
+						) => {
+							let num_blocks = get_num_block_defaults_for_target(target);
+							let estimation_mode = FeeRateEstimationMode::Conservative;
+							let estimation_fut = bitcoind_rpc_client
+								.get_fee_estimate_for_target(num_blocks, estimation_mode);
+							get_fee_rate_update!(estimation_fut)
+						},
+						_ => {
+							// Otherwise, we default to economical block-target estimate.
+							let num_blocks = get_num_block_defaults_for_target(target);
+							let estimation_mode = FeeRateEstimationMode::Economical;
+							let estimation_fut = bitcoind_rpc_client
+								.get_fee_estimate_for_target(num_blocks, estimation_mode);
+							get_fee_rate_update!(estimation_fut)
+						},
+					};
+
+					// 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(),
+					);
+				}
+
+				if fee_estimator.set_fee_rate_cache(new_fee_rate_cache) {
+					// We only log if the values changed, as it might be very spammy otherwise.
+					log_info!(
+						logger,
+						"Fee rate cache update finished in {}ms.",
+						now.elapsed().as_millis()
+					);
+				}
+
+				let unix_time_secs_opt =
+					SystemTime::now().duration_since(UNIX_EPOCH).ok().map(|d| d.as_secs());
+				{
+					let mut locked_node_metrics = node_metrics.write().unwrap();
+					locked_node_metrics.latest_fee_rate_cache_update_timestamp = unix_time_secs_opt;
+					write_node_metrics(
+						&*locked_node_metrics,
+						Arc::clone(&kv_store),
+						Arc::clone(&logger),
+					)?;
+				}
+
+				Ok(())
+			},
 		}
 	}
 

src/fee_estimator.rs

@@ -44,8 +44,17 @@ impl OnchainFeeEstimator {
 		Self { fee_rate_cache }
 	}
 
-	pub(crate) fn set_fee_rate_cache(&self, fee_rate_cache: HashMap<ConfirmationTarget, FeeRate>) {
-		*self.fee_rate_cache.write().unwrap() = fee_rate_cache;
+	// Updates the fee rate cache and returns if the new values changed.
+	pub(crate) fn set_fee_rate_cache(
+		&self, fee_rate_cache_update: HashMap<ConfirmationTarget, FeeRate>,
+	) -> bool {
+		let mut locked_fee_rate_cache = self.fee_rate_cache.write().unwrap();
+		if fee_rate_cache_update != *locked_fee_rate_cache {
+			*locked_fee_rate_cache = fee_rate_cache_update;
+			true
+		} else {
+			false
+		}
 	}
 }