Add ChannelContext::get_next_{local, remote}_commitment_stats

In upcoming commits, these methods will serve as proxies to
`SpecTxBuilder::get_next_commitment_stats` in all validation of channel
updates in `ChannelContext`.

Eventually, these methods will completely replace
`get_pending_htlc_stats`, and `get_next_
{local, remote}_commit_tx_fee_msat`.

When predicting the HTLCs on next commitment, we take the conservative
approach and only assume that a HTLC will not be in the next commitment
when it is guaranteed that it won't be.

While we previously took into account HTLCs in the holding cell when
validating channel updates, we now choose to ignore them; our
counterparty certainly does not know about them, and we will re-validate
their addition to the channel upon freeing the holding cell.

Author: tankyleo

lightning/src/ln/channel.rs

@@ -70,7 +70,7 @@ use crate::ln::script::{self, ShutdownScript};
 use crate::ln::types::ChannelId;
 use crate::routing::gossip::NodeId;
 use crate::sign::ecdsa::EcdsaChannelSigner;
-use crate::sign::tx_builder::{SpecTxBuilder, TxBuilder};
+use crate::sign::tx_builder::{HTLCAmountDirection, NextCommitmentStats, SpecTxBuilder, TxBuilder};
 use crate::sign::{ChannelSigner, EntropySource, NodeSigner, Recipient, SignerProvider};
 use crate::types::features::{ChannelTypeFeatures, InitFeatures};
 use crate::types::payment::{PaymentHash, PaymentPreimage};
@@ -4104,6 +4104,162 @@ where
 		);
 	}
 
