f - Generalize Splice variant into InteractiveFunding

Rename TransactionType::Splice to TransactionType::InteractiveFunding
and reshape it as Vec<FundingCandidate> (original + RBF attempts) where
each candidate carries one or more ChannelFunding entries (forward-
compatible with batched splices and V2 channel establishment, neither
of which is implemented yet). Per-candidate contribution is tail-aligned
with negotiated_candidates so leading rounds where we didn't contribute
yield None.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jkczyz

lightning/src/chain/chaininterface.rs

@@ -106,23 +106,55 @@ pub enum TransactionType {
 		/// A single sweep transaction may aggregate outputs from multiple channels.
 		channels: Vec<(PublicKey, ChannelId)>,
 	},
-	/// A splice transaction modifying an existing channel's funding.
+	/// An interactively-negotiated funding transaction.
 	///
-	/// A transaction of this type will be broadcast as a result of a [`ChannelManager::splice_channel`] operation.
+	/// A transaction of this type will be broadcast as a result of a
+	/// [`ChannelManager::splice_channel`] operation, or (once supported) V2 (dual-funded) channel
+	/// establishment. The same variant is used for batches of either or both.
+	///
+	/// The `Vec` contains every negotiated candidate for this funding in order: the original
+	/// negotiation followed by any RBF replacements. The last entry is the candidate being
+	/// broadcast.
 	///
 	/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
-	Splice {
-		/// The `node_id` of the channel counterparty.
-		counterparty_node_id: PublicKey,
-		/// The ID of the channel being spliced.
-		channel_id: ChannelId,
-		/// The local node's contribution to this splice/RBF round, or `None` if we did not
-		/// contribute (e.g., a pure acceptor with zero value added).
-		contribution: Option<FundingContribution>,
-		/// For an RBF replacement, the txid of the prior negotiated splice candidate being
-		/// replaced. `None` for the first splice attempt.
-		replaced_txid: Option<Txid>,
-	},
+	InteractiveFunding(Vec<FundingCandidate>),
+}
+
+/// A single negotiated candidate within an [`TransactionType::InteractiveFunding`] broadcast.
+///
+/// The candidate is identified by its [`Txid`] and lists the channels participating in it. A
+/// single candidate funds more than one channel only when batching splices and/or V2 channel
+/// openings (not yet implemented).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct FundingCandidate {
+	/// The txid of this candidate.
+	pub txid: Txid,
+	/// The channels participating in this candidate.
+	pub channels: Vec<ChannelFunding>,
+}
+
+/// Information about a single channel's participation in a [`FundingCandidate`].
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ChannelFunding {
+	/// The `node_id` of the channel counterparty.
+	pub counterparty_node_id: PublicKey,
+	/// The ID of the channel.
+	pub channel_id: ChannelId,
+	/// Whether this channel is being newly established or is an existing channel being spliced.
+	pub purpose: FundingPurpose,
+	/// The local node's contribution to this channel in this candidate, or `None` if we did
+	/// not contribute (e.g., a pure acceptor with zero value added, or a leading RBF round
+	/// before we began contributing).
+	pub contribution: Option<FundingContribution>,
+}
+
+/// The role of a channel within a [`FundingCandidate`].
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FundingPurpose {
+	/// The channel is being newly established (V2 dual-funded open).
+	Establishment,
+	/// An existing channel is being spliced.
+	Splice,
 }
 
 // TODO: Define typed abstraction over feerates to handle their conversions.

lightning/src/ln/channel.rs

@@ -28,7 +28,8 @@ use bitcoin::{secp256k1, sighash, FeeRate, Sequence, TxIn};
 
 use crate::blinded_path::message::BlindedMessagePath;
 use crate::chain::chaininterface::{
-	ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator, TransactionType,
+	ChannelFunding, ConfirmationTarget, FeeEstimator, FundingCandidate, FundingPurpose,
+	LowerBoundedFeeEstimator, TransactionType,
 };
 use crate::chain::channelmonitor::{
 	ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, CommitmentHTLCData,
@@ -9394,17 +9395,32 @@ where
 					);
 				}
 
-				let replaced_txid =
-					pending_splice.negotiated_candidates.len().checked_sub(2).and_then(|idx| {
-						pending_splice.negotiated_candidates[idx].get_funding_txid()
-					});
-				let contribution = pending_splice.contributions.last().cloned();
-				let tx_type = TransactionType::Splice {
-					counterparty_node_id: self.context.counterparty_node_id,
-					channel_id: self.context.channel_id,
-					contribution,
-					replaced_txid,
-				};
+				let contrib_offset = pending_splice
+					.negotiated_candidates
+					.len()
+					.saturating_sub(pending_splice.contributions.len());
+				let candidates = pending_splice
+					.negotiated_candidates
+					.iter()
+					.enumerate()
+					.filter_map(|(i, funding)| {
+						let txid = funding.get_funding_txid()?;
+						let contribution = i
+							.checked_sub(contrib_offset)
+							.and_then(|j| pending_splice.contributions.get(j))
+							.cloned();
+						Some(FundingCandidate {
+							txid,
+							channels: vec![ChannelFunding {
+								counterparty_node_id: self.context.counterparty_node_id,
+								channel_id: self.context.channel_id,
+								purpose: FundingPurpose::Splice,
+								contribution,
+							}],
+						})
+					})
+					.collect();
+				let tx_type = TransactionType::InteractiveFunding(candidates);
 				funding_tx_signed.funding_tx = Some((funding_tx, tx_type));
 				funding_tx_signed.splice_negotiated = Some(splice_negotiated);
 				funding_tx_signed.splice_locked = splice_locked;

lightning/src/ln/channelmanager.rs

