Add Event::SpliceFailed variant for splice transaction failures

Introduce SpliceFailed event to notify applications when splice
transaction construction or negotiation fails. This allows applications
to handle failures gracefully and take corrective action or retry.

The event includes similar fields to SplicePending but with optional
funding_txo and channel_type fields since they may not be available
when failures occur early in the process. Additionally includes
contributed_inputs and contributed_outputs vectors to provide
information about what inputs and outputs were attempted.

Uses TLV ID 52 for serialization to maintain proper event ordering
and avoid conflicts with other event types.

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

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

Author: jkczyz

lightning/src/events/mod.rs

@@ -49,7 +49,7 @@ use bitcoin::hashes::sha256::Hash as Sha256;
 use bitcoin::hashes::Hash;
 use bitcoin::script::ScriptBuf;
 use bitcoin::secp256k1::PublicKey;
-use bitcoin::{OutPoint, Transaction};
+use bitcoin::{OutPoint, Transaction, TxOut};
 use core::ops::Deref;
 
 #[allow(unused_imports)]
@@ -1436,6 +1436,37 @@ pub enum Event {
 		/// The features that this channel will operate with.
 		channel_type: ChannelTypeFeatures,
 	},
+	/// Used to indicate that a splice transaction for the given `channel_id` has failed.
+	///
+	/// This event is emitted when a splice transaction construction or negotiation fails,
+	/// allowing applications to handle the failure and potentially retry or take corrective action.
+	///
+	/// # Failure Behavior and Persistence
+	/// This event will eventually be replayed after failures-to-handle (i.e., the event handler
+	/// returning `Err(ReplayEvent ())`) and will be persisted across restarts.
+	SpliceFailed {
+		/// The `channel_id` of the channel for which the splice failed.
+		channel_id: ChannelId,
+		/// The `user_channel_id` value passed in to [`ChannelManager::create_channel`] for outbound
+		/// channels, or to [`ChannelManager::accept_inbound_channel`] for inbound channels if
+		/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
+		/// `user_channel_id` will be randomized for an inbound channel.
+		///
+		/// [`ChannelManager::create_channel`]: crate::ln::channelmanager::ChannelManager::create_channel
+		/// [`ChannelManager::accept_inbound_channel`]: crate::ln::channelmanager::ChannelManager::accept_inbound_channel
+		/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
+		user_channel_id: u128,
+		/// The `node_id` of the channel counterparty.
+		counterparty_node_id: PublicKey,
+		/// The outpoint of the channel's splice funding transaction, if one was created.
+		funding_txo: Option<OutPoint>,
+		/// The features that this channel will operate with, if available.
+		channel_type: Option<ChannelTypeFeatures>,
+		/// Input outpoints contributed to the splice transaction.
+		contributed_inputs: Vec<OutPoint>,
+		/// Outputs contributed to the splice transaction.
+		contributed_outputs: Vec<TxOut>,
+	},
 	/// Used to indicate that a channel with the given `channel_id` is ready to be used. This event
 	/// is emitted when
 	/// - the initial funding transaction has been confirmed on-chain to an acceptable depth
@@ -2198,6 +2229,26 @@ impl Writeable for Event {
 					(9, funding_txo, required),
 				});
 			},
+			&Event::SpliceFailed {
+				ref channel_id,
+				ref user_channel_id,
+				ref counterparty_node_id,
+				ref funding_txo,
+				ref channel_type,
+				ref contributed_inputs,
+				ref contributed_outputs,
+			} => {
+				52u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(1, channel_id, required),
+					(3, channel_type, option),
+					(5, user_channel_id, required),
+					(7, counterparty_node_id, required),
+					(9, funding_txo, option),
+					(11, *contributed_inputs, optional_vec),
+					(13, *contributed_outputs, optional_vec),
+				});
+			},
 			&Event::ConnectionNeeded { .. } => {
 				35u8.write(writer)?;
 				// Never write ConnectionNeeded events as buffered onion messages aren't serialized.
@@ -2856,6 +2907,30 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			52u8 => {
+				let mut f = || {
+					_init_and_read_len_prefixed_tlv_fields!(reader, {
+						(1, channel_id, required),
+						(3, channel_type, option),
+						(5, user_channel_id, required),
+						(7, counterparty_node_id, required),
+						(9, funding_txo, option),
+						(11, contributed_inputs, optional_vec),
+						(13, contributed_outputs, optional_vec),
+					});
+
+					Ok(Some(Event::SpliceFailed {
+						channel_id: channel_id.0.unwrap(),
+						user_channel_id: user_channel_id.0.unwrap(),
+						counterparty_node_id: counterparty_node_id.0.unwrap(),
+						funding_txo,
+						channel_type,
+						contributed_inputs: contributed_inputs.unwrap_or_default(),
+						contributed_outputs: contributed_outputs.unwrap_or_default(),
+					}))
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.