+	#[allow(dead_code)]
+	fn pending_inbound_htlcs_value_msat(&self) -> u64 {
+		self.pending_inbound_htlcs.iter().map(|htlc| htlc.amount_msat).sum()
+	}
+
+	/// Returns a best-effort guess of the set of HTLCs that will be present
+	/// on the next local or remote commitment. We cannot be certain as the
+	/// actual set of HTLCs present on the next commitment depends on the
+	/// ordering of commitment_signed and revoke_and_ack messages.
+	///
+	/// We take the conservative approach and only assume that a HTLC will
+	/// not be in the next commitment when it is guaranteed that it won't be.
+	///
+	/// While we previously took into account HTLCs in the holding cell when
+	/// validating channel updates, we now choose to ignore them; our
+	/// counterparty certainly does not know about them, and we will re-validate
+	/// their addition to the channel upon freeing the holding cell, failing
+	/// them backwards if necessary.
+	#[allow(dead_code)]
+	#[rustfmt::skip]
+	fn get_next_commitment_htlcs(
+		&self, local: bool, htlc_candidate: Option<HTLCAmountDirection>,
+	) -> Vec<HTLCAmountDirection> {
+		let mut commitment_htlcs = Vec::with_capacity(
+			1 + self.pending_inbound_htlcs.len()
+				+ self.pending_outbound_htlcs.len()
+				+ self.holding_cell_htlc_updates.len(),
+		);
+		// `LocalRemoved` HTLCs will certainly not be present on any future remote
+		// commitments, but they could be in a future local commitment as the remote has
+		// not yet acknowledged the removal.
+		let pending_inbound_htlcs = self
+			.pending_inbound_htlcs
+			.iter()
+			.filter(|InboundHTLCOutput { state, .. }| match (state, local) {
+				(InboundHTLCState::RemoteAnnounced(..), _) => true,
+				(InboundHTLCState::AwaitingRemoteRevokeToAnnounce(..), _) => true,
+				(InboundHTLCState::AwaitingAnnouncedRemoteRevoke(..), _) => true,
+				(InboundHTLCState::Committed, _) => true,
+				(InboundHTLCState::LocalRemoved(..), true) => true,
+				(InboundHTLCState::LocalRemoved(..), false) => false,
+			})
+			.map(|&InboundHTLCOutput { amount_msat, .. }| HTLCAmountDirection { outbound: false, amount_msat });
+		// While `LocalAnnounced` HTLCs will for sure be present on the next remote commitment, it is
+		// also possible for `LocalAnnounced` HTLCs to be present on the next local commitment if the
+		// remote acks the update before producing the next local commitment.
+		//
+		// `RemoteRemoved` HTLCs can still be present on the next remote commitment if
+		// local produces a commitment before acknowledging the update. These HTLCs
+		// will for sure not be present on the next local commitment.
+		let pending_outbound_htlcs = self
+			.pending_outbound_htlcs
+			.iter()
+			.filter(|OutboundHTLCOutput { state, .. }| match (state, local) {
+				(OutboundHTLCState::LocalAnnounced(..), _) => true,
+				(OutboundHTLCState::Committed, _) => true,
+				(OutboundHTLCState::RemoteRemoved(..), true) => false,
+				(OutboundHTLCState::RemoteRemoved(..), false) => true,
+				(OutboundHTLCState::AwaitingRemoteRevokeToRemove(..), _) => false,
+				(OutboundHTLCState::AwaitingRemovedRemoteRevoke(..), _) => false,
+			})
+			.map(|&OutboundHTLCOutput { amount_msat, .. }| HTLCAmountDirection { outbound: true, amount_msat });
+
+		// We do not include holding cell HTLCs, we will validate them upon freeing the holding cell...
+		//let holding_cell_htlcs = self.holding_cell_htlc_updates.iter().filter_map(|htlc| if let HTLCUpdateAwaitingACK::AddHTLC { amount_msat, ..} = htlc { Some(HTLCAmountDirection { outbound: true, amount_msat: *amount_msat }) } else { None });
+
+		commitment_htlcs.extend(
+			htlc_candidate.into_iter().chain(pending_inbound_htlcs).chain(pending_outbound_htlcs),
+		);
+		commitment_htlcs
+	}
+
+	/// This returns the value of `value_to_self_msat` after accounting for all the
+	/// successful inbound and outbound HTLCs that won't be present on the next
+	/// commitment.
+	///
+	/// To determine which HTLC claims to account for, we take the cases where a HTLC
+	/// will *not* be present on the next commitment from `next_commitment_htlcs`, and
+	/// check if their outcome is successful. If it is, we add the value of this claimed
+	/// HTLC to the balance of the claimer.
+	#[allow(dead_code)]
+	#[rustfmt::skip]
+	fn get_next_commitment_value_to_self_msat(&self, local: bool, funding: &FundingScope) -> u64 {
+		let inbound_claimed_htlc_msat: u64 =
+			self.pending_inbound_htlcs
+				.iter()
+				.filter(|InboundHTLCOutput { state, .. }| match (state, local) {
+					(InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_, _)), true) => false,
+					(InboundHTLCState::LocalRemoved(InboundHTLCRemovalReason::Fulfill(_, _)), false) => true,
+					_ => false,
+				})
+				.map(|InboundHTLCOutput { amount_msat, .. }| amount_msat)
+				.sum();
+		let outbound_claimed_htlc_msat: u64 =
+			self.pending_outbound_htlcs
+				.iter()
+				.filter(|OutboundHTLCOutput { state, .. }| match (state, local) {
+					(OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(_, _)), true) => true,
+					(OutboundHTLCState::RemoteRemoved(OutboundHTLCOutcome::Success(_, _)), false) => false,
+					(OutboundHTLCState::AwaitingRemoteRevokeToRemove(OutboundHTLCOutcome::Success(_, _)), _) => true,
+					(OutboundHTLCState::AwaitingRemovedRemoteRevoke(OutboundHTLCOutcome::Success(_, _)), _) => true,
+					_ => false,
+				})
+				.map(|OutboundHTLCOutput { amount_msat, .. }| amount_msat)
+				.sum();
+
+		funding
+			.value_to_self_msat
+			.saturating_sub(outbound_claimed_htlc_msat)
+			.saturating_add(inbound_claimed_htlc_msat)
+	}
+
+	#[allow(dead_code)]
+	fn get_next_local_commitment_stats(
+		&self, funding: &FundingScope, candidate_htlc: Option<HTLCAmountDirection>,
+		addl_nondust_htlc_count: usize, feerate_per_kw: u32,
+		dust_exposure_limiting_feerate: Option<u32>,
+	) -> NextCommitmentStats {
+		let next_commitment_htlcs = self.get_next_commitment_htlcs(true, candidate_htlc);
+		let next_value_to_self_msat = self.get_next_commitment_value_to_self_msat(true, funding);
+		SpecTxBuilder {}.get_next_commitment_stats(
+			true,
+			funding.is_outbound(),
+			funding.get_value_satoshis(),
+			next_value_to_self_msat,
+			next_commitment_htlcs,
+			addl_nondust_htlc_count,
+			feerate_per_kw,
+			dust_exposure_limiting_feerate,
+			self.holder_dust_limit_satoshis,
+			funding.get_channel_type(),
+		)
+	}
+
+	#[allow(dead_code)]
+	fn get_next_remote_commitment_stats(
+		&self, funding: &FundingScope, candidate_htlc: Option<HTLCAmountDirection>,
+		addl_nondust_htlc_count: usize, feerate_per_kw: u32,
+		dust_exposure_limiting_feerate: Option<u32>,
+	) -> NextCommitmentStats {
+		let next_commitment_htlcs = self.get_next_commitment_htlcs(false, candidate_htlc);
+		let next_value_to_self_msat = self.get_next_commitment_value_to_self_msat(false, funding);
+		SpecTxBuilder {}.get_next_commitment_stats(
+			false,
+			funding.is_outbound(),
+			funding.get_value_satoshis(),
+			next_value_to_self_msat,
+			next_commitment_htlcs,
+			addl_nondust_htlc_count,
+			feerate_per_kw,
+			dust_exposure_limiting_feerate,
+			self.counterparty_dust_limit_satoshis,
+			funding.get_channel_type(),
+		)
+	}
+
 	#[rustfmt::skip]
 	fn validate_update_add_htlc<F: Deref>(
 		&self, funding: &FundingScope, msg: &msgs::UpdateAddHTLC,