Refactor FeeEstimator to introduce local target variants

.. previously we used LDK's `FeeEstimator` and `ConfirmationTarget` and
~misused some of the latter's variants for our non-Lightning operations.

Here, we introduce our own `FeeEstimator` and `ConfirmationTarget`
allowing to add specific variants for `ChannelFunding` and
`OnchainPayment`s, for example.

src/event.rs

@@ -6,6 +6,7 @@ use crate::{
 };
 
 use crate::connection::ConnectionManager;
+use crate::fee_estimator::ConfirmationTarget;
 
 use crate::payment::store::{
 	PaymentDetails, PaymentDetailsUpdate, PaymentDirection, PaymentKind, PaymentStatus,
@@ -18,7 +19,6 @@ use crate::io::{
 };
 use crate::logger::{log_debug, log_error, log_info, Logger};
 
-use lightning::chain::chaininterface::ConfirmationTarget;
 use lightning::events::bump_transaction::BumpTransactionEvent;
 use lightning::events::{ClosureReason, PaymentPurpose};
 use lightning::events::{Event as LdkEvent, PaymentFailureReason};
@@ -398,7 +398,7 @@ where
 			} => {
 				// Construct the raw transaction with the output that is paid the amount of the
 				// channel.
-				let confirmation_target = ConfirmationTarget::NonAnchorChannelFee;
+				let confirmation_target = ConfirmationTarget::ChannelFunding;
 
 				// We set nLockTime to the current height to discourage fee sniping.
 				let cur_height = self.channel_manager.current_best_block().height;

src/fee_estimator.rs

@@ -2,9 +2,9 @@ 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, FeeEstimator, FEERATE_FLOOR_SATS_PER_KW,
-};
+use lightning::chain::chaininterface::ConfirmationTarget as LdkConfirmationTarget;
+use lightning::chain::chaininterface::FeeEstimator as LdkFeeEstimator;
+use lightning::chain::chaininterface::FEERATE_FLOOR_SATS_PER_KW;
 
 use bdk::FeeRate;
 use esplora_client::AsyncClient as EsploraClient;
@@ -17,6 +17,26 @@ use std::ops::Deref;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub(crate) enum ConfirmationTarget {
+	/// The default target for onchain payments.
+	OnchainPayment,
+	/// The target which we use for funding transactions.
+	ChannelFunding,
+	/// Targets used by LDK.
+	Lightning(LdkConfirmationTarget),
+}
+
+pub(crate) trait FeeEstimator {
+	fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate;
+}
+
+impl From<LdkConfirmationTarget> for ConfirmationTarget {
+	fn from(value: LdkConfirmationTarget) -> Self {
+		Self::Lightning(value)
+	}
+}
+
 pub(crate) struct OnchainFeeEstimator<L: Deref>
 where
 	L::Target: Logger,
@@ -61,23 +81,30 @@ where
 		}
 
 		let confirmation_targets = vec![
-			ConfirmationTarget::OnChainSweep,
-			ConfirmationTarget::MinAllowedAnchorChannelRemoteFee,
-			ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee,
-			ConfirmationTarget::AnchorChannelFee,
-			ConfirmationTarget::NonAnchorChannelFee,
-			ConfirmationTarget::ChannelCloseMinimum,
-			ConfirmationTarget::OutputSpendingFee,
+			ConfirmationTarget::OnchainPayment,
+			ConfirmationTarget::ChannelFunding,
+			LdkConfirmationTarget::OnChainSweep.into(),
+			LdkConfirmationTarget::MinAllowedAnchorChannelRemoteFee.into(),
+			LdkConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee.into(),
+			LdkConfirmationTarget::AnchorChannelFee.into(),
+			LdkConfirmationTarget::NonAnchorChannelFee.into(),
+			LdkConfirmationTarget::ChannelCloseMinimum.into(),
+			LdkConfirmationTarget::OutputSpendingFee.into(),
 		];
