New RefundingScope; FundedChannel can act as pending

FundedChannel is extended with an optional struct RefundingScope, that holds data used during splicing (re)negotiation.
It stores the same fields as PendingV2Channel, excet for the context.
FundedChannel can act as a transaction constructor (much like PendingV2Channel), when the refunding context is present.

Author: optout21

lightning/src/ln/channel.rs

@@ -1253,7 +1253,14 @@ impl<SP: Deref> Channel<SP> where
 	pub fn unfunded_context_mut(&mut self) -> Option<&mut UnfundedChannelContext> {
 		match &mut self.phase {
 			ChannelPhase::Undefined => unreachable!(),
-			ChannelPhase::Funded(_) => { debug_assert!(false); None },
+			#[cfg(not(splicing))]
+			ChannelPhase::Funded(_) => { debug_assert!(false); None }
+			#[cfg(splicing)]
+			ChannelPhase::Funded(chan) => {
+				chan.pending_splice.as_mut().map(|splice|
+					splice.refunding_scope.as_mut().map(|refunding_scope| &mut refunding_scope.pending_unfunded_context)
+				).flatten()
+			}
 			ChannelPhase::UnfundedOutboundV1(chan) => Some(&mut chan.unfunded_context),
 			ChannelPhase::UnfundedInboundV1(chan) => Some(&mut chan.unfunded_context),
 			ChannelPhase::UnfundedV2(chan) => Some(&mut chan.unfunded_context),
@@ -1801,12 +1808,19 @@ impl FundingScope {
 	}
 }
 
-/// Info about a pending splice, used in the pre-splice channel
+/// Info about a pending splice_init, used in the pre-splice channel
 #[cfg(splicing)]
-struct PendingSplice {
+struct PendingSpliceInit {
 	pub our_funding_contribution: i64,
 }
 
+/// Info about a pending splice
+#[cfg(splicing)]
+struct PendingSplice {
+	pub pending_splice_init: Option<PendingSpliceInit>,
+	pub refunding_scope: Option<RefundingScope>,
+}
+
 /// Contains everything about the channel including state, and various flags.
 pub(super) struct ChannelContext<SP: Deref> where SP::Target: SignerProvider {
 	config: LegacyChannelConfig,
@@ -2302,6 +2316,81 @@ impl<SP: Deref> InitialRemoteCommitmentReceiver<SP> for FundedChannel<SP> where
 	}
 }
 
+/// [`FundedChannel`] can act as a [`FundingTxConstructorV2`], but properly only when its
+/// [`RefundingScope`] is present.
+#[cfg(splicing)]
+impl<SP: Deref> FundingTxConstructorV2<SP> for FundedChannel<SP> where SP::Target: SignerProvider {
+	#[inline]
+	fn pending_funding(&self) -> Result<&FundingScope, &'static str> {
+		self.pending_splice.as_ref().map(|splice|
+			splice.refunding_scope.as_ref().map(|refunding| &refunding.pending_funding)
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn pending_funding_mut(&mut self) -> Result<&mut FundingScope, &'static str> {
+		self.pending_splice.as_mut().map(|splice|
+			splice.refunding_scope.as_mut().map(|refunding| &mut refunding.pending_funding)
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn pending_funding_and_context_mut(&mut self) -> Result<(&FundingScope, &mut ChannelContext<SP>), &'static str> {
+		let context_mut = &mut self.context;
+		self.pending_splice.as_ref().map(|splice|
+			splice.refunding_scope.as_ref().map(|refunding| (&refunding.pending_funding, context_mut))
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn dual_funding_context(&self) -> Result<&DualFundingChannelContext, &'static str> {
+		self.pending_splice.as_ref().map(|splice|
+			splice.refunding_scope.as_ref().map(|refunding| &refunding.pending_dual_funding_context)
+		).flatten().ok_or("Not re-funding")
+	}
+
+	fn swap_out_dual_funding_context_inputs(&mut self, funding_inputs: &mut Vec<(TxIn, TransactionU16LenLimited)>) -> Result<(), &'static str> {
+		if let Some(pending_splice) = &mut self.pending_splice {
+			if let Some(refunding) = &mut pending_splice.refunding_scope {
+				mem::swap(&mut refunding.pending_dual_funding_context.our_funding_inputs, funding_inputs);
+				Ok(())
+			} else {
+				Err("Not re-funding")
+			}
+		} else {
+			Err("Not re-funding")
+		}
+	}
+
+	#[inline]
+	fn unfunded_context(&self) -> Result<&UnfundedChannelContext, &'static str> {
+		self.pending_splice.as_ref().map(|splice|
+			splice.refunding_scope.as_ref().map(|refunding| &refunding.pending_unfunded_context)
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn interactive_tx_constructor(&self) -> Result<Option<&InteractiveTxConstructor>, &'static str> {
+		self.pending_splice.as_ref().map(|splice|
+			splice.refunding_scope.as_ref().map(|refunding| refunding.pending_interactive_tx_constructor.as_ref())
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn interactive_tx_constructor_mut(&mut self) -> Result<&mut Option<InteractiveTxConstructor>, &'static str> {
+		self.pending_splice.as_mut().map(|splice|
+			splice.refunding_scope.as_mut().map(|refunding| &mut refunding.pending_interactive_tx_constructor)
+		).flatten().ok_or("Not re-funding")
+	}
+
+	#[inline]
+	fn interactive_tx_signing_session_mut(&mut self) -> Result<&mut Option<InteractiveTxSigningSession>, &'static str> {
+		self.pending_splice.as_mut().map(|splice|
+			splice.refunding_scope.as_mut().map(|refunding| &mut refunding.pending_interactive_tx_signing_session)
+		).flatten().ok_or("Not re-funding")
+	}
+}
+
 /// A channel struct implementing this trait can perform V2 transaction negotiation,
 /// either at channel open or during splicing.
 /// Accessors return a Result, because [`FundedChannel`] can act like a TX constructor,
@@ -2659,6 +2748,19 @@ impl<SP: Deref> FundingTxConstructorV2<SP> for PendingV2Channel<SP> where SP::Ta
 	}
 }
 
