Introduce NegotiatingChannelView to bridge Funded and PendingV2

optout21 · optout21 · commit d3c342ca677a · 2025-06-17T05:43:37.000+02:00
Introduce struct NegotiatingChannelView to perform transaction negotiation
logic, on top of either PendingV2Channel (dual-funded channel open) or
FundedChannel (splicing).
diff --git a/lightning/src/ln/channel.rs b/lightning/src/ln/channel.rs
@@ -1582,6 +1582,16 @@ impl<SP: Deref> Channel<SP> where
 		}
 	}
 
+	pub fn as_negotiating_channel(&mut self) -> Result<NegotiatingChannelView<SP>, ChannelError> {
+		match &mut self.phase {
+			ChannelPhase::UnfundedV2(chan) => Ok(chan.as_negotiating_channel()),
+			#[cfg(splicing)]
+			ChannelPhase::Funded(chan) => Ok(chan.as_renegotiating_channel()
+				.map_err(|err| ChannelError::Warn(err.into()))?),
+			_ => Err(ChannelError::Warn("Got a transaction negotiation message in an invalid phase".to_owned())),
+		}
+	}
+
 	pub fn funding_signed<L: Deref>(
 		&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
 	) -> Result<(&mut FundedChannel<SP>, ChannelMonitor<<SP::Target as SignerProvider>::EcdsaSigner>), ChannelError>
@@ -1619,9 +1629,10 @@ impl<SP: Deref> Channel<SP> where
 	where
 		L::Target: Logger
 	{
-		if let ChannelPhase::UnfundedV2(chan) = &mut self.phase {
-			let logger = WithChannelContext::from(logger, &chan.context, None);
-			chan.funding_tx_constructed(signing_session, &&logger)
+		let logger = WithChannelContext::from(logger, self.context(), None);
+		if let Ok(mut negotiating_channel) = self.as_negotiating_channel() {
+			let (commitment_signed, event) = negotiating_channel.funding_tx_constructed(signing_session, &&logger)?;
+			Ok((commitment_signed, event))
 		} else {
 			Err(ChannelError::Warn("Got a tx_complete message with no interactive transaction construction expected or in-progress".to_owned()))
 		}
@@ -1935,7 +1946,13 @@ impl FundingScope {
 /// Info about a pending splice, used in the pre-splice channel
 #[cfg(splicing)]
 struct PendingSplice {
+	/// Intended contributions to the splice from our end
 	pub our_funding_contribution: i64,
+	funding_scope: Option<FundingScope>,
+	funding_negotiation_context: FundingNegotiationContext,
+	/// The current interactive transaction construction session under negotiation.
+	interactive_tx_constructor: Option<InteractiveTxConstructor>,
+	interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
 }
 
 /// Contains everything about the channel including state, and various flags.
@@ -2432,7 +2449,20 @@ impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for FundedChannel<SP> where
 	}
 }
 
-impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
+/// A short-lived subset view of a channel, used for V2 funding negotiation or re-negotiation.
+/// Can be produced by:
+/// - [`PendingV2Channel`], at V2 channel open, and
+/// - [`FundedChannel`], when splicing.
+pub struct NegotiatingChannelView<'a, SP: Deref> where SP::Target: SignerProvider {
+	context: &'a mut ChannelContext<SP>,
+	funding: &'a mut FundingScope,
+	funding_negotiation_context: &'a mut FundingNegotiationContext,
+	interactive_tx_constructor: &'a mut Option<InteractiveTxConstructor>,
+	interactive_tx_signing_session: &'a mut Option<InteractiveTxSigningSession>,
+	holder_commitment_transaction_number: u64,
+}
+
+impl<'a, SP: Deref> NegotiatingChannelView<'a, SP> where SP::Target: SignerProvider {
 	/// Prepare and start interactive transaction negotiation.
 	/// `change_destination_opt` - Optional destination for optional change; if None,
 	///   default destination address is used.
@@ -2522,13 +2552,13 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		let mut tx_constructor = InteractiveTxConstructor::new(constructor_args)?;
 		let msg = tx_constructor.take_initiator_first_message();
 
-		self.interactive_tx_constructor = Some(tx_constructor);
+		*self.interactive_tx_constructor = Some(tx_constructor);
 
 		Ok(msg)
 	}
 
