Contribute to splice as acceptor

When both nodes want to splice simultaneously, the quiescence
tie-breaker designates one as the initiator. Previously, the losing
node responded with zero contribution, requiring a second full splice
session after the first splice locked. This is wasteful, especially for
often-offline nodes that may connect and immediately want to splice.

Instead, the losing node contributes to the winner's splice as the
acceptor, merging both contributions into a single splice transaction.
Since the FundingContribution was originally built with initiator fees
(which include common fields and shared input/output weight), the fee is
adjusted to the acceptor rate before contributing, with the surplus
returned to the change output.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jkczyz

lightning/src/ln/channel.rs

@@ -11851,6 +11851,26 @@ where
 		self.propose_quiescence(logger, QuiescentAction::Splice { contribution, locktime })
 	}
 
+	/// Returns a reference to the funding contribution queued by a pending [`QuiescentAction`],
+	/// if any.
+	fn queued_funding_contribution(&self) -> Option<&FundingContribution> {
+		match &self.quiescent_action {
+			Some(QuiescentAction::Splice { contribution, .. }) => Some(contribution),
+			_ => None,
+		}
+	}
+
+	/// Consumes and returns the funding contribution from the pending [`QuiescentAction`], if any.
+	fn take_queued_funding_contribution(&mut self) -> Option<FundingContribution> {
+		match &self.quiescent_action {
+			Some(QuiescentAction::Splice { .. }) => match self.quiescent_action.take() {
+				Some(QuiescentAction::Splice { contribution, .. }) => Some(contribution),
+				_ => unreachable!(),
+			},
+			_ => None,
+		}
+	}
+
 	fn send_splice_init(&mut self, context: FundingNegotiationContext) -> msgs::SpliceInit {
 		debug_assert!(self.pending_splice.is_none());
 		// Rotate the funding pubkey using the prev_funding_txid as a tweak
@@ -11948,10 +11968,6 @@ where
 			));
 		}
 