+
 		for target in confirmation_targets {
 			let num_blocks = match target {
-				ConfirmationTarget::OnChainSweep => 6,
-				ConfirmationTarget::MinAllowedAnchorChannelRemoteFee => 1008,
-				ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee => 144,
-				ConfirmationTarget::AnchorChannelFee => 1008,
-				ConfirmationTarget::NonAnchorChannelFee => 12,
-				ConfirmationTarget::ChannelCloseMinimum => 144,
-				ConfirmationTarget::OutputSpendingFee => 12,
+				ConfirmationTarget::OnchainPayment => 6,
+				ConfirmationTarget::ChannelFunding => 12,
+				ConfirmationTarget::Lightning(ldk_target) => match ldk_target {
+					LdkConfirmationTarget::OnChainSweep => 6,
+					LdkConfirmationTarget::MinAllowedAnchorChannelRemoteFee => 1008,
+					LdkConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee => 144,
+					LdkConfirmationTarget::AnchorChannelFee => 1008,
+					LdkConfirmationTarget::NonAnchorChannelFee => 12,
+					LdkConfirmationTarget::ChannelCloseMinimum => 144,
+					LdkConfirmationTarget::OutputSpendingFee => 12,
+				},
 			};
 
 			let converted_estimates =
@@ -96,7 +123,9 @@ where
 			// 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 = match target {
-				ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee => {
+				ConfirmationTarget::Lightning(
+					LdkConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee,
+				) => {
 					let slightly_less_than_background =
 						fee_rate.fee_wu(Weight::from_wu(1000)) - 250;
 					FeeRate::from_sat_per_kwu(slightly_less_than_background as f32)
@@ -115,33 +144,53 @@ where
 		}
 		Ok(())
 	}
+}
 