-	pub fn tx_add_input(&mut self, msg: &msgs::TxAddInput) -> InteractiveTxMessageSendResult {
-		InteractiveTxMessageSendResult(match &mut self.interactive_tx_constructor {
+	pub(super) fn tx_add_input(&mut self, msg: &msgs::TxAddInput) -> InteractiveTxMessageSendResult {
+		InteractiveTxMessageSendResult(match self.interactive_tx_constructor {
 			Some(ref mut tx_constructor) => tx_constructor.handle_tx_add_input(msg).map_err(
 				|reason| reason.into_tx_abort_msg(self.context.channel_id())),
 			None => Err(msgs::TxAbort {
@@ -2538,8 +2568,8 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		})
 	}
 
-	pub fn tx_add_output(&mut self, msg: &msgs::TxAddOutput)-> InteractiveTxMessageSendResult {
-		InteractiveTxMessageSendResult(match &mut self.interactive_tx_constructor {
+	pub(super) fn tx_add_output(&mut self, msg: &msgs::TxAddOutput)-> InteractiveTxMessageSendResult {
+		InteractiveTxMessageSendResult(match self.interactive_tx_constructor {
 			Some(ref mut tx_constructor) => tx_constructor.handle_tx_add_output(msg).map_err(
 				|reason| reason.into_tx_abort_msg(self.context.channel_id())),
 			None => Err(msgs::TxAbort {
@@ -2549,8 +2579,8 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		})
 	}
 
-	pub fn tx_remove_input(&mut self, msg: &msgs::TxRemoveInput)-> InteractiveTxMessageSendResult {
-		InteractiveTxMessageSendResult(match &mut self.interactive_tx_constructor {
+	pub(super) fn tx_remove_input(&mut self, msg: &msgs::TxRemoveInput)-> InteractiveTxMessageSendResult {
+		InteractiveTxMessageSendResult(match self.interactive_tx_constructor {
 			Some(ref mut tx_constructor) => tx_constructor.handle_tx_remove_input(msg).map_err(
 				|reason| reason.into_tx_abort_msg(self.context.channel_id())),
 			None => Err(msgs::TxAbort {
@@ -2560,8 +2590,8 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		})
 	}
 
-	pub fn tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput)-> InteractiveTxMessageSendResult {
-		InteractiveTxMessageSendResult(match &mut self.interactive_tx_constructor {
+	pub(super) fn tx_remove_output(&mut self, msg: &msgs::TxRemoveOutput)-> InteractiveTxMessageSendResult {
+		InteractiveTxMessageSendResult(match self.interactive_tx_constructor {
 			Some(ref mut tx_constructor) => tx_constructor.handle_tx_remove_output(msg).map_err(
 				|reason| reason.into_tx_abort_msg(self.context.channel_id())),
 			None => Err(msgs::TxAbort {
@@ -2571,9 +2601,9 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		})
 	}
 
-	pub fn tx_complete(&mut self, msg: &msgs::TxComplete) -> HandleTxCompleteResult {
-		let tx_constructor = match &mut self.interactive_tx_constructor {
-			Some(ref mut tx_constructor) => tx_constructor,
+	pub(super) fn tx_complete(&mut self, msg: &msgs::TxComplete) -> HandleTxCompleteResult {
+		let tx_constructor = match self.interactive_tx_constructor {
+			Some(tx_constructor) => tx_constructor,
 			None => {
 				let tx_abort = msgs::TxAbort {
 					channel_id: msg.channel_id,
@@ -2593,14 +2623,14 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		HandleTxCompleteResult(Ok(tx_complete))
 	}
 
-	pub fn funding_tx_constructed<L: Deref>(
+	fn funding_tx_constructed<L: Deref>(
 		&mut self, mut signing_session: InteractiveTxSigningSession, logger: &L
 	) -> Result<(msgs::CommitmentSigned, Option<Event>), ChannelError>
 	where
 		L::Target: Logger
 	{
-		let our_funding_satoshis = self.funding_negotiation_context.our_funding_satoshis;
-		let transaction_number = self.unfunded_context.transaction_number();
+		let our_funding_satoshis = self.funding_negotiation_context
+			.our_funding_satoshis;
 
 		let mut output_index = None;
 		let expected_spk = self.funding.get_funding_redeemscript().to_p2wsh();
@@ -2625,14 +2655,16 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 					ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) },
 				)));
 		};
-		self.funding.channel_transaction_parameters.funding_outpoint = Some(outpoint);
+		self.funding
+			.channel_transaction_parameters.funding_outpoint = Some(outpoint);
 
-		self.context.assert_no_commitment_advancement(transaction_number, "initial commitment_signed");
+		self.context.assert_no_commitment_advancement(self.holder_commitment_transaction_number, "initial commitment_signed");
 		let commitment_signed = self.context.get_initial_commitment_signed(&self.funding, logger);
 		let commitment_signed = match commitment_signed {
 			Ok(commitment_signed) => commitment_signed,
 			Err(err) => {
-				self.funding.channel_transaction_parameters.funding_outpoint = None;
+				self.funding
+					.channel_transaction_parameters.funding_outpoint = None;
 				return Err(ChannelError::Close((err.to_string(), ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) })));
 			},
 		};
@@ -2680,8 +2712,8 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 		self.context.channel_state = channel_state;
 
 		// Clear the interactive transaction constructor
-		self.interactive_tx_constructor.take();
-		self.interactive_tx_signing_session = Some(signing_session);
+		*self.interactive_tx_constructor = None;
+		*self.interactive_tx_signing_session = Some(signing_session);
 
 		Ok((commitment_signed, funding_ready_for_sig_event))
 	}
@@ -5262,6 +5294,36 @@ impl<SP: Deref> FundedChannel<SP> where
 	SP::Target: SignerProvider,
 	<SP::Target as SignerProvider>::EcdsaSigner: EcdsaChannelSigner
 {
+	/// If we are in splicing/refunding, return a short-lived [`NegotiatingChannelView`].
+	#[cfg(splicing)]
+	fn as_renegotiating_channel(&mut self) -> Result<NegotiatingChannelView<SP>, &'static str> {
+		if let Some(ref mut pending_splice) = &mut self.pending_splice {
+			if let Some(ref mut funding) = &mut pending_splice.funding_scope {
+				if
+					pending_splice.funding_negotiation_context.our_funding_satoshis != 0 ||
+					pending_splice.funding_negotiation_context.their_funding_satoshis.unwrap_or_default() != 0
+				{
+					Ok(NegotiatingChannelView {
+						context: &mut self.context,
+						funding,
+						funding_negotiation_context: &mut pending_splice.funding_negotiation_context,
+						interactive_tx_constructor: &mut pending_splice.interactive_tx_constructor,
+						interactive_tx_signing_session: &mut pending_splice.interactive_tx_signing_session,
+						holder_commitment_transaction_number: self.holder_commitment_point.transaction_number(),
+					})
+				} else {
+					Err("Received unexpected interactive transaction negotiation message: \
+						the channel is splicing, but splice_init/splice_ack has not been exchanged yet")
+				}
+			} else {
+				Err("Received unexpected interactive transaction negotiation message: \
+					the channel is splicing, but splice_init/splice_ack has not been exchanged yet")
+			}
+		} else {
+			Err("Received unexpected interactive transaction negotiation message: the channel is funded and not splicing")
+		}
+	}
+
 	fn check_remote_fee<F: Deref, L: Deref>(
 		channel_type: &ChannelTypeFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,
 		feerate_per_kw: u32, cur_feerate_per_kw: Option<u32>, logger: &L
@@ -8895,10 +8957,11 @@ impl<SP: Deref> FundedChannel<SP> where
 	) -> Result<msgs::SpliceInit, APIError> {
 		// Check if a splice has been initiated already.
 		// Note: only a single outstanding splice is supported (per spec)
-		if let Some(splice_info) = &self.pending_splice {
+		if let Some(pending_splice) = &self.pending_splice {
 			return Err(APIError::APIMisuseError { err: format!(
 				"Channel {} cannot be spliced, as it has already a splice pending (contribution {})",
-				self.context.channel_id(), splice_info.our_funding_contribution
+				self.context.channel_id(),
+				pending_splice.our_funding_contribution,
 			)});
 		}
 
@@ -8930,9 +8993,26 @@ impl<SP: Deref> FundedChannel<SP> where
 				"Insufficient inputs for splicing; channel ID {}, err {}",
 				self.context.channel_id(), err,
 			)})?;
+		// Convert inputs
+		let mut funding_inputs = Vec::new();
+		for (tx_in, tx, _w) in our_funding_inputs.into_iter() {
+			let tx16 = TransactionU16LenLimited::new(tx.clone()).map_err(|_e| APIError::APIMisuseError { err: format!("Too large transaction")})?;
+			funding_inputs.push((tx_in.clone(), tx16));
+		}
 
+		let funding_negotiation_context = FundingNegotiationContext {
+			our_funding_satoshis: 0, // set at later phase
+			their_funding_satoshis: None, // set at later phase
+			funding_tx_locktime: LockTime::from_consensus(locktime),
+			funding_feerate_sat_per_1000_weight: funding_feerate_per_kw,
+			our_funding_inputs: funding_inputs,
+		};
 		self.pending_splice = Some(PendingSplice {
 			our_funding_contribution: our_funding_contribution_satoshis,
+			funding_scope: None,
+			funding_negotiation_context,
+			interactive_tx_constructor: None,
+			interactive_tx_signing_session: None,
 		});
 
 		let msg = self.get_splice_init(our_funding_contribution_satoshis, funding_feerate_per_kw, locktime);
@@ -10652,6 +10732,18 @@ impl<SP: Deref> PendingV2Channel<SP> where SP::Target: SignerProvider {
 	pub fn get_accept_channel_v2_message(&self) -> msgs::AcceptChannelV2 {
 		self.generate_accept_channel_v2_message()
 	}
+
+	/// Return a short-lived [`NegotiatingChannelView`].
+	fn as_negotiating_channel(&mut self) -> NegotiatingChannelView<SP> {
+		NegotiatingChannelView {
+			context: &mut self.context,
+			funding: &mut self.funding,
+			funding_negotiation_context: &mut self.funding_negotiation_context,
+			interactive_tx_constructor: &mut self.interactive_tx_constructor,
+			interactive_tx_signing_session: &mut self.interactive_tx_signing_session,
+			holder_commitment_transaction_number: self.unfunded_context.transaction_number(),
+		}
+	}
 }
 
 // Unfunded channel utilities
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
@@ -8636,7 +8636,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 	}
 
 	#[rustfmt::skip]
-	fn internal_tx_msg<HandleTxMsgFn: Fn(&mut Channel<SP>) -> Result<MessageSendEvent, &'static str>>(
+	fn internal_tx_msg<HandleTxMsgFn: Fn(&mut Channel<SP>) -> Result<MessageSendEvent, ChannelError>>(
 		&self, counterparty_node_id: &PublicKey, channel_id: ChannelId, tx_msg_handler: HandleTxMsgFn
 	) -> Result<(), MsgHandleErrInternal> {
 		let per_peer_state = self.per_peer_state.read().unwrap();
@@ -8654,9 +8654,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 				let channel = chan_entry.get_mut();
 				let msg_send_event = match tx_msg_handler(channel) {
 					Ok(msg_send_event) => msg_send_event,
-					Err(tx_msg_str) =>  return Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Warn(
-						format!("Got a {tx_msg_str} message with no interactive transaction construction expected or in-progress")
-					), channel_id)),
+					Err(err) =>  return Err(MsgHandleErrInternal::from_chan_no_close(err, channel_id)),
 				};
 				peer_state.pending_msg_events.push(msg_send_event);
 				Ok(())
@@ -8674,48 +8672,40 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		&self, counterparty_node_id: PublicKey, msg: &msgs::TxAddInput,
 	) -> Result<(), MsgHandleErrInternal> {
 		self.internal_tx_msg(&counterparty_node_id, msg.channel_id, |channel: &mut Channel<SP>| {
-			match channel.as_unfunded_v2_mut() {
-				Some(unfunded_channel) => {
-					Ok(unfunded_channel.tx_add_input(msg).into_msg_send_event(counterparty_node_id))
-				},
-				None => Err("tx_add_input"),
-			}
+			Ok(channel
+				.as_negotiating_channel()?
+				.tx_add_input(msg)
+				.into_msg_send_event(counterparty_node_id))
 		})
 	}
 
 	#[rustfmt::skip]
 	fn internal_tx_add_output(&self, counterparty_node_id: PublicKey, msg: &msgs::TxAddOutput) -> Result<(), MsgHandleErrInternal> {
 		self.internal_tx_msg(&counterparty_node_id, msg.channel_id, |channel: &mut Channel<SP>| {
-			match channel.as_unfunded_v2_mut() {
-				Some(unfunded_channel) => {
-					Ok(unfunded_channel.tx_add_output(msg).into_msg_send_event(counterparty_node_id))
-				},
-				None => Err("tx_add_output"),
-			}
+			Ok(channel.as_negotiating_channel()?
+				.tx_add_output(msg)
+				.into_msg_send_event(counterparty_node_id)
+			)
 		})
 	}
 
 	#[rustfmt::skip]
 	fn internal_tx_remove_input(&self, counterparty_node_id: PublicKey, msg: &msgs::TxRemoveInput) -> Result<(), MsgHandleErrInternal> {
 		self.internal_tx_msg(&counterparty_node_id, msg.channel_id, |channel: &mut Channel<SP>| {
-			match channel.as_unfunded_v2_mut() {
-				Some(unfunded_channel) => {
-					Ok(unfunded_channel.tx_remove_input(msg).into_msg_send_event(counterparty_node_id))
-				},
-				None => Err("tx_remove_input"),
-			}
+			Ok(channel.as_negotiating_channel()?
+				.tx_remove_input(msg)
+				.into_msg_send_event(counterparty_node_id)
+			)
 		})
 	}
 
 	#[rustfmt::skip]
 	fn internal_tx_remove_output(&self, counterparty_node_id: PublicKey, msg: &msgs::TxRemoveOutput) -> Result<(), MsgHandleErrInternal> {
 		self.internal_tx_msg(&counterparty_node_id, msg.channel_id, |channel: &mut Channel<SP>| {
-			match channel.as_unfunded_v2_mut() {
-				Some(unfunded_channel) => {
-					Ok(unfunded_channel.tx_remove_output(msg).into_msg_send_event(counterparty_node_id))
-				},
-				None => Err("tx_remove_output"),
-			}
+			Ok(channel.as_negotiating_channel()?
+				.tx_remove_output(msg)
+				.into_msg_send_event(counterparty_node_id)
+			)
 		})
 	}
 
@@ -8733,14 +8723,13 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		let peer_state = &mut *peer_state_lock;
 		match peer_state.channel_by_id.entry(msg.channel_id) {
 			hash_map::Entry::Occupied(mut chan_entry) => {
-				let (msg_send_event_opt, signing_session_opt) = match chan_entry.get_mut().as_unfunded_v2_mut() {
-					Some(chan) => chan.tx_complete(msg)
+				let (msg_send_event_opt, signing_session_opt) = match chan_entry.get_mut().as_negotiating_channel() {
+					Ok(mut negotiating_channel) => negotiating_channel
+						.tx_complete(msg)
 						.into_msg_send_event_or_signing_session(counterparty_node_id),
-					None => try_channel_entry!(self, peer_state, Err(ChannelError::Close(
-						(
-							"Got a tx_complete message with no interactive transaction construction expected or in-progress".into(),
-							ClosureReason::HolderForceClosed { broadcasted_latest_txn: Some(false) },
-						))), chan_entry)
+					Err(err) => {
+						try_channel_entry!(self, peer_state, Err(err), chan_entry)
+					}
 				};
 				if let Some(msg_send_event) = msg_send_event_opt {
 					peer_state.pending_msg_events.push(msg_send_event);
