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.
@@ -2676,6 +2679,15 @@ pub(crate) struct SpliceInstructions {
 	locktime: u32,
 }
 
+impl SpliceInstructions {
+	fn into_contributed_inputs_and_outputs(self) -> (Vec<bitcoin::OutPoint>, Vec<TxOut>) {
+		(
+			self.our_funding_inputs.into_iter().map(|input| input.utxo.outpoint).collect(),
+			self.our_funding_outputs,
+		)
+	}
+}
+
 impl_writeable_tlv_based!(SpliceInstructions, {
 	(1, adjusted_funding_contribution, required),
 	(3, our_funding_inputs, required_vec),
@@ -6030,6 +6042,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,
 		}
 	}
 
@@ -6823,7 +6836,42 @@ where
 	}
 
 	pub fn force_shutdown(&mut self, closure_reason: ClosureReason) -> ShutdownResult {
-		self.context.force_shutdown(&self.funding, closure_reason)
+		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| {
+				// FIXME: Populte after #4120 is merged
+				SpliceFundingFailed {
+					funding_txo: todo!(),
+					channel_type: todo!(),
+					contributed_inputs: todo!(),
+					contributed_outputs: todo!(),
+				}
+			})
+			.or_else(|| {
+				self.quiescent_action.take().and_then(|quiescent_action| match quiescent_action {
+					QuiescentAction::Splice(instructions) => {
+						let (inputs, outputs) = instructions.into_contributed_inputs_and_outputs();
+						Some(SpliceFundingFailed {
+							funding_txo: None,
+							channel_type: None,
+							contributed_inputs: inputs,
+							contributed_outputs: outputs,
+						})
+					},
+					#[cfg(any(test, fuzzing))]
+					_ => {
+						self.quiescent_action = Some(quiescent_action);
+						None
+					},
+				})
+			});
+
+		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> {
@@ -10258,6 +10306,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: shutdown_res.channel_id,
+					counterparty_node_id: shutdown_res.counterparty_node_id,
+					user_channel_id: shutdown_res.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 {