-	pub(crate) fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate {
+impl<L: Deref> FeeEstimator for OnchainFeeEstimator<L>
+where
+	L::Target: Logger,
+{
+	fn estimate_fee_rate(&self, confirmation_target: ConfirmationTarget) -> FeeRate {
 		let locked_fee_rate_cache = self.fee_rate_cache.read().unwrap();
 
 		let fallback_sats_kwu = match confirmation_target {
-			ConfirmationTarget::OnChainSweep => 5000,
-			ConfirmationTarget::MinAllowedAnchorChannelRemoteFee => FEERATE_FLOOR_SATS_PER_KW,
-			ConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee => FEERATE_FLOOR_SATS_PER_KW,
-			ConfirmationTarget::AnchorChannelFee => 500,
-			ConfirmationTarget::NonAnchorChannelFee => 1000,
-			ConfirmationTarget::ChannelCloseMinimum => 500,
-			ConfirmationTarget::OutputSpendingFee => 1000,
+			ConfirmationTarget::OnchainPayment => 5000,
+			ConfirmationTarget::ChannelFunding => 1000,
+			ConfirmationTarget::Lightning(ldk_target) => match ldk_target {
+				LdkConfirmationTarget::OnChainSweep => 5000,
+				LdkConfirmationTarget::MinAllowedAnchorChannelRemoteFee => {
+					FEERATE_FLOOR_SATS_PER_KW
+				},
+				LdkConfirmationTarget::MinAllowedNonAnchorChannelRemoteFee => {
+					FEERATE_FLOOR_SATS_PER_KW
+				},
+				LdkConfirmationTarget::AnchorChannelFee => 500,
+				LdkConfirmationTarget::NonAnchorChannelFee => 1000,
+				LdkConfirmationTarget::ChannelCloseMinimum => 500,
+				LdkConfirmationTarget::OutputSpendingFee => 1000,
+			},
 		};
 
 		// We'll fall back on this, if we really don't have any other information.
 		let fallback_rate = FeeRate::from_sat_per_kwu(fallback_sats_kwu as f32);
 
-		*locked_fee_rate_cache.get(&confirmation_target).unwrap_or(&fallback_rate)
+		let estimate = *locked_fee_rate_cache.get(&confirmation_target).unwrap_or(&fallback_rate);
+
+		// Currently we assume every transaction needs to at least be relayable, which is why we
+		// enforce a lower bound of `FEERATE_FLOOR_SATS_PER_KW`.
+		let weight_units = Weight::from_wu(1000);
+		FeeRate::from_wu(
+			estimate.fee_wu(weight_units).max(FEERATE_FLOOR_SATS_PER_KW as u64),
+			weight_units,
+		)
 	}
 }
 
-impl<L: Deref> FeeEstimator for OnchainFeeEstimator<L>
+impl<L: Deref> LdkFeeEstimator for OnchainFeeEstimator<L>
 where
 	L::Target: Logger,
 {
-	fn get_est_sat_per_1000_weight(&self, confirmation_target: ConfirmationTarget) -> u32 {
-		(self.estimate_fee_rate(confirmation_target).fee_wu(Weight::from_wu(1000)) as u32)
-			.max(FEERATE_FLOOR_SATS_PER_KW)
+	fn get_est_sat_per_1000_weight(&self, confirmation_target: LdkConfirmationTarget) -> u32 {
+		self.estimate_fee_rate(confirmation_target.into()).fee_wu(Weight::from_wu(1000)) as u32
 	}
 }

src/wallet.rs

@@ -1,9 +1,10 @@
 use crate::logger::{log_error, log_info, log_trace, Logger};
 
 use crate::config::BDK_WALLET_SYNC_TIMEOUT_SECS;
+use crate::fee_estimator::{ConfirmationTarget, FeeEstimator};
 use crate::Error;
 
-use lightning::chain::chaininterface::{BroadcasterInterface, ConfirmationTarget, FeeEstimator};
+use lightning::chain::chaininterface::BroadcasterInterface;
 
 use lightning::events::bump_transaction::{Utxo, WalletSource};
 use lightning::ln::msgs::{DecodeError, UnsignedGossipMessage};
@@ -18,8 +19,7 @@ use lightning::util::message_signing;
 use bdk::blockchain::EsploraBlockchain;
 use bdk::database::BatchDatabase;
 use bdk::wallet::AddressIndex;
-use bdk::{Balance, FeeRate};
-use bdk::{SignOptions, SyncOptions};
+use bdk::{Balance, SignOptions, SyncOptions};
 
 use bitcoin::address::{Payload, WitnessVersion};
 use bitcoin::bech32::u5;
@@ -153,9 +153,7 @@ where
 		&self, output_script: ScriptBuf, value_sats: u64, confirmation_target: ConfirmationTarget,
 		locktime: LockTime,
 	) -> Result<Transaction, Error> {
-		let fee_rate = FeeRate::from_sat_per_kwu(
-			self.fee_estimator.get_est_sat_per_1000_weight(confirmation_target) as f32,
-		);
+		let fee_rate = self.fee_estimator.estimate_fee_rate(confirmation_target);
 
 		let locked_wallet = self.inner.lock().unwrap();
 		let mut tx_builder = locked_wallet.build_tx();
@@ -240,10 +238,8 @@ where
 	pub(crate) fn send_to_address(
 		&self, address: &bitcoin::Address, amount_msat_or_drain: Option<u64>,
 	) -> Result<Txid, Error> {
-		let confirmation_target = ConfirmationTarget::OutputSpendingFee;
-		let fee_rate = FeeRate::from_sat_per_kwu(
-			self.fee_estimator.get_est_sat_per_1000_weight(confirmation_target) as f32,
-		);
+		let confirmation_target = ConfirmationTarget::OnchainPayment;
+		let fee_rate = self.fee_estimator.estimate_fee_rate(confirmation_target);
 
 		let tx = {
 			let locked_wallet = self.inner.lock().unwrap();