Split DiscardFunding from SpliceFailed event

When a splice fails, users need to reclaim UTXOs they contributed to the
funding transaction. Previously, the contributed inputs and outputs were
included in the SpliceFailed event. This commit splits them into a
separate DiscardFunding event with a new FundingInfo::Contribution
variant, providing a consistent interface for UTXO cleanup across all
funding failure scenarios.

Changes:
- Add FundingInfo::Contribution variant to hold inputs/outputs for
  DiscardFunding events
- Remove contributed_inputs/outputs fields from SpliceFailed event
- Add QuiescentError enum for better error handling in funding_contributed
- Emit DiscardFunding on all funding_contributed error paths
- Filter duplicate inputs/outputs when contribution overlaps existing
  pending contribution
- Return Err(APIError) from funding_contributed on all error cases
- Add comprehensive test coverage for funding_contributed error paths

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jkczyz

lightning/src/events/mod.rs

@@ -78,6 +78,13 @@ pub enum FundingInfo {
 		/// The outpoint of the funding
 		outpoint: transaction::OutPoint,
 	},
+	/// The contributions used to for a dual funding or splice funding transaction.
+	Contribution {
+		/// UTXOs spent as inputs contributed to the funding transaction.
+		inputs: Vec<OutPoint>,
+		/// Outputs contributed to the funding transaction.
+		outputs: Vec<TxOut>,
+	},
 }
 
 impl_writeable_tlv_based_enum!(FundingInfo,
@@ -86,6 +93,10 @@ impl_writeable_tlv_based_enum!(FundingInfo,
 	},
 	(1, OutPoint) => {
 		(1, outpoint, required)
+	},
+	(2, Contribution) => {
+		(0, inputs, optional_vec),
+		(1, outputs, optional_vec),
 	}
 );
 
@@ -1580,10 +1591,6 @@ pub enum Event {
 		abandoned_funding_txo: Option<OutPoint>,
 		/// The features that this channel will operate with, if available.
 		channel_type: Option<ChannelTypeFeatures>,
-		/// UTXOs spent as inputs contributed to the splice transaction.
-		contributed_inputs: Vec<OutPoint>,
-		/// Outputs contributed to the splice transaction.
-		contributed_outputs: Vec<TxOut>,
 	},
 	/// Used to indicate to the user that they can abandon the funding transaction and recycle the
 	/// inputs for another purpose.
