Add TransactionType::Splice variant for splice transactions

Add a new `Splice` variant to `TransactionType` to distinguish splice
transactions from regular funding transactions when broadcasting.

Update `FundingTxSigned` to include the transaction type alongside the
funding transaction, allowing the channel manager to broadcast with the
correct type information for both initial funding and splice operations.

Co-Authored-By: HAL 9000

Author: tnull

lightning/src/chain/chaininterface.rs

@@ -63,6 +63,11 @@ pub enum TransactionType {
 		/// A single sweep transaction may aggregate outputs from multiple channels.
 		channel_ids: Vec<ChannelId>,
 	},
+	/// A splice transaction modifying an existing channel's funding.
+	Splice {
+		/// The ID of the channel being spliced.
+		channel_id: ChannelId,
+	},
 }
 
 // TODO: Define typed abstraction over feerates to handle their conversions.

lightning/src/ln/channel.rs

@@ -28,7 +28,7 @@ use bitcoin::{secp256k1, sighash, FeeRate, Sequence, TxIn};
 
 use crate::blinded_path::message::BlindedMessagePath;
 use crate::chain::chaininterface::{
-	fee_for_weight, ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator,
+	fee_for_weight, ConfirmationTarget, FeeEstimator, LowerBoundedFeeEstimator, TransactionType,
 };
 use crate::chain::channelmonitor::{
 	ChannelMonitor, ChannelMonitorUpdate, ChannelMonitorUpdateStep, CommitmentHTLCData,
@@ -2103,6 +2103,8 @@ where
 			},
 		};
 
+		let channel_id = context.channel_id;
+
 		let signing_session = if let Some(signing_session) =
 			context.interactive_tx_signing_session.as_mut()
 		{
@@ -2213,6 +2215,15 @@ where
 			(None, None)
 		};
 
+		let funding_tx = funding_tx.map(|tx| {
+			let tx_type = if splice_negotiated.is_some() {
+				TransactionType::Splice { channel_id }
+			} else {
+				TransactionType::Funding { channel_ids: vec![channel_id] }
+			};
+			(tx, tx_type)
+		});
+
 		// If we have a pending splice with a buffered initial commitment signed from our
 		// counterparty, process it now that we have provided our signatures.
 		let counterparty_initial_commitment_signed_result =
@@ -6919,8 +6930,8 @@ pub(super) struct FundingTxSigned {
 	/// Signatures that should be sent to the counterparty, if necessary.
 	pub tx_signatures: Option<msgs::TxSignatures>,
 
-	/// The fully-signed funding transaction to be broadcast.
-	pub funding_tx: Option<Transaction>,
+	/// The fully-signed funding transaction to be broadcast, along with the transaction type.
+	pub funding_tx: Option<(Transaction, TransactionType)>,
 
 	/// Information about the completed funding negotiation.
 	pub splice_negotiated: Option<SpliceFundingNegotiated>,
@@ -9143,6 +9154,15 @@ where
 			(None, None)
 		};
 
+		let funding_tx = funding_tx.map(|tx| {
+			let tx_type = if splice_negotiated.is_some() {
+				TransactionType::Splice { channel_id: self.context.channel_id }
+			} else {
+				TransactionType::Funding { channel_ids: vec![self.context.channel_id] }
+			};
+			(tx, tx_type)
+		});
+
 		Ok(FundingTxSigned {
 			commitment_signed: None,
 			counterparty_initial_commitment_signed_result: None,

lightning/src/ln/channelmanager.rs

@@ -6429,13 +6429,14 @@ impl<
 							splice_negotiated,
 							splice_locked,
 						}) => {
-							if let Some(funding_tx) = funding_tx {
+							if let Some((funding_tx, tx_type)) = funding_tx {
 								let funded_chan = chan.as_funded_mut().expect(
 									"Funding transactions ready for broadcast can only exist for funded channels",
 								);
 								self.broadcast_interactive_funding(
 									funded_chan,
 									&funding_tx,
+									Some(tx_type),
 									&self.logger,
 								);
 							}
@@ -6563,18 +6564,19 @@ impl<
 	}
 
 	fn broadcast_interactive_funding(
-		&self, channel: &mut FundedChannel<SP>, funding_tx: &Transaction, logger: &L,
+		&self, channel: &mut FundedChannel<SP>, funding_tx: &Transaction,
+		transaction_type: Option<TransactionType>, logger: &L,
 	) {
 		let logger = WithChannelContext::from(logger, channel.context(), None);
 		log_info!(
 			logger,
 			"Broadcasting signed interactive funding transaction {}",
 			funding_tx.compute_txid()
 		);
-		self.tx_broadcaster.broadcast_transactions(&[(
-			funding_tx,
-			TransactionType::Funding { channel_ids: vec![channel.context().channel_id()] },
-		)]);
+		let tx_type = transaction_type.unwrap_or_else(|| TransactionType::Funding {
+			channel_ids: vec![channel.context().channel_id()],
+		});
+		self.tx_broadcaster.broadcast_transactions(&[(funding_tx, tx_type)]);
 		{
 			let mut pending_events = self.pending_events.lock().unwrap();
 			emit_channel_pending_event!(pending_events, channel);
@@ -11402,8 +11404,8 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 								msg: splice_locked,
 							});
 						}
-						if let Some(ref funding_tx) = funding_tx {
-							self.broadcast_interactive_funding(chan, funding_tx, &self.logger);
+						if let Some((ref funding_tx, ref tx_type)) = funding_tx {
+							self.broadcast_interactive_funding(chan, funding_tx, Some(tx_type.clone()), &self.logger);
 						}
 						if let Some(splice_negotiated) = splice_negotiated {
 							self.pending_events.lock().unwrap().push_back((