@@ -11136,7 +11136,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		} else if let Some((splice_tx, tx_type)) = funding_tx_signed
 			.as_mut()
 			.and_then(|v| v.funding_tx.take())
-			.filter(|(_, tx_type)| matches!(tx_type, TransactionType::Splice { .. }))
+			.filter(|(_, tx_type)| matches!(tx_type, TransactionType::InteractiveFunding(..)))
 		{
 			log_info!(logger, "Broadcasting signed splice transaction with txid {}", splice_tx.compute_txid());
 			self.tx_broadcaster.broadcast_transactions(&[(&splice_tx, tx_type)]);

lightning/src/ln/splicing_tests.rs

@@ -9,7 +9,7 @@
 
 #![cfg_attr(not(test), allow(unused_imports))]
 
-use crate::chain::chaininterface::{TransactionType, FEERATE_FLOOR_SATS_PER_KW};
+use crate::chain::chaininterface::{FundingPurpose, TransactionType, FEERATE_FLOOR_SATS_PER_KW};
 use crate::chain::channelmonitor::{ANTI_REORG_DELAY, LATENCY_GRACE_PERIOD_BLOCKS};
 use crate::chain::transaction::OutPoint;
 use crate::chain::ChannelMonitorUpdateStatus;
@@ -503,9 +503,9 @@ pub fn sign_interactive_funding_tx<'a, 'b, 'c, 'd>(
 	)
 }
 
-/// `expected_replaced_txid` is the expected value of `TransactionType::Splice.replaced_txid` on
-/// the resulting broadcast: `None` for a first splice attempt; `Some(txid)` for an RBF replacing
-/// that prior negotiated candidate.
+/// `expected_replaced_txid` is the expected txid of the prior negotiated candidate in the
+/// `TransactionType::InteractiveFunding` broadcast: `None` for a first splice attempt; `Some(txid)`
+/// for an RBF replacing that prior negotiated candidate.
 pub fn sign_interactive_funding_tx_with_acceptor_contribution<'a, 'b, 'c, 'd>(
 	initiator: &'a Node<'b, 'c, 'd>, acceptor: &'a Node<'b, 'c, 'd>, is_0conf: bool,
 	acceptor_has_contribution: bool, expected_replaced_txid: Option<Txid>,
@@ -608,28 +608,29 @@ pub fn sign_interactive_funding_tx_with_acceptor_contribution<'a, 'b, 'c, 'd>(
 		assert_eq!(initiator_txn[0].0, acceptor_txn[0].0);
 		let (tx, initiator_tx_type) = initiator_txn.remove(0);
 		let (_, acceptor_tx_type) = acceptor_txn.remove(0);
-		// Verify transaction types are Splice for both nodes. The initiator always contributes;
-		// the acceptor contributes iff the flag says so. Both parties must observe the same
-		// `replaced_txid` as the caller declares.
-		if let TransactionType::Splice { contribution, replaced_txid, .. } = &initiator_tx_type {
-			assert!(
-				contribution.is_some(),
-				"Initiator always contributes; expected Some, got None"
-			);
-			assert_eq!(*replaced_txid, expected_replaced_txid, "initiator replaced_txid mismatch");
-		} else {
-			panic!("Expected TransactionType::Splice, got {:?}", initiator_tx_type);
-		}
-		if let TransactionType::Splice { contribution, replaced_txid, .. } = &acceptor_tx_type {
-			assert_eq!(
-				contribution.is_some(),
-				acceptor_has_contribution,
-				"Acceptor contribution presence must match `acceptor_has_contribution`",
-			);
-			assert_eq!(*replaced_txid, expected_replaced_txid, "acceptor replaced_txid mismatch");
-		} else {
-			panic!("Expected TransactionType::Splice, got {:?}", acceptor_tx_type);
-		}
+		// Verify transaction types are InteractiveFunding for both nodes. The initiator always
+		// contributes; the acceptor contributes iff the flag says so. Both parties must observe
+		// the same prior candidate txid as the caller declares.
+		let assert_broadcast =
+			|label: &str, tx_type: &TransactionType, contribution_expected: bool| {
+				let candidates = match tx_type {
+					TransactionType::InteractiveFunding(candidates) => candidates,
+					other => panic!("Expected TransactionType::InteractiveFunding, got {other:?}"),
+				};
+				let last = candidates.last().expect("at least one candidate");
+				assert_eq!(last.txid, tx.compute_txid(), "{label} last candidate txid mismatch");
+				let last_channel = last.channels.first().expect("at least one channel");
+				assert!(matches!(last_channel.purpose, FundingPurpose::Splice));
+				assert_eq!(
+					last_channel.contribution.is_some(),
+					contribution_expected,
+					"{label} contribution presence mismatch",
+				);
+				let prior_txid = candidates.len().checked_sub(2).map(|i| candidates[i].txid);
+				assert_eq!(prior_txid, expected_replaced_txid, "{label} replaced_txid mismatch");
+			};
+		assert_broadcast("initiator", &initiator_tx_type, true);
+		assert_broadcast("acceptor", &acceptor_tx_type, acceptor_has_contribution);
 		tx
 	};
 	(tx, splice_locked)
@@ -4370,8 +4371,8 @@ fn test_splice_rbf_acceptor_basic() {
 		new_funding_script.clone(),
 	);
 
-	// Step 10: Sign and broadcast. The broadcast's `TransactionType::Splice.replaced_txid` must
-	// point at the first splice tx it is replacing.
+	// Step 10: Sign and broadcast. The prior candidate in the broadcast's
+	// `TransactionType::InteractiveFunding` must point at the first splice tx it is replacing.
 	let (rbf_tx, splice_locked) = sign_interactive_funding_tx(
 		&nodes[0],
 		&nodes[1],