Consider funding scopes in get_available_balances

A FundedChannel may have more than one pending FundingScope during
splicing, one for the splice attempt and one or more for any RBF
attempts. When calling get_available_balances, consider all funding
scopes and take the minimum by next_outbound_htlc_limit_msat. This is
used both informationally and to determine which channel to use to
forward an HTLC.

The choice of next_outbound_htlc_limit_msat is somewhat arbitrary but
matches the field used when determining which channel used to forward an
HTLC. Any field should do since each field should be adjusted by the
same amount relative to another FundingScope given the nature of the
fields (i.e., inbound/outbound capacity, min/max HTLC limit).

Using the minimum was chosen since an order for an HTLC to be sent over
the channel, it must be possible for each funding scope -- both the
confirmed one and any pending scopes, one of which may eventually
confirm.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1248,6 +1248,16 @@ impl<SP: Deref> Channel<SP> where
 		}
 	}
 
+	pub fn pending_funding(&self) -> &[FundingScope] {
+		match &self.phase {
+			ChannelPhase::Undefined => unreachable!(),
+			ChannelPhase::Funded(chan) => &chan.pending_funding,
+			ChannelPhase::UnfundedOutboundV1(_) => &[],
+			ChannelPhase::UnfundedInboundV1(_) => &[],
+			ChannelPhase::UnfundedV2(_) => &[],
+		}
+	}
+
 	pub fn unfunded_context_mut(&mut self) -> Option<&mut UnfundedChannelContext> {
 		match &mut self.phase {
 			ChannelPhase::Undefined => unreachable!(),
@@ -4128,6 +4138,27 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 	/// if-we-removed-it-already-but-haven't-fully-resolved-they-can-still-send-an-inbound-HTLC
 	/// corner case properly.
 	pub fn get_available_balances<F: Deref>(
+		&self, funding: &FundingScope, pending_funding: &[FundingScope],
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
+	) -> AvailableBalances
+	where
+		F::Target: FeeEstimator,
+	{
+		core::iter::once(funding)
+			.chain(pending_funding.iter())
+			.map(|funding| self.get_available_balances_for_scope(funding, fee_estimator))
+			.reduce(|acc, e| {
+				AvailableBalances {
+					inbound_capacity_msat: acc.inbound_capacity_msat.min(e.inbound_capacity_msat),
+					outbound_capacity_msat: acc.outbound_capacity_msat.min(e.outbound_capacity_msat),
+					next_outbound_htlc_limit_msat: acc.next_outbound_htlc_limit_msat.min(e.next_outbound_htlc_limit_msat),
+					next_outbound_htlc_minimum_msat: acc.next_outbound_htlc_minimum_msat.max(e.next_outbound_htlc_minimum_msat),
+				}
+			})
+			.expect("At least one FundingScope is always provided")
+	}
+
+	fn get_available_balances_for_scope<F: Deref>(
 		&self, funding: &FundingScope, fee_estimator: &LowerBoundedFeeEstimator<F>,
 	) -> AvailableBalances
 	where
@@ -4918,7 +4949,7 @@ pub(super) struct DualFundingChannelContext {
 // Counterparty designates channel data owned by the another channel participant entity.
 pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 	pub funding: FundingScope,
-	pending_funding: Vec<FundingScope>,
+	pub(super) pending_funding: Vec<FundingScope>,
 	pub context: ChannelContext<SP>,
 	pub interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
 	holder_commitment_point: HolderCommitmentPoint,
@@ -8711,7 +8742,7 @@ impl<SP: Deref> FundedChannel<SP> where
 			return Err(ChannelError::Ignore("Cannot send 0-msat HTLC".to_owned()));
 		}
 
-		let available_balances = self.context.get_available_balances(&self.funding, fee_estimator);
+		let available_balances = self.get_available_balances(fee_estimator);
 		if amount_msat < available_balances.next_outbound_htlc_minimum_msat {
 			return Err(ChannelError::Ignore(format!("Cannot send less than our next-HTLC minimum - {} msat",
 				available_balances.next_outbound_htlc_minimum_msat)));
@@ -8783,6 +8814,15 @@ impl<SP: Deref> FundedChannel<SP> where
 		Ok(Some(res))
 	}
 
+	pub fn get_available_balances<F: Deref>(
+		&self, fee_estimator: &LowerBoundedFeeEstimator<F>,
+	) -> AvailableBalances
+	where
+		F::Target: FeeEstimator,
+	{
+		self.context.get_available_balances(&self.funding, &self.pending_funding, fee_estimator)
+	}
+
 	fn build_commitment_no_status_check<L: Deref>(&mut self, logger: &L) -> ChannelMonitorUpdate where L::Target: Logger {
 		log_trace!(logger, "Updating HTLC state for a newly-sent commitment_signed...");
 		// We can upgrade the status of some HTLCs that are waiting on a commitment, even if we

lightning/src/ln/channel_state.rs

@@ -476,14 +476,15 @@ impl ChannelDetails {
 	}
 
 	pub(super) fn from_channel_context<SP: Deref, F: Deref>(
-		context: &ChannelContext<SP>, funding: &FundingScope, best_block_height: u32,
-		latest_features: InitFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,
+		context: &ChannelContext<SP>, funding: &FundingScope, pending_funding: &[FundingScope],
+		best_block_height: u32, latest_features: InitFeatures,
+		fee_estimator: &LowerBoundedFeeEstimator<F>,
 	) -> Self
 	where
 		SP::Target: SignerProvider,
 		F::Target: FeeEstimator,
 	{
-		let balance = context.get_available_balances(funding, fee_estimator);
+		let balance = context.get_available_balances(funding, pending_funding, fee_estimator);
 		let (to_remote_reserve_satoshis, to_self_reserve_satoshis) =
 			funding.get_holder_counterparty_selected_channel_reserve_satoshis();
 		#[allow(deprecated)] // TODO: Remove once balance_msat is removed.

lightning/src/ln/channelmanager.rs

@@ -3744,8 +3744,11 @@ where
 					.filter_map(|(chan_id, chan)| chan.as_funded().map(|chan| (chan_id, chan)))
 					.filter(f)
 					.map(|(_channel_id, channel)| {
-						ChannelDetails::from_channel_context(&channel.context, &channel.funding, best_block_height,
-							peer_state.latest_features.clone(), &self.fee_estimator)
+						ChannelDetails::from_channel_context(
+							&channel.context, &channel.funding, &channel.pending_funding,
+							best_block_height, peer_state.latest_features.clone(),
+							&self.fee_estimator,
+						)
 					})
 				);
 			}
@@ -3768,9 +3771,13 @@ where
 			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 (context, funding) in peer_state.channel_by_id.iter().map(|(_, chan)| (chan.context(), chan.funding())) {
-					let details = ChannelDetails::from_channel_context(context, funding, best_block_height,
-						peer_state.latest_features.clone(), &self.fee_estimator);
+				for (context, funding, pending_funding) in peer_state.channel_by_id.iter()
+					.map(|(_, chan)| (chan.context(), chan.funding(), chan.pending_funding()))
+				{
+					let details = ChannelDetails::from_channel_context(
+						context, funding, pending_funding, best_block_height,
+						peer_state.latest_features.clone(), &self.fee_estimator,
+					);
 					res.push(details);
 				}
 			}
@@ -3800,12 +3807,15 @@ where
 			let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 			let peer_state = &mut *peer_state_lock;
 			let features = &peer_state.latest_features;
-			let context_to_details = |(context, funding)| {
-				ChannelDetails::from_channel_context(context, funding, best_block_height, features.clone(), &self.fee_estimator)
+			let context_to_details = |(context, funding, pending_funding)| {
+				ChannelDetails::from_channel_context(
+					context, funding, pending_funding, best_block_height, features.clone(),
+					&self.fee_estimator,
+				)
 			};
 			return peer_state.channel_by_id
 				.iter()
-				.map(|(_, chan)| (chan.context(), chan.funding()))
+				.map(|(_, chan)| (chan.context(), chan.funding(), chan.pending_funding()))
 				.map(context_to_details)
 				.collect();
 		}
@@ -6087,7 +6097,7 @@ where
 								let maybe_optimal_channel = peer_state.channel_by_id.values_mut()
 									.filter_map(Channel::as_funded_mut)
 									.filter_map(|chan| {
-										let balances = chan.context.get_available_balances(&chan.funding, &self.fee_estimator);
+										let balances = chan.get_available_balances(&self.fee_estimator);
 										if outgoing_amt_msat <= balances.next_outbound_htlc_limit_msat &&
 											outgoing_amt_msat >= balances.next_outbound_htlc_minimum_msat &&
 											chan.context.is_usable() {