Introduce NegotiatingChannelView to bridge Funded and PendingV2

Introduce struct NegotiatingChannelView to perform transaction negotiation
logic, on top of either PendingV2Channel (dual-funded channel open) or
FundedChannel (splicing).

Author: optout21

lightning/src/ln/channel.rs

@@ -1732,6 +1732,19 @@ 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(),
+			)),
+		}
+	}
+
 	#[rustfmt::skip]
 	pub fn funding_signed<L: Deref>(
 		&mut self, msg: &msgs::FundingSigned, best_block: BestBlock, signer_provider: &SP, logger: &L
@@ -1770,9 +1783,11 @@ 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()))
 		}
@@ -2175,8 +2190,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: 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>,
 
 	/// The funding txid used in the `splice_locked` sent to the counterparty.
 	sent_funding_txid: Option<Txid>,
@@ -2757,7 +2777,23 @@ where
 	}
 }
 
-impl<SP: Deref> PendingV2Channel<SP>
+/// 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,
 {
@@ -2841,13 +2877,15 @@ where
 		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())),
@@ -2858,8 +2896,10 @@ where
 		})
 	}
 
-	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())),
@@ -2870,8 +2910,10 @@ where
 		})
 	}
 
-	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())),
@@ -2882,10 +2924,10 @@ where
 		})
 	}
 
-	pub fn tx_remove_output(
+	pub(super) fn tx_remove_output(
 		&mut self, msg: &msgs::TxRemoveOutput,
 	) -> InteractiveTxMessageSendResult {
-		InteractiveTxMessageSendResult(match &mut self.interactive_tx_constructor {
+		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())),
@@ -2896,9 +2938,9 @@ where
 		})
 	}
 
-	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,
@@ -2919,14 +2961,14 @@ where
 	}
 
 	#[rustfmt::skip]
-	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();
@@ -2947,9 +2989,10 @@ where
 			let reason = ClosureReason::ProcessingError { err: msg.to_owned() };
 			return Err(ChannelError::Close((msg.to_owned(), reason)));
 		};
-		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,
@@ -3000,8 +3043,8 @@ where
 		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))
 	}
@@ -5997,6 +6040,42 @@ where
 		self.context.force_shutdown(&self.funding, closure_reason)
 	}
 
+	/// 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 {
+				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")
+		}
+	}
+
 	#[rustfmt::skip]
 	fn check_remote_fee<F: Deref, L: Deref>(
 		channel_type: &ChannelTypeFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,
@@ -10181,10 +10260,11 @@ 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,
 			)});
 		}
 
@@ -10216,10 +10296,27 @@ 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 {
+			is_initiator: true,
+			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: None,
+			funding_negotiation_context,
+			interactive_tx_constructor: None,
+			interactive_tx_signing_session: None,
 			sent_funding_txid: None,
 			received_funding_txid: None,
 		});
@@ -12147,6 +12244,18 @@ where
 	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