Consider fees and anchor in balances when checking reserve requirements

Author: optout21

lightning/src/ln/channel.rs

@@ -5084,26 +5084,21 @@ where
 		pre_balance: u64, post_balance: u64, pre_channel_value: u64, post_channel_value: u64,
 		dust_limit: u64,
 	) -> Result<(), u64> {
-		if post_balance == 0 {
-			// 0 balance is fine
-			return Ok(());
-		}
 		let post_channel_reserve = get_v2_channel_reserve_satoshis(post_channel_value, dust_limit);
 		if post_balance >= post_channel_reserve {
 			return Ok(());
 		}
-		// post is not OK, check pre
-		if pre_balance == 0 {
-			// pre OK, post not -> not
-			return Err(post_channel_reserve);
-		}
 		let pre_channel_reserve = get_v2_channel_reserve_satoshis(pre_channel_value, dust_limit);
 		if pre_balance >= pre_channel_reserve {
-			// pre OK, post not -> not
+			// We're not allowed to dip below the reserve once we've been above.
 			return Err(post_channel_reserve);
 		}
-		// post not OK, but so was pre -> OK
-		Ok(())
+		// Make sure we either remain with the same balance or move towards the reserve.
+		if post_balance >= pre_balance {
+			Ok(())
+		} else {
+			Err(post_channel_reserve)
+		}
 	}
 
 	/// Check that balances meet the channel reserve requirements or violates them (below reserve).
@@ -10916,6 +10911,71 @@ where
 		})
 	}
 
