Emit SpliceFailed events when tx_abort is received for funded channels

When a tx_abort message is successfully processed for a funded channel
with an active splice negotiation, emit Event::SpliceFailed to notify
users that the splice operation was aborted by the counterparty.

This extends the SpliceFailed event coverage to handle abort scenarios,
providing comprehensive splice failure notifications across all stages:

- AwaitingAck: funding_txo and channel_type are None since funding
  parameters were not yet established
- ConstructingTransaction/AwaitingSignatures: Include actual funding
  information since negotiation had progressed to funding establishment

The implementation captures splice context before taking the funding
negotiation state, ensuring accurate failure information is available
for event emission while maintaining proper tx_abort acknowledgment
behavior per the Lightning specification.

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

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

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1887,7 +1887,7 @@ where
 
 	pub fn tx_abort<L: Deref>(
 		&mut self, msg: &msgs::TxAbort, logger: &L,
-	) -> Result<Option<msgs::TxAbort>, ChannelError>
+	) -> Result<Option<(msgs::TxAbort, SpliceFundingFailed)>, ChannelError>
 	where
 		L::Target: Logger,
 	{
@@ -1896,20 +1896,49 @@ where
 		// phase for this interactively constructed transaction and hence we have not exchanged
 		// `tx_signatures`. Either way, we never close the channel upon receiving a `tx_abort`:
 		//   https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L574-L576
-		let should_ack = match &mut self.phase {
+		let (should_ack, splice_funding_failed) = match &mut self.phase {
 			ChannelPhase::Undefined => unreachable!(),
 			ChannelPhase::UnfundedOutboundV1(_) | ChannelPhase::UnfundedInboundV1(_) => {
 				let err = "Got an unexpected tx_abort message: This is an unfunded channel created with V1 channel establishment";
 				return Err(ChannelError::Warn(err.into()));
 			},
 			ChannelPhase::UnfundedV2(pending_v2_channel) => {
-				pending_v2_channel.interactive_tx_constructor.take().is_some()
+				let had_constructor = pending_v2_channel.interactive_tx_constructor.take().is_some();
+				(had_constructor, None)
+			},
+			ChannelPhase::Funded(funded_channel) => {
+				let funding_negotiation_opt = funded_channel
+					.pending_splice
+					.as_mut()
+					.and_then(|pending_splice| pending_splice.funding_negotiation.take());
+
+				let should_ack = funding_negotiation_opt.is_some();
+				let splice_funding_failed = funding_negotiation_opt.map(|funding_negotiation| {
+					// Create SpliceFundingFailed for the aborted splice
+					let (funding_txo, channel_type) = match &funding_negotiation {
+						FundingNegotiation::ConstructingTransaction { funding, .. } => {
+							(funding.get_funding_txo().map(|txo| txo.into_bitcoin_outpoint()), Some(funding.get_channel_type().clone()))
+						},
+						FundingNegotiation::AwaitingSignatures { funding } => {
+							(funding.get_funding_txo().map(|txo| txo.into_bitcoin_outpoint()), Some(funding.get_channel_type().clone()))
+						},
+						FundingNegotiation::AwaitingAck { .. } => {
+							(None, None)
+						},
+					};
+
+					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: Vec::new(),
+						contributed_outputs: Vec::new(),
+					}
+				});
+				(should_ack, splice_funding_failed)
 			},
-			ChannelPhase::Funded(funded_channel) => funded_channel
-				.pending_splice
-				.as_mut()
-				.and_then(|pending_splice| pending_splice.funding_negotiation.take())
-				.is_some(),
 		};
 
 		// NOTE: Since at this point we have not sent a `tx_abort` message for this negotiation
@@ -1918,16 +1947,20 @@ where
 		//   https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L560-L561
 		// For rationale why we echo back `tx_abort`:
 		//   https://github.com/lightning/bolts/blob/247e83d/02-peer-protocol.md?plain=1#L578-L580
-		Ok(should_ack.then(|| {
+		let result = if should_ack {
 			let logger = WithChannelContext::from(logger, &self.context(), None);
 			let reason =
 				types::string::UntrustedString(String::from_utf8_lossy(&msg.data).to_string());
 			log_info!(logger, "Counterparty failed interactive transaction negotiation: {reason}");
-			msgs::TxAbort {
+			let tx_abort_response = msgs::TxAbort {
 				channel_id: msg.channel_id,
 				data: "Acknowledged tx_abort".to_string().into_bytes(),
-			}
-		}))
+			};
+			splice_funding_failed.map(|failed| (tx_abort_response, failed))
+		} else {
+			None
+		};
+		Ok(result)
 	}
 
 	#[rustfmt::skip]

lightning/src/ln/channelmanager.rs

@@ -10220,10 +10220,24 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		match peer_state.channel_by_id.entry(msg.channel_id) {
 			hash_map::Entry::Occupied(mut chan_entry) => {
 				let res = chan_entry.get_mut().tx_abort(msg, &self.logger);
-				if let Some(msg) = try_channel_entry!(self, peer_state, res, chan_entry) {
+				let tx_abort_and_splice_failed = try_channel_entry!(self, peer_state, res, chan_entry);
+
+				// Emit SpliceFailed event and send TxAbort response if we had an active splice negotiation
+				if let Some((tx_abort_msg, splice_funding_failed)) = tx_abort_and_splice_failed {
+					let pending_events = &mut self.pending_events.lock().unwrap();
+					pending_events.push_back((events::Event::SpliceFailed {
+						channel_id: splice_funding_failed.channel_id,
+						counterparty_node_id: splice_funding_failed.counterparty_node_id,
+						user_channel_id: splice_funding_failed.user_channel_id,
+						funding_txo: splice_funding_failed.funding_txo,
+						channel_type: splice_funding_failed.channel_type,
+						contributed_inputs: splice_funding_failed.contributed_inputs,
+						contributed_outputs: splice_funding_failed.contributed_outputs,
+					}, None));
+
 					peer_state.pending_msg_events.push(MessageSendEvent::SendTxAbort {
 						node_id: *counterparty_node_id,
-						msg,
+						msg: tx_abort_msg,
 					});
 				}
 				Ok(())