Emit SpliceFailed event when funded channels shut down with active splice negotiations

Adds SpliceFailed event emission immediately after ChannelClosed events when a
FundedChannel is shut down while having an active splice negotiation. This ensures
users are notified when splice operations are terminated due to channel closure.

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

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

Author: jkczyz

lightning/src/ln/channel.rs

@@ -1188,6 +1188,9 @@ pub(crate) struct ShutdownResult {
 	pub(crate) unbroadcasted_funding_tx: Option<Transaction>,
 	pub(crate) channel_funding_txo: Option<OutPoint>,
 	pub(crate) last_local_balance_msat: u64,
+	/// If a splice was in progress when the channel was shut down, this contains
+	/// the splice funding information for emitting a SpliceFailed event.
+	pub(crate) splice_funding_failed: Option<SpliceFundingFailed>,
 }
 
 /// Tracks the transaction number, along with current and next commitment points.
@@ -6043,6 +6046,7 @@ where
 			is_manual_broadcast: self.is_manual_broadcast,
 			channel_funding_txo: funding.get_funding_txo(),
 			last_local_balance_msat: funding.value_to_self_msat,
+			splice_funding_failed: None,
 		}
 	}
 
@@ -6846,7 +6850,38 @@ where
 	}
 
 	pub fn force_shutdown(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
-		self.context.force_shutdown(&self.funding, closure_reason)
+		// Capture splice funding failed information if we have an active splice negotiation
+		let splice_funding_failed = self.pending_splice.as_mut()
+			.and_then(|pending_splice| pending_splice.funding_negotiation.take())
+			.filter(|funding_negotiation| funding_negotiation.is_initiator())
+			.map(|funding_negotiation| {
+				// Create SpliceFundingFailed for any active splice negotiation during shutdown
+				let (funding_txo, channel_type) = match &funding_negotiation {
+					FundingNegotiation::AwaitingAck { .. } => {
+						(None, None)
+					},
+					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()))
+					},
+				};
+
+				SpliceFundingFailed {
+					channel_id: self.context.channel_id,
+					counterparty_node_id: self.context.counterparty_node_id,
+					user_channel_id: self.context.user_id,
+					funding_txo,
+					channel_type,
+					contributed_inputs: Vec::new(),
+					contributed_outputs: Vec::new(),
+				}
+			});
+
+		let mut shutdown_result = self.context.force_shutdown(&self.funding, closure_reason);
+		shutdown_result.splice_funding_failed = splice_funding_failed;
+		shutdown_result
 	}
 
 	fn interactive_tx_constructor_mut(&mut self) -> Option<&mut InteractiveTxConstructor> {
@@ -10284,6 +10319,7 @@ where
 			is_manual_broadcast: self.context.is_manual_broadcast,
 			channel_funding_txo: self.funding.get_funding_txo(),
 			last_local_balance_msat: self.funding.value_to_self_msat,
+			splice_funding_failed: None,
 		}
 	}
 

lightning/src/ln/channelmanager.rs

@@ -4509,6 +4509,19 @@ where
 				last_local_balance_msat: Some(shutdown_res.last_local_balance_msat),
 			}, None));
 
+			// Emit SpliceFailed event immediately after ChannelClosed if there was an active splice negotiation
+			if let Some(splice_funding_failed) = shutdown_res.splice_funding_failed.take() {
+				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));
+			}
+
 			if let Some(transaction) = shutdown_res.unbroadcasted_funding_tx {
 				let funding_info = if shutdown_res.is_manual_broadcast {
 					FundingInfo::OutPoint {