Emit SpliceFailed events for interactive transaction failures

When interactive transaction construction fails during splice funding
negotiation, emit Event::SpliceFailed to notify users of the failure.

This introduces a SpliceFundingFailed struct to carry failure information
from channel functions to ChannelManager, where it is converted to the
appropriate event. The struct includes channel metadata and placeholders
for contributed inputs/outputs (currently empty pending access to private
InteractiveTxConstructor fields).

Updates all interactive transaction functions (tx_add_input, tx_add_output,
tx_remove_input, tx_remove_output, tx_complete) to return failure
information alongside abort messages, enabling proper event emission
when splice negotiations fail.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1714,43 +1714,56 @@ where
 
 	fn fail_interactive_tx_negotiation<L: Deref>(
 		&mut self, error: NegotiationError, logger: &L,
-	) -> msgs::TxAbort
+	) -> (msgs::TxAbort, Option<SpliceFundingFailed>)
 	where
 		L::Target: Logger,
 	{
 		let logger = WithChannelContext::from(logger, &self.context(), None);
-		let NegotiationError { reason, .. } = error;
+		let NegotiationError { reason, contributed_inputs, contributed_outputs } = error;
 		log_info!(logger, "Failed interactive transaction negotiation: {reason}");
 
-		let _interactive_tx_constructor = match &mut self.phase {
+		let splice_funding_failed = match &mut self.phase {
 			ChannelPhase::Undefined => unreachable!(),
 			ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_) => None,
 			ChannelPhase::UnfundedV2(pending_v2_channel) => {
-				pending_v2_channel.interactive_tx_constructor.take()
+				pending_v2_channel.interactive_tx_constructor.take();
+				None
+			},
+			ChannelPhase::Funded(funded_channel) => {
+				funded_channel
+					.pending_splice
+					.as_mut()
+					.and_then(|pending_splice| pending_splice.funding_negotiation.take())
+					.filter(|funding_negotiation| funding_negotiation.is_initiator())
+					.map(|funding_negotiation| {
+						let funding_txo = funding_negotiation
+							.as_funding()
+							.and_then(|funding| funding.get_funding_txo())
+							.map(|txo| txo.into_bitcoin_outpoint());
+
+						let channel_type = funding_negotiation
+							.as_funding()
+							.map(|funding| funding.get_channel_type().clone());
+
+						SpliceFundingFailed {
+							channel_id: funded_channel.context.channel_id,
+							counterparty_node_id: funded_channel.context.counterparty_node_id,
+							user_channel_id: funded_channel.context.user_id,
+							funding_txo,
+							channel_type,
+							contributed_inputs,
+							contributed_outputs,
+						}
+					})
 			},
-			ChannelPhase::Funded(funded_channel) => funded_channel
-				.pending_splice
-				.as_mut()
-				.and_then(|pending_splice| pending_splice.funding_negotiation.take())
-				.and_then(|funding_negotiation| {
-					if let FundingNegotiation::ConstructingTransaction {
-						interactive_tx_constructor,
-						..
-					} = funding_negotiation
-					{
-						Some(interactive_tx_constructor)
-					} else {
-						None
-					}
-				}),
 		};
 
-		reason.into_tx_abort_msg(self.context().channel_id)
+		(reason.into_tx_abort_msg(self.context().channel_id), splice_funding_failed)
 	}
 
 	pub fn tx_add_input<L: Deref>(
 		&mut self, msg: &msgs::TxAddInput, logger: &L,
-	) -> Result<InteractiveTxMessageSend, msgs::TxAbort>
+	) -> Result<InteractiveTxMessageSend, (msgs::TxAbort, Option<SpliceFundingFailed>)>
 	where
 		L::Target: Logger,
 	{
@@ -1769,7 +1782,7 @@ where
 
 	pub fn tx_add_output<L: Deref>(
 		&mut self, msg: &msgs::TxAddOutput, logger: &L,
-	) -> Result<InteractiveTxMessageSend, msgs::TxAbort>
+	) -> Result<InteractiveTxMessageSend, (msgs::TxAbort, Option<SpliceFundingFailed>)>
 	where
 		L::Target: Logger,
 	{
@@ -1790,7 +1803,7 @@ where
 
 	pub fn tx_remove_input<L: Deref>(
 		&mut self, msg: &msgs::TxRemoveInput, logger: &L,
-	) -> Result<InteractiveTxMessageSend, msgs::TxAbort>
+	) -> Result<InteractiveTxMessageSend, (msgs::TxAbort, Option<SpliceFundingFailed>)>
 	where
 		L::Target: Logger,
 	{
@@ -1811,7 +1824,7 @@ where
 
 	pub fn tx_remove_output<L: Deref>(
 		&mut self, msg: &msgs::TxRemoveOutput, logger: &L,
-	) -> Result<InteractiveTxMessageSend, msgs::TxAbort>
+	) -> Result<InteractiveTxMessageSend, (msgs::TxAbort, Option<SpliceFundingFailed>)>
 	where
 		L::Target: Logger,
 	{
@@ -1832,7 +1845,7 @@ where
 
 	pub fn tx_complete<L: Deref>(
 		&mut self, msg: &msgs::TxComplete, logger: &L,
-	) -> Result<(Option<InteractiveTxMessageSend>, Option<msgs::CommitmentSigned>), msgs::TxAbort>
+	) -> Result<(Option<InteractiveTxMessageSend>, Option<msgs::CommitmentSigned>), (msgs::TxAbort, Option<SpliceFundingFailed>)>
 	where
 		L::Target: Logger,
 	{
@@ -1985,6 +1998,7 @@ where
 							interactive_tx_constructor,
 						} = funding_negotiation
 						{
+							let is_initiator = interactive_tx_constructor.is_initiator();
 							let signing_session = interactive_tx_constructor.into_signing_session();
 							let commitment_signed = chan.context.funding_tx_constructed(
 								&mut funding,
@@ -1995,7 +2009,7 @@ where
 							)?;
 
 							pending_splice.funding_negotiation =
-								Some(FundingNegotiation::AwaitingSignatures { funding });
+								Some(FundingNegotiation::AwaitingSignatures { funding, is_initiator });
 
 							return Ok(commitment_signed);
 						} else {
@@ -2596,12 +2610,14 @@ enum FundingNegotiation {
 	},
 	AwaitingSignatures {
 		funding: FundingScope,
+		is_initiator: bool,
 	},
 }
 
 impl_writeable_tlv_based_enum_upgradable!(FundingNegotiation,
 	(0, AwaitingSignatures) => {
 		(1, funding, required),
+		(3, is_initiator, required),
 	},
 	unread_variants: AwaitingAck, ConstructingTransaction
 );
