Merge pull request #4388 from jkczyz/2026-02-splice-discard-funding

Split `DiscardFunding` from `SpliceFailed` event

Author: TheBlueMatt

lightning/src/events/mod.rs

@@ -77,6 +77,13 @@ pub enum FundingInfo {
 		/// The outpoint of the funding
 		outpoint: transaction::OutPoint,
 	},
+	/// The contributions used 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,
@@ -85,6 +92,10 @@ impl_writeable_tlv_based_enum!(FundingInfo,
 	},
 	(1, OutPoint) => {
 		(1, outpoint, required)
+	},
+	(2, Contribution) => {
+		(1, inputs, optional_vec),
+		(3, outputs, optional_vec),
 	}
 );
 
@@ -1561,10 +1572,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.
@@ -2326,8 +2333,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, {
@@ -2336,8 +2341,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),
 				});
 			},
 			// Note that, going forward, all new events must only write data inside of
@@ -2965,8 +2968,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 {
@@ -2975,8 +2976,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

@@ -3050,6 +3050,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, feature = "_test_utils"))]
+			QuiescentAction::DoNothing => QuiescentError::DoNothing,
+		}
+	}
+}
+
 pub(crate) enum StfuResponse {
 	Stfu(msgs::Stfu),
 	SpliceInit(msgs::SpliceInit),
@@ -6833,11 +6862,16 @@ impl FundingNegotiationContext {
 		(contributed_inputs, contributed_outputs)
 	}
 
+	fn contributed_inputs(&self) -> impl Iterator<Item = bitcoin::OutPoint> + '_ {
+		self.our_funding_inputs.iter().map(|input| input.utxo.outpoint)
+	}
+
+	fn contributed_outputs(&self) -> impl Iterator<Item = &TxOut> + '_ {
+		self.our_funding_outputs.iter()
+	}
+
 	fn to_contributed_inputs_and_outputs(&self) -> (Vec<bitcoin::OutPoint>, Vec<TxOut>) {
-		let contributed_inputs =
-			self.our_funding_inputs.iter().map(|input| input.utxo.outpoint).collect();
-		let contributed_outputs = self.our_funding_outputs.clone();
-		(contributed_inputs, contributed_outputs)
+		(self.contributed_inputs().collect(), self.contributed_outputs().cloned().collect())
 	}
 }
 
@@ -12210,9 +12244,58 @@ 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
+		{
+			return match contribution.into_unique_contributions(
+				existing.contributed_inputs(),
+				existing.contributed_outputs(),
+			) {
+				None => Err(QuiescentError::DoNothing),
+				Some((inputs, outputs)) => Err(QuiescentError::DiscardFunding { inputs, outputs }),
+			};
+		}
+
+		let initiated_funding_negotiation = self
+			.pending_splice
+			.as_ref()
+			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
+			.filter(|funding_negotiation| funding_negotiation.is_initiator());
+
+		if let Some(funding_negotiation) = initiated_funding_negotiation {
+			let unique_contributions = match funding_negotiation {
+				FundingNegotiation::AwaitingAck { context, .. } => contribution
+					.into_unique_contributions(
+						context.contributed_inputs(),
+						context.contributed_outputs(),
+					),
+				FundingNegotiation::ConstructingTransaction {
+					interactive_tx_constructor, ..
+				} => contribution.into_unique_contributions(
+					interactive_tx_constructor.contributed_inputs(),
+					interactive_tx_constructor.contributed_outputs(),
+				),
+				FundingNegotiation::AwaitingSignatures { .. } => {
+					let session = self
+						.context
+						.interactive_tx_signing_session
+						.as_ref()
+						.expect("pending splice awaiting signatures");
+					contribution.into_unique_contributions(
+						session.contributed_inputs(),
+						session.contributed_outputs(),
+					)
+				},
+			};
+
+			return match unique_contributions {
+				None => Err(QuiescentError::DoNothing),
+				Some((inputs, outputs)) => Err(QuiescentError::DiscardFunding { inputs, outputs }),
+			};
+		}
+
 		if let Err(e) = contribution.validate().and_then(|()| {
 			// For splice-out, our_funding_contribution is adjusted to cover fees if there
 			// aren't any inputs.
@@ -12224,37 +12307,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 {
@@ -13377,19 +13438,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());
 		}
 		// Since we don't have a pending quiescent action, we should never be in a state where we
 		// sent `stfu` without already having become quiescent.