Include failure context in splice events

fuzz/src/chanmon_consistency.rs

@@ -2015,7 +2015,7 @@ pub fn do_test<Out: Output + MaybeSend + MaybeSync>(data: &[u8], out: Out) {
 								)
 								.unwrap();
 						},
-						events::Event::SplicePending { new_funding_txo, .. } => {
+						events::Event::SpliceNegotiated { new_funding_txo, .. } => {
 							let broadcaster = match $node {
 								0 => &broadcast_a,
 								1 => &broadcast_b,
@@ -2027,7 +2027,7 @@ pub fn do_test<Out: Output + MaybeSend + MaybeSync>(data: &[u8], out: Out) {
 							assert_eq!(new_funding_txo.txid, splice_tx.compute_txid());
 							chain_state.confirm_tx(splice_tx);
 						},
-						events::Event::SpliceFailed { .. } => {},
+						events::Event::SpliceNegotiationFailed { .. } => {},
 						events::Event::DiscardFunding {
 							funding_info: events::FundingInfo::Contribution { .. },
 							..

fuzz/src/full_stack.rs

@@ -1141,10 +1141,10 @@ pub fn do_test(mut data: &[u8], logger: &Arc<dyn Logger + MaybeSend + MaybeSync>
 						signed_tx,
 					);
 				},
-				Event::SplicePending { .. } => {
+				Event::SpliceNegotiated { .. } => {
 					// Splice negotiation completed, waiting for confirmation
 				},
-				Event::SpliceFailed { .. } => {
+				Event::SpliceNegotiationFailed { .. } => {
 					// Splice failed, inputs can be re-spent
 				},
 				Event::OpenChannelRequest {

lightning/src/events/mod.rs

@@ -25,6 +25,7 @@ use crate::blinded_path::payment::{
 use crate::chain::transaction;
 use crate::ln::channel::FUNDING_CONF_DEADLINE_BLOCKS;
 use crate::ln::channelmanager::{InterceptId, PaymentId};
+use crate::ln::funding::FundingContribution;
 use crate::ln::msgs;
 use crate::ln::onion_utils::LocalHTLCFailureReason;
 use crate::ln::outbound_payment::RecipientOnionFields;
@@ -99,6 +100,109 @@ impl_writeable_tlv_based_enum!(FundingInfo,
 	}
 );
 
+/// The reason a funding negotiation round failed.
+///
+/// Each negotiation attempt (initial or RBF) resolves to either success or failure. This enum
+/// indicates what caused the failure. Use [`is_retriable`] to determine whether the splice can
+/// be reattempted on this channel by calling [`ChannelManager::splice_channel`].
+///
+/// [`is_retriable`]: Self::is_retriable
+/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum NegotiationFailureReason {
+	/// The reason was not available (e.g., from an older serialization).
+	Unknown,
+	/// The peer disconnected during negotiation. Wait for the peer to reconnect, then retry.
+	PeerDisconnected,
+	/// The counterparty explicitly aborted the negotiation by sending `tx_abort`. Retrying with
+	/// the same parameters is unlikely to succeed — consider adjusting the contribution or
+	/// waiting for the counterparty to initiate.
+	CounterpartyAborted {
+		/// The counterparty's abort message.
+		///
+		/// This is counterparty-provided data. Use `Display` on [`UntrustedString`] for safe
+		/// logging.
+		msg: UntrustedString,
+	},
+	/// An error occurred during interactive transaction negotiation (e.g., the counterparty sent
+	/// an invalid message). The negotiation was aborted.
+	NegotiationError {
+		/// A developer-readable error message.
+		msg: String,
+	},
+	/// The funding contribution was invalid (e.g., insufficient balance for the splice amount).
+	/// Call [`ChannelManager::splice_channel`] for a fresh [`FundingTemplate`] and build a new
+	/// contribution with adjusted parameters.
+	///
+	/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
+	/// [`FundingTemplate`]: crate::ln::funding::FundingTemplate
+	ContributionInvalid,
+	/// The negotiation was locally abandoned via `ChannelManager::abandon_splice`.
+	LocallyAbandoned,
+	/// The channel is closing, so the negotiation cannot continue. See [`Event::ChannelClosed`]
+	/// for the closure reason.
+	ChannelClosing,
+	/// The contribution's feerate was too low for RBF. Call [`ChannelManager::splice_channel`]
+	/// for a fresh [`FundingTemplate`] (which includes the updated minimum feerate) and build a
+	/// new contribution with a higher feerate.
+	///
+	/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
+	/// [`FundingTemplate`]: crate::ln::funding::FundingTemplate
+	FeeRateTooLow,
+}
+
+impl NegotiationFailureReason {
+	/// Whether the splice negotiation is likely to succeed if retried on this channel. When `true`,
+	/// call [`ChannelManager::splice_channel`] to obtain a fresh [`FundingTemplate`] and retry.
+	///
+	/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
+	/// [`FundingTemplate`]: crate::ln::funding::FundingTemplate
+	pub fn is_retriable(&self) -> bool {
+		match self {
+			Self::Unknown
+			| Self::PeerDisconnected
+			| Self::CounterpartyAborted { .. }
+			| Self::NegotiationError { .. }
+			| Self::ContributionInvalid
+			| Self::FeeRateTooLow => true,
+			Self::LocallyAbandoned | Self::ChannelClosing => false,
+		}
+	}
+}
+
+impl core::fmt::Display for NegotiationFailureReason {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		match self {
+			Self::Unknown => f.write_str("unknown reason"),
+			Self::PeerDisconnected => f.write_str("peer disconnected during negotiation"),
+			Self::CounterpartyAborted { msg } => {
+				write!(f, "counterparty aborted: {}", msg)
+			},
+			Self::NegotiationError { msg } => write!(f, "negotiation error: {}", msg),
+			Self::ContributionInvalid => f.write_str("funding contribution was invalid"),
+			Self::LocallyAbandoned => f.write_str("splice locally abandoned"),
+
+			Self::ChannelClosing => f.write_str("channel is closing"),
+			Self::FeeRateTooLow => f.write_str("feerate too low for RBF"),
+		}
+	}
+}
+
+impl_writeable_tlv_based_enum_upgradable!(NegotiationFailureReason,
+	(0, Unknown) => {},
+	(2, PeerDisconnected) => {},
+	(4, CounterpartyAborted) => {
+		(1, msg, required),
+	},
+	(6, NegotiationError) => {
+		(1, msg, required),
+	},
+	(8, ContributionInvalid) => {},
+	(10, LocallyAbandoned) => {},
+	(12, ChannelClosing) => {},
+	(14, FeeRateTooLow) => {},
+);
+
 /// Some information provided on receipt of payment depends on whether the payment received is a
 /// spontaneous payment or a "conventional" lightning payment that's paying an invoice.
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -1541,8 +1645,8 @@ pub enum Event {
 	/// # 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.
-	SplicePending {
-		/// The `channel_id` of the channel that has a pending splice funding transaction.
+	SpliceNegotiated {
+		/// The `channel_id` of the channel with the negotiated splice funding transaction.
 		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.
@@ -1560,19 +1664,20 @@ pub enum Event {
 		/// The witness script that is used to lock the channel's funding output to commitment transactions.
 		new_funding_redeem_script: ScriptBuf,
 	},
-	/// Used to indicate that a splice for the given `channel_id` has failed.
+	/// Used to indicate that a splice negotiation round for the given `channel_id` has failed.
 	///
-	/// This event may be emitted if a splice fails after it has been initiated but prior to signing
-	/// any negotiated funding transaction.
+	/// Each splice attempt (initial or RBF) resolves to either [`Event::SpliceNegotiated`] on
+	/// success or this event on failure. Prior successfully negotiated splice transactions are
+	/// unaffected.
 	///
-	/// Any UTXOs contributed to be spent by the funding transaction may be reused and will be
-	/// given in `contributed_inputs`.
+	/// Any UTXOs contributed to the failed round that are not committed to a prior negotiated
+	/// splice transaction will be returned via a preceding [`Event::DiscardFunding`].
 	///
 	/// # 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.
+	SpliceNegotiationFailed {
+		/// The `channel_id` of the channel for which the splice negotiation round 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.
@@ -1582,10 +1687,17 @@ pub enum Event {
 		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.
-		abandoned_funding_txo: Option<OutPoint>,
-		/// The features that this channel will operate with, if available.
-		channel_type: Option<ChannelTypeFeatures>,
+		/// The reason the splice negotiation failed.
+		reason: NegotiationFailureReason,
+		/// The funding contribution from the failed negotiation round, if available. This can be
+		/// fed back to [`ChannelManager::funding_contributed`] to retry with the same parameters.
+		/// Alternatively, call [`ChannelManager::splice_channel`] to obtain a fresh
+		/// [`FundingTemplate`] and build a new contribution.
+		///
+		/// [`ChannelManager::funding_contributed`]: crate::ln::channelmanager::ChannelManager::funding_contributed
+		/// [`ChannelManager::splice_channel`]: crate::ln::channelmanager::ChannelManager::splice_channel
+		/// [`FundingTemplate`]: crate::ln::funding::FundingTemplate
+		contribution: Option<FundingContribution>,
 	},
 	/// Used to indicate to the user that they can abandon the funding transaction and recycle the
 	/// inputs for another purpose.
@@ -2355,7 +2467,7 @@ impl Writeable for Event {
 				// We never write out FundingTransactionReadyForSigning events as they will be regenerated when
 				// necessary.
 			},
-			&Event::SplicePending {
+			&Event::SpliceNegotiated {
 				ref channel_id,
 				ref user_channel_id,
 				ref counterparty_node_id,
@@ -2373,20 +2485,20 @@ impl Writeable for Event {
 					(11, new_funding_redeem_script, required),
 				});
 			},
-			&Event::SpliceFailed {
+			&Event::SpliceNegotiationFailed {
 				ref channel_id,
 				ref user_channel_id,
 				ref counterparty_node_id,
-				ref abandoned_funding_txo,
-				ref channel_type,
+				ref reason,
+				ref contribution,
 			} => {
 				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, abandoned_funding_txo, option),
+					(11, reason, required),
+					(13, contribution, option),
 				});
 			},
 			// Note that, going forward, all new events must only write data inside of
@@ -3012,7 +3124,7 @@ impl MaybeReadable for Event {
 						(11, new_funding_redeem_script, required),
 					});
 
-					Ok(Some(Event::SplicePending {
+					Ok(Some(Event::SpliceNegotiated {
 						channel_id: channel_id.0.unwrap(),
 						user_channel_id: user_channel_id.0.unwrap(),
 						counterparty_node_id: counterparty_node_id.0.unwrap(),
@@ -3027,18 +3139,18 @@ impl MaybeReadable for Event {
 				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, abandoned_funding_txo, option),
+						(11, reason, upgradable_option),
+						(13, contribution, option),
 					});
 
-					Ok(Some(Event::SpliceFailed {
+					Ok(Some(Event::SpliceNegotiationFailed {
 						channel_id: channel_id.0.unwrap(),
 						user_channel_id: user_channel_id.0.unwrap(),
 						counterparty_node_id: counterparty_node_id.0.unwrap(),
-						abandoned_funding_txo,
-						channel_type,
+						reason: reason.unwrap_or(NegotiationFailureReason::Unknown),
+						contribution,
 					}))
 				};
 				f()

lightning/src/ln/async_signer_tests.rs

@@ -1647,8 +1647,8 @@ fn test_async_splice_initial_commit_sig() {
 		get_event_msg!(initiator, MessageSendEvent::SendTxSignatures, acceptor_node_id);
 	acceptor.node.handle_tx_signatures(initiator_node_id, &tx_signatures);
 
-	let _ = get_event!(initiator, Event::SplicePending);
-	let _ = get_event!(acceptor, Event::SplicePending);
+	let _ = get_event!(initiator, Event::SpliceNegotiated);
+	let _ = get_event!(acceptor, Event::SpliceNegotiated);
 }
 
 #[test]
@@ -1739,6 +1739,6 @@ fn test_async_splice_initial_commit_sig_waits_for_monitor_before_tx_signatures()
 		get_event_msg!(initiator, MessageSendEvent::SendTxSignatures, acceptor_node_id);
 	acceptor.node.handle_tx_signatures(initiator_node_id, &tx_signatures);
 
-	let _ = get_event!(initiator, Event::SplicePending);
-	let _ = get_event!(acceptor, Event::SplicePending);
+	let _ = get_event!(initiator, Event::SpliceNegotiated);
+	let _ = get_event!(acceptor, Event::SpliceNegotiated);
 }