Expose interactive funding candidates on broadcast

Replace TransactionType::Splice with TransactionType::InteractiveFunding
so downstream consumers can update their own state tracking from the
broadcast callback. The local contribution data isn't recoverable from
the on-chain transaction, so the broadcast must surface it directly.
Each candidate carries the participating channels and their local
contributions; the broadcast lists every negotiated candidate — original
first, then each RBF replacement — letting downstream reconcile any
historical txid, not just the immediate predecessor.

The new variant is structured to be forward-compatible with batches and
V2 (dual-funded) channel establishment, neither of which is implemented
today. The new types are Writeable/Readable so downstream can persist
them directly.

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

Author: jkczyz

lightning/src/chain/chaininterface.rs

@@ -15,9 +15,11 @@
 
 use core::{cmp, ops::Deref};
 
+use crate::ln::funding::FundingContribution;
 use crate::ln::types::ChannelId;
 use crate::prelude::*;
 
+use bitcoin::hash_types::Txid;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::transaction::Transaction;
 
@@ -104,19 +106,76 @@ 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.
 	///
 	/// [`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,
+	InteractiveFunding {
+		/// Every negotiated candidate for this funding in order: the original negotiation
+		/// followed by any RBF replacements. The last entry is the candidate being broadcast.
+		candidates: Vec<FundingCandidate>,
 	},
 }
 
+/// A single negotiated candidate within a [`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, Hash, 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, Hash, 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, Hash, PartialEq, Eq)]
+pub enum FundingPurpose {
+	/// The channel is being newly established (V2 dual-funded open).
+	Establishment,
+	/// An existing channel is being spliced.
+	Splice,
+}
+
+// Needed so downstream consumers can persist these without needing to define wrapper types
+// mirroring the type structure.
+impl_writeable_tlv_based!(FundingCandidate, {
+	(1, txid, required),
+	(3, channels, required_vec),
+});
+
+impl_writeable_tlv_based!(ChannelFunding, {
+	(1, counterparty_node_id, required),
+	(3, channel_id, required),
+	(5, purpose, required),
+	(7, contribution, option),
+});
+
+impl_writeable_tlv_based_enum!(FundingPurpose,
+	(0, Establishment) => {},
+	(2, Splice) => {},
+);
+
 // TODO: Define typed abstraction over feerates to handle their conversions.
 pub(crate) fn compute_feerate_sat_per_1000_weight(fee_sat: u64, weight: u64) -> u32 {
 	(fee_sat * 1000 / weight).try_into().unwrap_or(u32::max_value())

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,
@@ -9382,10 +9383,34 @@ where
 					);
 				}
 
-				let tx_type = TransactionType::Splice {
-					counterparty_node_id: self.context.counterparty_node_id,
-					channel_id: self.context.channel_id,
-				};
+				let contrib_offset = pending_splice
+					.negotiated_candidates
+					.len()
+					.saturating_sub(pending_splice.contributions.len());
+				let candidates = pending_splice
+					.negotiated_candidates
+					.iter()
+					.enumerate()
+					.map(|(i, funding)| {
+						let txid = funding
+							.get_funding_txid()
+							.expect("negotiated candidates should have a funding txid");
+						let contribution = i
+							.checked_sub(contrib_offset)
+							.and_then(|j| pending_splice.contributions.get(j))
+							.cloned();
+						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

@@ -11124,7 +11124,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/funding.rs

@@ -539,7 +539,7 @@ enum FundingInputs {
 }
 
 /// The components of a funding transaction contributed by one party.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct FundingContribution {
 	/// The estimate fees responsible to be paid for the contribution.
 	estimated_fee: Amount,