ln/refactor: add utility to get commitment feerate by channel type

Author: carlaKC

lightning/src/ln/chan_utils.rs

@@ -25,7 +25,9 @@ use bitcoin::hashes::ripemd160::Hash as Ripemd160;
 use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::{Hash, HashEngine};
 
-use crate::chain::chaininterface::fee_for_weight;
+use crate::chain::chaininterface::{
+	fee_for_weight, ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator,
+};
 use crate::chain::package::WEIGHT_REVOKED_OUTPUT;
 use crate::ln::msgs::DecodeError;
 use crate::sign::EntropySource;
@@ -244,6 +246,22 @@ pub(crate) fn htlc_tx_fees_sat(feerate_per_kw: u32, num_accepted_htlcs: usize, n
 	htlc_tx_fees_sat
 }
 
+/// Returns a fee estimate for the commitment transaction depending on channel type.
+pub(super) fn commitment_sat_per_1000_weight_for_type<F: Deref>(
+	fee_estimator: &LowerBoundedFeeEstimator<F>, channel_type: &ChannelTypeFeatures,
+) -> u32
+where
+	F::Target: FeeEstimator,
+{
+	if channel_type.supports_anchor_zero_fee_commitments() {
+		0
+	} else if channel_type.supports_anchors_zero_fee_htlc_tx() {
+		fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::AnchorChannelFee)
+	} else {
+		fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee)
+	}
+}
+
 // Various functions for key derivation and transaction creation for use within channels. Primarily
 // used in Channel and ChannelMonitor.
 

lightning/src/ln/channel.rs