@@ -2611,7 +2627,17 @@ impl FundingNegotiation {
 		match self {
 			FundingNegotiation::AwaitingAck { .. } => None,
 			FundingNegotiation::ConstructingTransaction { funding, .. } => Some(funding),
-			FundingNegotiation::AwaitingSignatures { funding } => Some(funding),
+			FundingNegotiation::AwaitingSignatures { funding, .. } => Some(funding),
+		}
+	}
+
+	fn is_initiator(&self) -> bool {
+		match self {
+			FundingNegotiation::AwaitingAck { context } => context.is_initiator,
+			FundingNegotiation::ConstructingTransaction { interactive_tx_constructor, .. } => {
+				interactive_tx_constructor.is_initiator()
+			},
+			FundingNegotiation::AwaitingSignatures { is_initiator, .. } => *is_initiator,
 		}
 	}
 }
@@ -6802,6 +6828,25 @@ pub struct SpliceFundingNegotiated {
 	pub channel_type: ChannelTypeFeatures,
 }
 
+/// Information about a splice funding negotiation that has failed.
+/// This is returned from channel operations and converted to an Event::SpliceFailed in ChannelManager.
+pub struct SpliceFundingFailed {
+	/// The channel_id of the channel for which the splice failed.
+	pub channel_id: ChannelId,
+	/// The counterparty's node_id.
+	pub counterparty_node_id: PublicKey,
+	/// The user_channel_id value.
+	pub user_channel_id: u128,
+	/// The outpoint of the channel's splice funding transaction, if one was created.
+	pub funding_txo: Option<bitcoin::OutPoint>,
+	/// The features that this channel will operate with, if available.
+	pub channel_type: Option<ChannelTypeFeatures>,
+	/// Input outpoints contributed to the splice transaction.
+	pub contributed_inputs: Vec<bitcoin::OutPoint>,
+	/// Outputs contributed to the splice transaction.
+	pub contributed_outputs: Vec<bitcoin::TxOut>,
+}
+
 pub struct SpliceFundingPromotion {
 	pub funding_txo: OutPoint,
 	pub monitor_update: Option<ChannelMonitorUpdate>,
@@ -8649,7 +8694,7 @@ where
 
 		if let Some(pending_splice) = self.pending_splice.as_mut() {
 			self.context.channel_state.clear_quiescent();
-			if let Some(FundingNegotiation::AwaitingSignatures { mut funding }) =
+			if let Some(FundingNegotiation::AwaitingSignatures { mut funding, .. }) =
 				pending_splice.funding_negotiation.take()
 			{
 				funding.funding_transaction = Some(funding_tx);
@@ -9566,7 +9611,7 @@ where
 						.as_ref()
 						.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
 						.and_then(|funding_negotiation| {
-							if let FundingNegotiation::AwaitingSignatures { funding } = &funding_negotiation {
+							if let FundingNegotiation::AwaitingSignatures { funding, .. } = &funding_negotiation {
 								Some(funding)
 							} else {
 								None

lightning/src/ln/channelmanager.rs

@@ -61,7 +61,7 @@ use crate::ln::channel::QuiescentAction;
 use crate::ln::channel::{
 	self, hold_time_since, Channel, ChannelError, ChannelUpdateStatus, FundedChannel,
 	InboundV1Channel, OutboundV1Channel, PendingV2Channel, ReconnectionMsg, ShutdownResult,
-	StfuResponse, UpdateFulfillCommitFetch, WithChannelContext,
+	SpliceFundingFailed, StfuResponse, UpdateFulfillCommitFetch, WithChannelContext,
 };
 use crate::ln::channel_state::ChannelDetails;
 use crate::ln::funding::SpliceContribution;
@@ -9997,7 +9997,7 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 	}
 
 	fn internal_tx_msg<
-		HandleTxMsgFn: Fn(&mut Channel<SP>) -> Result<InteractiveTxMessageSend, msgs::TxAbort>,
+		HandleTxMsgFn: Fn(&mut Channel<SP>) -> Result<InteractiveTxMessageSend, (msgs::TxAbort, Option<SpliceFundingFailed>)>,
 	>(
 		&self, counterparty_node_id: &PublicKey, channel_id: ChannelId,
 		tx_msg_handler: HandleTxMsgFn,
@@ -10015,16 +10015,30 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		match peer_state.channel_by_id.entry(channel_id) {
 			hash_map::Entry::Occupied(mut chan_entry) => {
 				let channel = chan_entry.get_mut();
-				let msg_send_event = match tx_msg_handler(channel) {
-					Ok(msg_send) => msg_send.into_msg_send_event(*counterparty_node_id),
-					Err(tx_abort) => {
-						MessageSendEvent::SendTxAbort {
+				match tx_msg_handler(channel) {
+					Ok(msg_send) => {
+						let msg_send_event = msg_send.into_msg_send_event(*counterparty_node_id);
+						peer_state.pending_msg_events.push(msg_send_event);
+					},
+					Err((tx_abort, splice_funding_failed)) => {
+						peer_state.pending_msg_events.push(MessageSendEvent::SendTxAbort {
 							node_id: *counterparty_node_id,
 							msg: tx_abort,
+						});
+						if let Some(splice_funding_failed) = splice_funding_failed {
+							let pending_events = &mut self.pending_events.lock().unwrap();
+							pending_events.push_back((events::Event::SpliceFailed {
+								channel_id,
+								counterparty_node_id: *counterparty_node_id,
+								user_channel_id: channel.context().get_user_id(),
+								funding_txo: splice_funding_failed.funding_txo,
+								channel_type: splice_funding_failed.channel_type.clone(),
+								contributed_inputs: splice_funding_failed.contributed_inputs,
+								contributed_outputs: splice_funding_failed.contributed_outputs,
+							}, None));
 						}
 					},
 				};
-				peer_state.pending_msg_events.push(msg_send_event);
 				Ok(())
 			},
 			hash_map::Entry::Vacant(_) => {
@@ -10104,11 +10118,23 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 							});
 						}
 					},
-					Err(tx_abort) => {
+					Err((tx_abort, splice_funding_failed)) => {
 						peer_state.pending_msg_events.push(MessageSendEvent::SendTxAbort {
 							node_id: counterparty_node_id,
 							msg: tx_abort,
 						});
+						if let Some(splice_funding_failed) = splice_funding_failed {
+							let pending_events = &mut self.pending_events.lock().unwrap();
+							pending_events.push_back((events::Event::SpliceFailed {
+								channel_id: msg.channel_id,
+								counterparty_node_id,
+								user_channel_id: chan.context().get_user_id(),
+								funding_txo: splice_funding_failed.funding_txo,
+								channel_type: splice_funding_failed.channel_type.clone(),
+								contributed_inputs: splice_funding_failed.contributed_inputs,
+								contributed_outputs: splice_funding_failed.contributed_outputs,
+							}, None));
+						}
 					},
 				}
 				Ok(())

lightning/src/ln/interactivetxs.rs

@@ -1916,6 +1916,7 @@ impl InteractiveTxInput {
 
 pub(super) struct InteractiveTxConstructor {
 	state_machine: StateMachine,
+	is_initiator: bool,
 	initiator_first_message: Option<InteractiveTxMessageSend>,
 	channel_id: ChannelId,
 	inputs_to_contribute: Vec<(SerialId, InputOwned)>,
@@ -2090,6 +2091,7 @@ impl InteractiveTxConstructor {
 
 		let mut constructor = Self {
 			state_machine,
+			is_initiator,
 			initiator_first_message: None,
 			channel_id,
 			inputs_to_contribute,
@@ -2102,6 +2104,10 @@ impl InteractiveTxConstructor {
 		Ok(constructor)
 	}
 
+	pub fn is_initiator(&self) -> bool {
+		self.is_initiator
+	}
+
 	pub fn take_initiator_first_message(&mut self) -> Option<InteractiveTxMessageSend> {
 		self.initiator_first_message.take()
 	}