+	/// Compute the channel balances (local & remote) by taking into account fees, anchor values, and dust limits.
+	/// Pending HTLCs are not taken into account, this method should be used when there is no such,
+	/// e.g. in quiscence state
+	#[cfg(splicing)]
+	fn compute_balances_less_fees(
+		&self, channel_value_sats: u64, value_to_self_msat: u64, is_local: bool,
+	) -> (u64, u64) {
+		// We should get here only when there are no pending HTLCs, as they are not taken into account
+		debug_assert!(self.context.pending_inbound_htlcs.is_empty());
+		debug_assert!(self.context.pending_outbound_htlcs.is_empty());
+
+		let feerate_per_kw = self.context.feerate_per_kw;
+
+		// compute 'raw' counterparty balance
+		let value_to_remote_msat: i64 =
+			((channel_value_sats * 1000) as i64).saturating_sub(value_to_self_msat as i64);
+		debug_assert!(value_to_remote_msat >= 0);
+
+		let total_fee_sat = SpecTxBuilder {}.commit_tx_fee_sat(
+			feerate_per_kw,
+			0,
+			&self.funding.channel_transaction_parameters.channel_type_features,
+		);
+		let anchors_val = if self
+			.funding
+			.channel_transaction_parameters
+			.channel_type_features
+			.supports_anchors_zero_fee_htlc_tx()
+		{
+			ANCHOR_OUTPUT_VALUE_SATOSHI * 2
+		} else {
+			0
+		} as i64;
+
+		// consider fees and anchor values
+		let (mut value_to_self, mut value_to_remote) = if self.funding.is_outbound() {
+			(
+				(value_to_self_msat as i64) / 1000 - anchors_val - total_fee_sat as i64,
+				value_to_remote_msat / 1000,
+			)
+		} else {
+			(
+				(value_to_self_msat as i64) / 1000,
+				value_to_remote_msat / 1000 - anchors_val - total_fee_sat as i64,
+			)
+		};
+
+		// consider dust limit
+		let broadcaster_dust_limit_satoshis = if is_local {
+			self.context.holder_dust_limit_satoshis
+		} else {
+			self.context.counterparty_dust_limit_satoshis
+		} as i64;
+		if value_to_self < broadcaster_dust_limit_satoshis {
+			value_to_self = 0;
+		}
+		debug_assert!(value_to_self >= 0);
+		if value_to_remote < broadcaster_dust_limit_satoshis {
+			value_to_remote = 0;
+		}
+		debug_assert!(value_to_remote >= 0);
+
+		(value_to_self as u64, value_to_remote as u64)
+	}
+
 	/// Handle splice_ack
 	#[cfg(splicing)]
 	pub(crate) fn splice_ack<ES: Deref, L: Deref>(
@@ -10926,35 +10986,37 @@ where
 		ES::Target: EntropySource,
 		L::Target: Logger,
 	{
-		let pending_splice = if let Some(ref mut pending_splice) = &mut self.pending_splice {
-			pending_splice
-		} else {
-			return Err(ChannelError::Ignore(format!("Channel is not in pending splice")));
-		};
+		let funding_negotiation_context = {
+			let pending_splice = if let Some(ref mut pending_splice) = &mut self.pending_splice {
+				pending_splice
+			} else {
+				return Err(ChannelError::Ignore(format!("Channel is not in pending splice")));
+			};
 
-		// TODO(splicing): Add check that we are the splice (quiescence) initiator
+			// TODO(splicing): Add check that we are the splice (quiescence) initiator
 
-		let funding_negotiation_context = match pending_splice.funding_negotiation.take() {
-			Some(FundingNegotiation::AwaitingAck(context)) => context,
-			Some(FundingNegotiation::ConstructingTransaction(funding, constructor)) => {
-				pending_splice.funding_negotiation =
-					Some(FundingNegotiation::ConstructingTransaction(funding, constructor));
-				return Err(ChannelError::WarnAndDisconnect(format!(
-					"Got unexpected splice_ack; splice negotiation already in progress"
-				)));
-			},
-			Some(FundingNegotiation::AwaitingSignatures(funding)) => {
-				pending_splice.funding_negotiation =
-					Some(FundingNegotiation::AwaitingSignatures(funding));
-				return Err(ChannelError::WarnAndDisconnect(format!(
-					"Got unexpected splice_ack; splice negotiation already in progress"
-				)));
-			},
-			None => {
-				return Err(ChannelError::Ignore(format!(
-					"Got unexpected splice_ack; no splice negotiation in progress"
-				)));
-			},
+			match pending_splice.funding_negotiation.take() {
+				Some(FundingNegotiation::AwaitingAck(context)) => context,
+				Some(FundingNegotiation::ConstructingTransaction(funding, constructor)) => {
+					pending_splice.funding_negotiation =
+						Some(FundingNegotiation::ConstructingTransaction(funding, constructor));
+					return Err(ChannelError::WarnAndDisconnect(format!(
+						"Got unexpected splice_ack; splice negotiation already in progress"
+					)));
+				},
+				Some(FundingNegotiation::AwaitingSignatures(funding)) => {
+					pending_splice.funding_negotiation =
+						Some(FundingNegotiation::AwaitingSignatures(funding));
+					return Err(ChannelError::WarnAndDisconnect(format!(
+						"Got unexpected splice_ack; splice negotiation already in progress"
+					)));
+				},
+				None => {
+					return Err(ChannelError::Ignore(format!(
+						"Got unexpected splice_ack; no splice negotiation in progress"
+					)));
+				},
+			}
 		};
 
 		let our_funding_contribution_satoshis =
@@ -10979,15 +11041,17 @@ where
 		let pre_balance_self = self.funding.value_to_self_msat;
 		let post_balance_self =
 			PendingSplice::add_checked(pre_balance_self, our_funding_contribution_satoshis);
-		let pre_balance_counterparty = pre_channel_value.saturating_sub(pre_balance_self);
-		let post_balance_counterparty = post_channel_value.saturating_sub(post_balance_self);
+		let (pre_balance_self_less_fees, pre_balance_counterparty_less_fees) =
+			self.compute_balances_less_fees(pre_channel_value, pre_balance_self, true);
+		let (post_balance_self_less_fees, post_balance_counterparty_less_fees) =
+			self.compute_balances_less_fees(post_channel_value, post_balance_self, true);
 		// Pre-check for reserve requirement
 		// This will also be checked later at tx_complete
 		let _res = self.context.check_splice_balances_meet_v2_reserve_requirements(
-			pre_balance_self,
-			post_balance_self,
-			pre_balance_counterparty,
-			post_balance_counterparty,
+			pre_balance_self_less_fees,
+			post_balance_self_less_fees,
+			pre_balance_counterparty_less_fees,
+			post_balance_counterparty_less_fees,
 			pre_channel_value,
 			post_channel_value,
 		)?;
@@ -11017,6 +11081,11 @@ where
 		let tx_msg_opt = interactive_tx_constructor.take_initiator_first_message();
 
 		debug_assert!(self.interactive_tx_signing_session.is_none());
+		let pending_splice = if let Some(ref mut pending_splice) = &mut self.pending_splice {
+			pending_splice
+		} else {
+			return Err(ChannelError::Ignore(format!("Channel is not in pending splice")));
+		};
 		pending_splice.funding_negotiation = Some(FundingNegotiation::ConstructingTransaction(
 			splice_funding,
 			interactive_tx_constructor,