+/// Data needed during splicing --
+/// when the funding transaction is being renegotiated in a funded channel.
+#[cfg(splicing)]
+struct RefundingScope {
+	// Fields belonging for [`PendingV2Channel`], except the context
+	pending_funding: FundingScope,
+	pending_unfunded_context: UnfundedChannelContext,
+	pending_dual_funding_context: DualFundingChannelContext,
+	/// The current interactive transaction construction session under negotiation.
+	pending_interactive_tx_constructor: Option<InteractiveTxConstructor>,
+	pending_interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
+}
+
 impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 	fn new_for_inbound_channel<'a, ES: Deref, F: Deref, L: Deref>(
 		fee_estimator: &'a LowerBoundedFeeEstimator<F>,
@@ -8726,10 +8828,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.pending_splice_init.as_ref().map(|ps| ps.our_funding_contribution).unwrap_or_default(),
 			)});
 		}
 
@@ -8762,9 +8865,13 @@ impl<SP: Deref> FundedChannel<SP> where
 				self.context.channel_id(), err,
 			)})?;
 
-		self.pending_splice = Some(PendingSplice {
+		let pending_splice_init = Some(PendingSpliceInit {
 			our_funding_contribution: our_funding_contribution_satoshis,
 		});
+		self.pending_splice = Some(PendingSplice {
+			pending_splice_init,
+			refunding_scope: None,
+		});
 
 		let msg = self.get_splice_init(our_funding_contribution_satoshis, funding_feerate_per_kw, locktime);
 		Ok(msg)
@@ -8796,9 +8903,11 @@ impl<SP: Deref> FundedChannel<SP> where
 		let our_funding_contribution_satoshis = 0i64;
 
 		// Check if a splice has been initiated already.
-		if let Some(splice_info) = &self.pending_splice {
+		if let Some(pending_splice) = &self.pending_splice {
 			return Err(ChannelError::Warn(format!(
-				"Channel has already a splice pending, contribution {}", splice_info.our_funding_contribution,
+				"Channel {} has already a splice pending, contribution {}",
+				self.context.channel_id(),
+				pending_splice.pending_splice_init.as_ref().map(|si| si.our_funding_contribution).unwrap_or_default(),
 			)));
 		}
 
@@ -8843,7 +8952,11 @@ impl<SP: Deref> FundedChannel<SP> where
 	#[cfg(splicing)]
 	pub fn splice_ack(&mut self, _msg: &msgs::SpliceAck) -> Result<(), ChannelError> {
 		// check if splice is pending
-		if self.pending_splice.is_none() {
+		if let Some(pending_splice) = &self.pending_splice {
+			if pending_splice.pending_splice_init.is_none() {
+				return Err(ChannelError::Warn(format!("Channel is not in pending splice_init")));
+			}
+		} else {
 			return Err(ChannelError::Warn(format!("Channel is not in pending splice")));
 		};