@@ -41,10 +41,11 @@ use crate::ln::chan_utils;
 #[cfg(splicing)]
 use crate::ln::chan_utils::FUNDING_TRANSACTION_WITNESS_WEIGHT;
 use crate::ln::chan_utils::{
-	get_commitment_transaction_number_obscure_factor, htlc_success_tx_weight,
-	htlc_timeout_tx_weight, max_htlcs, ChannelPublicKeys, ChannelTransactionParameters,
-	ClosingTransaction, CommitmentTransaction, CounterpartyChannelTransactionParameters,
-	CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HolderCommitmentTransaction,
+	commitment_sat_per_1000_weight_for_type, get_commitment_transaction_number_obscure_factor,
+	htlc_success_tx_weight, htlc_timeout_tx_weight, max_htlcs, ChannelPublicKeys,
+	ChannelTransactionParameters, ClosingTransaction, CommitmentTransaction,
+	CounterpartyChannelTransactionParameters, CounterpartyCommitmentSecrets,
+	HTLCOutputInCommitment, HolderCommitmentTransaction,
 };
 use crate::ln::channel_state::{
 	ChannelShutdownState, CounterpartyForwardingInfo, InboundHTLCDetails, InboundHTLCStateDetails,
@@ -3398,16 +3399,7 @@ where
 		debug_assert!(!channel_type.supports_any_optional_bits());
 		debug_assert!(!channel_type.requires_unknown_bits_from(&channelmanager::provided_channel_type_features(&config)));
 
-		let commitment_feerate = if channel_type.supports_anchor_zero_fee_commitments() {
-			0
-		} else {
-			let commitment_conf_target = if channel_type.supports_anchors_zero_fee_htlc_tx() {
-				ConfirmationTarget::AnchorChannelFee
-			} else {
-				ConfirmationTarget::NonAnchorChannelFee
-			};
-			fee_estimator.bounded_sat_per_1000_weight(commitment_conf_target)
-		};
+		let commitment_feerate = commitment_sat_per_1000_weight_for_type(&fee_estimator, &channel_type);
 
 		let value_to_self_msat = channel_value_satoshis * 1000 - push_msat;
 		let commit_tx_fee_sat = SpecTxBuilder {}.commit_tx_fee_sat(commitment_feerate, MIN_AFFORDABLE_HTLC_COUNT, &channel_type);
@@ -5449,20 +5441,7 @@ where
 
 		let next_channel_type = get_initial_channel_type(user_config, &eligible_features);
 
-		// Note that we can't get `anchor_zero_fee_commitments` type here, which requires zero
-		// fees, because we downgrade from this channel type first. If there were a superior
-		// channel type that downgrades to `anchor_zero_fee_commitments`, we'd need to handle
-		// fee setting differently here. If we proceeded to open a `anchor_zero_fee_commitments`
-		// channel with non-zero fees, we could produce a non-standard commitment transaction that
-		// puts us at risk of losing funds. We would expect our peer to reject such a channel
-		// open, but we don't want to rely on their validation.
-		assert!(!next_channel_type.supports_anchor_zero_fee_commitments());
-		let conf_target = if next_channel_type.supports_anchors_zero_fee_htlc_tx() {
-			ConfirmationTarget::AnchorChannelFee
-		} else {
-			ConfirmationTarget::NonAnchorChannelFee
-		};
-		self.feerate_per_kw = fee_estimator.bounded_sat_per_1000_weight(conf_target);
+		self.feerate_per_kw = commitment_sat_per_1000_weight_for_type(&fee_estimator, &next_channel_type);
 	 	funding.channel_transaction_parameters.channel_type_features = next_channel_type;
 
 		Ok(())

lightning/src/ln/channelmanager.rs

@@ -56,6 +56,7 @@ use crate::events::{
 	InboundChannelFunds, PaymentFailureReason, ReplayEvent,
 };
 use crate::events::{FundingInfo, PaidBolt12Invoice};
+use crate::ln::chan_utils::commitment_sat_per_1000_weight_for_type;
 // Since this struct is returned in `list_channels` methods, expose it here in case users want to
 // construct one themselves.
 use crate::ln::channel::PendingV2Channel;
@@ -7216,22 +7217,14 @@ where
 		PersistenceNotifierGuard::optionally_notify(self, || {
 			let mut should_persist = NotifyOption::SkipPersistNoEvents;
 
-			let non_anchor_feerate = self.fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
-			let anchor_feerate = self.fee_estimator.bounded_sat_per_1000_weight(ConfirmationTarget::AnchorChannelFee);
-
 			let per_peer_state = self.per_peer_state.read().unwrap();
 			for (_cp_id, peer_state_mutex) in per_peer_state.iter() {
 				let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 				let peer_state = &mut *peer_state_lock;
 				for (chan_id, chan) in peer_state.channel_by_id.iter_mut()
 					.filter_map(|(chan_id, chan)| chan.as_funded_mut().map(|chan| (chan_id, chan)))
 				{
-					let is_anchors_chan = chan.funding.get_channel_type().supports_anchors_zero_fee_htlc_tx();
-					let new_feerate = if is_anchors_chan {
-						anchor_feerate
-					} else {
-						non_anchor_feerate
-					};
+					let new_feerate = commitment_sat_per_1000_weight_for_type(&self.fee_estimator, chan.funding.get_channel_type());
 					let chan_needs_persist = self.update_channel_fee(chan_id, chan, new_feerate);
 					if chan_needs_persist == NotifyOption::DoPersist { should_persist = NotifyOption::DoPersist; }
 				}
@@ -7266,13 +7259,6 @@ where
 		PersistenceNotifierGuard::optionally_notify(self, || {
 			let mut should_persist = NotifyOption::SkipPersistNoEvents;
 
-			let non_anchor_feerate = self
-				.fee_estimator
-				.bounded_sat_per_1000_weight(ConfirmationTarget::NonAnchorChannelFee);
-			let anchor_feerate = self
-				.fee_estimator
-				.bounded_sat_per_1000_weight(ConfirmationTarget::AnchorChannelFee);
-
 			let mut handle_errors: Vec<(Result<(), _>, _)> = Vec::new();
 			let mut timed_out_mpp_htlcs = Vec::new();
 			let mut pending_peers_awaiting_removal = Vec::new();
@@ -7287,11 +7273,7 @@ where
 					peer_state.channel_by_id.retain(|chan_id, chan| {
 						match chan.as_funded_mut() {
 							Some(funded_chan) => {
-								let new_feerate = if funded_chan.funding.get_channel_type().supports_anchors_zero_fee_htlc_tx() {
-									anchor_feerate
-								} else {
-									non_anchor_feerate
-								};
+								let new_feerate = commitment_sat_per_1000_weight_for_type(&self.fee_estimator, funded_chan.funding.get_channel_type());
 								let chan_needs_persist = self.update_channel_fee(chan_id, funded_chan, new_feerate);
 								if chan_needs_persist == NotifyOption::DoPersist { should_persist = NotifyOption::DoPersist; }