-		// TODO(splicing): Once splice acceptor can contribute, check that inputs are sufficient,
-		// similarly to the check in `funding_contributed`.
-		debug_assert_eq!(our_funding_contribution, SignedAmount::ZERO);
-
 		let their_funding_contribution = SignedAmount::from_sat(msg.funding_contribution_satoshis);
 		if their_funding_contribution == SignedAmount::ZERO {
 			return Err(ChannelError::WarnAndDisconnect(format!(
@@ -12075,11 +12091,52 @@ where
 	}
 
 	pub(crate) fn splice_init<ES: EntropySource, L: Logger>(
-		&mut self, msg: &msgs::SpliceInit, our_funding_contribution_satoshis: i64,
-		entropy_source: &ES, holder_node_id: &PublicKey, logger: &L,
+		&mut self, msg: &msgs::SpliceInit, entropy_source: &ES, holder_node_id: &PublicKey,
+		logger: &L,
 	) -> Result<msgs::SpliceAck, ChannelError> {
-		let our_funding_contribution = SignedAmount::from_sat(our_funding_contribution_satoshis);
-		let splice_funding = self.validate_splice_init(msg, our_funding_contribution)?;
+		let feerate = FeeRate::from_sat_per_kwu(msg.funding_feerate_per_kw as u64);
+		let holder_balance = self
+			.get_holder_counterparty_balances_floor_incl_fee(&self.funding)
+			.map(|(holder, _)| holder)
+			.map_err(|e| {
+				log_info!(
+					logger,
+					"Cannot compute holder balance for channel {}: {}; \
+						 proceeding without contribution",
+					self.context.channel_id(),
+					e,
+				);
+			})
+			.ok();
+		let our_funding_contribution =
+			holder_balance.and_then(|_| self.queued_funding_contribution()).and_then(|c| {
+				c.net_value_for_acceptor_at_feerate(feerate, holder_balance.unwrap())
+					.map_err(|e| {
+						log_info!(
+							logger,
+							"Cannot accommodate initiator's feerate ({}) for channel {}: {}; \
+								 proceeding without contribution",
+							feerate,
+							self.context.channel_id(),
+							e,
+						);
+					})
+					.ok()
+			});
+
+		let splice_funding =
+			self.validate_splice_init(msg, our_funding_contribution.unwrap_or(SignedAmount::ZERO))?;
+
+		let (our_funding_inputs, our_funding_outputs) = if our_funding_contribution.is_some() {
+			self.take_queued_funding_contribution()
+				.expect("queued_funding_contribution was Some")
+				.for_acceptor_at_feerate(feerate, holder_balance.unwrap())
+				.expect("feerate compatibility already checked")
+				.into_tx_parts()
+		} else {
+			Default::default()
+		};
+		let our_funding_contribution = our_funding_contribution.unwrap_or(SignedAmount::ZERO);
 
 		log_info!(
 			logger,
@@ -12096,8 +12153,8 @@ where
 			funding_tx_locktime: LockTime::from_consensus(msg.locktime),
 			funding_feerate_sat_per_1000_weight: msg.funding_feerate_per_kw,
 			shared_funding_input: Some(prev_funding_input),
-			our_funding_inputs: Vec::new(),
-			our_funding_outputs: Vec::new(),
+			our_funding_inputs,
+			our_funding_outputs,
 		};
 
 		let (interactive_tx_constructor, first_message) = funding_negotiation_context
@@ -12109,11 +12166,6 @@ where
 			);
 		debug_assert!(first_message.is_none());
 
-		// TODO(splicing): if quiescent_action is set, integrate what the user wants to do into the
-		// counterparty-initiated splice. For always-on nodes this probably isn't a useful
-		// optimization, but for often-offline nodes it may be, as we may connect and immediately
-		// go into splicing from both sides.
-
 		let new_funding_pubkey = splice_funding.get_holder_pubkeys().funding_pubkey;
 		self.pending_splice = Some(PendingFunding {
 			funding_negotiation: Some(FundingNegotiation::ConstructingTransaction {

lightning/src/ln/channelmanager.rs

@@ -4643,11 +4643,21 @@ impl<
 	///
 	/// The splice initiator is responsible for paying fees for common fields, shared inputs, and
 	/// shared outputs along with any contributed inputs and outputs. When building a
-	/// [`FundingContribution`], fees are estimated using `min_feerate` and must be covered by the
-	/// supplied inputs for splice-in or the channel balance for splice-out. If the counterparty
-	/// also initiates a splice and wins the tie-break, they become the initiator and choose the
-	/// feerate. In that case, `max_feerate` is used to reject a feerate that is too high for our
-	/// contribution.
+	/// [`FundingContribution`], fees are estimated at `min_feerate` assuming initiator
+	/// responsibility and must be covered by the supplied inputs for splice-in or the channel
+	/// balance for splice-out. If the counterparty also initiates a splice and wins the
+	/// tie-break, they become the initiator and choose the feerate. The fee is then
+	/// re-estimated at the counterparty's feerate for only our contributed inputs and outputs,
+	/// which may be higher or lower than the original estimate. The contribution is dropped and
+	/// the splice proceeds without it when:
+	/// - the counterparty's feerate is below `min_feerate`
+	/// - the counterparty's feerate is above `max_feerate` and the re-estimated fee exceeds the
+	///   original fee estimate
+	/// - the re-estimated fee exceeds the *fee buffer* regardless of `max_feerate`
+	///
+	/// The fee buffer is the maximum fee that can be accommodated:
+	/// - **splice-in**: the selected inputs' value minus the contributed amount
+	/// - **splice-out**: the channel balance minus the withdrawal outputs
 	///
 	/// Returns a [`FundingTemplate`] which should be used to build a [`FundingContribution`] via
 	/// one of its splice methods (e.g., [`FundingTemplate::splice_in_sync`]). The resulting
@@ -12826,9 +12836,6 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 		let peer_state = &mut *peer_state_lock;
 
-		// TODO(splicing): Currently not possible to contribute on the splicing-acceptor side
-		let our_funding_contribution = 0i64;
-
 		// Look for the channel
 		match peer_state.channel_by_id.entry(msg.channel_id) {
 			hash_map::Entry::Vacant(_) => {
@@ -12848,7 +12855,6 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				if let Some(ref mut funded_channel) = chan_entry.get_mut().as_funded_mut() {
 					let init_res = funded_channel.splice_init(
 						msg,
-						our_funding_contribution,
 						&self.entropy_source,
 						&self.get_our_node_id(),
 						&self.logger,