@@ -2378,8 +2385,6 @@ impl Writeable for Event {
 				ref counterparty_node_id,
 				ref abandoned_funding_txo,
 				ref channel_type,
-				ref contributed_inputs,
-				ref contributed_outputs,
 			} => {
 				52u8.write(writer)?;
 				write_tlv_fields!(writer, {
@@ -2388,8 +2393,6 @@ impl Writeable for Event {
 					(5, user_channel_id, required),
 					(7, counterparty_node_id, required),
 					(9, abandoned_funding_txo, option),
-					(11, *contributed_inputs, optional_vec),
-					(13, *contributed_outputs, optional_vec),
 				});
 			},
 			&Event::FundingNeeded { .. } => {
@@ -3015,8 +3018,6 @@ impl MaybeReadable for Event {
 						(5, user_channel_id, required),
 						(7, counterparty_node_id, required),
 						(9, abandoned_funding_txo, option),
-						(11, contributed_inputs, optional_vec),
-						(13, contributed_outputs, optional_vec),
 					});
 
 					Ok(Some(Event::SpliceFailed {
@@ -3025,8 +3026,6 @@ impl MaybeReadable for Event {
 						counterparty_node_id: counterparty_node_id.0.unwrap(),
 						abandoned_funding_txo,
 						channel_type,
-						contributed_inputs: contributed_inputs.unwrap_or_default(),
-						contributed_outputs: contributed_outputs.unwrap_or_default(),
 					}))
 				};
 				f()

lightning/src/ln/channel.rs

@@ -2940,6 +2940,35 @@ pub(crate) enum QuiescentAction {
 	DoNothing,
 }
 
+pub(super) enum QuiescentError {
+	DoNothing,
+	DiscardFunding { inputs: Vec<bitcoin::OutPoint>, outputs: Vec<bitcoin::TxOut> },
+	FailSplice(SpliceFundingFailed),
+}
+
+impl From<QuiescentAction> for QuiescentError {
+	fn from(action: QuiescentAction) -> Self {
+		match action {
+			QuiescentAction::LegacySplice(_) => {
+				debug_assert!(false);
+				QuiescentError::DoNothing
+			},
+			QuiescentAction::Splice { contribution, .. } => {
+				let (contributed_inputs, contributed_outputs) =
+					contribution.into_contributed_inputs_and_outputs();
+				return QuiescentError::FailSplice(SpliceFundingFailed {
+					funding_txo: None,
+					channel_type: None,
+					contributed_inputs,
+					contributed_outputs,
+				});
+			},
+			#[cfg(any(test, fuzzing))]
+			QuiescentAction::DoNothing => QuiescentError::DoNothing,
+		}
+	}
+}
+
 pub(crate) enum StfuResponse {
 	Stfu(msgs::Stfu),
 	SpliceInit(msgs::SpliceInit),
@@ -11907,9 +11936,30 @@ where
 
 	pub fn funding_contributed<L: Logger>(
 		&mut self, contribution: FundingContribution, locktime: LockTime, logger: &L,
-	) -> Result<Option<msgs::Stfu>, SpliceFundingFailed> {
+	) -> Result<Option<msgs::Stfu>, QuiescentError> {
 		debug_assert!(contribution.is_splice());
 
+		if let Some(QuiescentAction::Splice { contribution: existing, .. }) = &self.quiescent_action
+		{
+			let (new_inputs, new_outputs) = contribution.into_contributed_inputs_and_outputs();
+
+			// Filter out inputs/outputs already in the existing contribution
+			let inputs: Vec<_> = new_inputs
+				.into_iter()
+				.filter(|input| !existing.contributed_inputs().any(|e| e == *input))
+				.collect();
+			let outputs: Vec<_> = new_outputs
+				.into_iter()
+				.filter(|output| !existing.contributed_outputs().any(|e| *e == *output))
+				.collect();
+
+			if inputs.is_empty() && outputs.is_empty() {
+				return Err(QuiescentError::DoNothing);
+			}
+
+			return Err(QuiescentError::DiscardFunding { inputs, outputs });
+		}
+
 		if let Err(e) = contribution.net_value().and_then(|our_funding_contribution| {
 			// For splice-out, our_funding_contribution is adjusted to cover fees if there
 			// aren't any inputs.
@@ -11920,37 +11970,15 @@ where
 			let (contributed_inputs, contributed_outputs) =
 				contribution.into_contributed_inputs_and_outputs();
 
-			return Err(SpliceFundingFailed {
+			return Err(QuiescentError::FailSplice(SpliceFundingFailed {
 				funding_txo: None,
 				channel_type: None,
 				contributed_inputs,
 				contributed_outputs,
-			});
+			}));
 		}
 
-		self.propose_quiescence(logger, QuiescentAction::Splice { contribution, locktime }).map_err(
-			|action| {
-				// FIXME: Any better way to do this?
-				if let QuiescentAction::Splice { contribution, .. } = action {
-					let (contributed_inputs, contributed_outputs) =
-						contribution.into_contributed_inputs_and_outputs();
-					SpliceFundingFailed {
-						funding_txo: None,
-						channel_type: None,
-						contributed_inputs,
-						contributed_outputs,
-					}
-				} else {
-					debug_assert!(false);
-					SpliceFundingFailed {
-						funding_txo: None,
-						channel_type: None,
-						contributed_inputs: vec![],
-						contributed_outputs: vec![],
-					}
-				}
-			},
-		)
+		self.propose_quiescence(logger, QuiescentAction::Splice { contribution, locktime })
 	}
 
 	fn send_splice_init(&mut self, instructions: SpliceInstructions) -> msgs::SpliceInit {
@@ -13069,19 +13097,19 @@ where
 	#[rustfmt::skip]
 	pub fn propose_quiescence<L: Logger>(
 		&mut self, logger: &L, action: QuiescentAction,
-	) -> Result<Option<msgs::Stfu>, QuiescentAction> {
+	) -> Result<Option<msgs::Stfu>, QuiescentError> {
 		log_debug!(logger, "Attempting to initiate quiescence");
 
 		if !self.context.is_usable() {
 			log_debug!(logger, "Channel is not in a usable state to propose quiescence");
-			return Err(action);
+			return Err(action.into());
 		}
 		if self.quiescent_action.is_some() {
 			log_debug!(
 				logger,
 				"Channel already has a pending quiescent action and cannot start another",
 			);
-			return Err(action);
+			return Err(action.into());
 		}
 
 		self.quiescent_action = Some(action);