Filter duplicate inputs/outputs in funding_contributed

When funding_contributed is called with a contribution that has
inputs/outputs already present in an existing pending splice
contribution, filter them out before emitting DiscardFunding.
If all inputs and outputs are duplicates, return DoNothing and
emit no event.

Add helper methods to FundingContribution for iterating over
contributed inputs and outputs to support the filtering logic.

Add test coverage for both the filtering behavior and the DoNothing
path when an identical contribution is provided twice.

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

Author: jkczyz

lightning/src/ln/channel.rs

@@ -11939,9 +11939,24 @@ where
 	) -> Result<Option<msgs::Stfu>, QuiescentError> {
 		debug_assert!(contribution.is_splice());
 
-		if let Some(QuiescentAction::Splice { contribution: _, .. }) = &self.quiescent_action {
-			// TODO(splicing): Filter duplicates
-			let (inputs, outputs) = contribution.into_contributed_inputs_and_outputs();
+		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 });
 		}
 

lightning/src/ln/funding.rs

@@ -308,6 +308,14 @@ impl FundingContribution {
 		self.is_splice
 	}
 
+	pub(super) fn contributed_inputs(&self) -> impl Iterator<Item = OutPoint> + '_ {
+		self.inputs.iter().map(|input| input.utxo.outpoint)
+	}
+
+	pub(super) fn contributed_outputs(&self) -> impl Iterator<Item = &TxOut> + '_ {
+		self.outputs.iter().chain(self.change_output.iter())
+	}
+
 	pub(super) fn into_tx_parts(self) -> (Vec<FundingTxInput>, Vec<TxOut>) {
 		let FundingContribution { inputs, mut outputs, change_output, .. } = self;
 

lightning/src/ln/splicing_tests.rs

@@ -29,9 +29,12 @@ use crate::util::wallet_utils::{WalletSourceSync, WalletSync};
 
 use crate::sync::Arc;
 
+use bitcoin::hashes::Hash;
 use bitcoin::secp256k1::ecdsa::Signature;
 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
-use bitcoin::{Amount, FeeRate, OutPoint as BitcoinOutPoint, ScriptBuf, Transaction, TxOut};
+use bitcoin::{
+	Amount, FeeRate, OutPoint as BitcoinOutPoint, ScriptBuf, Transaction, TxOut, WPubkeyHash,
+};
 
 #[test]
 fn test_splicing_not_supported_api_error() {
@@ -2603,7 +2606,8 @@ fn test_funding_contributed_channel_not_found() {
 #[test]
 fn test_funding_contributed_splice_already_pending() {
 	// Tests that calling funding_contributed when there's already a pending splice
-	// contribution returns Ok(()) but emits a DiscardFunding event for the duplicate.
+	// contribution returns Ok(()) but emits a DiscardFunding event containing only the
+	// inputs/outputs that are NOT already in the existing contribution.
 	let chanmon_cfgs = create_chanmon_cfgs(2);
 	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
@@ -2618,27 +2622,58 @@ fn test_funding_contributed_splice_already_pending() {
 	// Provide enough UTXOs for two contributions
 	provide_utxo_reserves(&nodes, 2, splice_in_amount * 2);
 
-	let contribution = SpliceContribution::splice_in(splice_in_amount);
+	// Use splice_in_and_out with an output so we can test output filtering
+	let first_splice_out = TxOut {
+		value: Amount::from_sat(5_000),
+		script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::from_raw_hash(Hash::all_zeros())),
+	};
+	let first_contribution_spec =
+		SpliceContribution::splice_in_and_out(splice_in_amount, vec![first_splice_out.clone()]);
 	let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64);
 
-	// Initiate splice to get a FundingNeeded event
-	nodes[0].node.splice_channel(&channel_id, &node_id_1, contribution, feerate).unwrap();
+	// Initiate first splice to get a FundingNeeded event
+	nodes[0]
+		.node
+		.splice_channel(&channel_id, &node_id_1, first_contribution_spec, feerate)
+		.unwrap();
 
 	let event = get_event!(nodes[0], Event::FundingNeeded);
-	let funding_template = match event {
+	let first_funding_template = match event {
 		Event::FundingNeeded { funding_template, .. } => funding_template,
 		_ => panic!("Expected Event::FundingNeeded"),
 	};
 
 	// Build the first contribution
 	let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger);
-	let first_contribution = funding_template.clone().build_sync(&wallet).unwrap();
+	let first_contribution = first_funding_template.build_sync(&wallet).unwrap();
 
-	// Clear UTXOs and add fresh ones for the second contribution
+	// Initiate a second splice with a DIFFERENT output to test that different outputs
+	// are included in DiscardFunding (not filtered out)
+	let second_splice_out = TxOut {
+		value: Amount::from_sat(6_000), // Different amount
+		script_pubkey: ScriptBuf::new_p2wpkh(&WPubkeyHash::from_raw_hash(Hash::all_zeros())),
+	};
+	let second_contribution_spec =
+		SpliceContribution::splice_in_and_out(splice_in_amount, vec![second_splice_out.clone()]);
+
+	// Clear UTXOs and add a LARGER one for the second contribution to ensure
+	// the change output will be different from the first contribution's change
 	nodes[0].wallet_source.clear_utxos();
-	provide_utxo_reserves(&nodes, 1, splice_in_amount * 2);
+	provide_utxo_reserves(&nodes, 1, splice_in_amount * 3);
+
+	nodes[0]
+		.node
+		.splice_channel(&channel_id, &node_id_1, second_contribution_spec, feerate)
+		.unwrap();
+
+	let event = get_event!(nodes[0], Event::FundingNeeded);
+	let second_funding_template = match event {
+		Event::FundingNeeded { funding_template, .. } => funding_template,
+		_ => panic!("Expected Event::FundingNeeded"),
+	};
+
 	let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger);
-	let second_contribution = funding_template.build_sync(&wallet).unwrap();
+	let second_contribution = second_funding_template.build_sync(&wallet).unwrap();
 
 	// First funding_contributed - this sets up the quiescent action
 	nodes[0].node.funding_contributed(&channel_id, &node_id_1, first_contribution, None).unwrap();
@@ -2647,18 +2682,90 @@ fn test_funding_contributed_splice_already_pending() {
 	let _ = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1);
 
 	// Second funding_contributed with a different contribution - this should trigger
-	// DiscardFunding because there's already a pending quiescent action (splice contribution)
-	let result = nodes[0].node.funding_contributed(
-		&channel_id,
-		&node_id_1,
-		second_contribution.clone(),
-		None,
-	);
+	// DiscardFunding because there's already a pending quiescent action (splice contribution).
+	// Only inputs/outputs NOT in the existing contribution should be discarded.
+	let (expected_inputs, expected_outputs) =
+		second_contribution.clone().into_contributed_inputs_and_outputs();
+	let result =
+		nodes[0].node.funding_contributed(&channel_id, &node_id_1, second_contribution, None);
+
+	// Returns Ok(()) but emits DiscardFunding for the non-duplicate parts of the second contribution
+	assert!(result.is_ok());
+
+	// The second contribution has different outputs (second_splice_out differs from first_splice_out),
+	// so those outputs should NOT be filtered out - they should appear in DiscardFunding.
+	let events = nodes[0].node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match &events[0] {
+		Event::DiscardFunding { channel_id: event_channel_id, funding_info } => {
+			assert_eq!(event_channel_id, &channel_id);
+			if let FundingInfo::Contribution { inputs, outputs } = funding_info {
+				// The input is different, so it should be in the discard event
+				assert_eq!(*inputs, expected_inputs);
+				// The splice-out output is different (6000 vs 5000), so it should be in discard event
+				assert!(expected_outputs.contains(&second_splice_out));
+				assert!(!expected_outputs.contains(&first_splice_out));
+				// The different outputs should NOT be filtered out
+				assert_eq!(*outputs, expected_outputs);
+			} else {
+				panic!("Expected FundingInfo::Contribution");
+			}
+		},
+		_ => panic!("Expected DiscardFunding event"),
+	}
+}
 
-	// Returns Ok(()) but emits DiscardFunding for the second contribution
+#[test]
+fn test_funding_contributed_duplicate_contribution_no_event() {
+	// Tests that calling funding_contributed with the exact same contribution twice
+	// returns Ok(()) but emits no events on the second call (DoNothing path).
+	// This tests the case where all inputs/outputs in the second contribution
+	// are already present in the existing contribution.
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let node_id_1 = nodes[1].node.get_our_node_id();
+
+	let (_, _, channel_id, _) =
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0);
+
+	let splice_in_amount = Amount::from_sat(20_000);
+	provide_utxo_reserves(&nodes, 1, splice_in_amount * 2);
+
+	let contribution_spec = SpliceContribution::splice_in(splice_in_amount);
+	let feerate = FeeRate::from_sat_per_kwu(FEERATE_FLOOR_SATS_PER_KW as u64);
+
+	// Initiate splice to get a FundingNeeded event
+	nodes[0].node.splice_channel(&channel_id, &node_id_1, contribution_spec, feerate).unwrap();
+
+	let event = get_event!(nodes[0], Event::FundingNeeded);
+	let funding_template = match event {
+		Event::FundingNeeded { funding_template, .. } => funding_template,
+		_ => panic!("Expected Event::FundingNeeded"),
+	};
+
+	// Build the contribution
+	let wallet = WalletSync::new(Arc::clone(&nodes[0].wallet_source), nodes[0].logger);
+	let contribution = funding_template.build_sync(&wallet).unwrap();
+
+	// First funding_contributed - this sets up the quiescent action
+	nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution.clone(), None).unwrap();
+
+	// Drain the pending stfu message
+	let _ = get_event_msg!(nodes[0], MessageSendEvent::SendStfu, node_id_1);
+
+	// Second funding_contributed with the SAME contribution (same inputs/outputs)
+	// This should trigger the DoNothing path because all inputs/outputs are duplicates
+	let result = nodes[0].node.funding_contributed(&channel_id, &node_id_1, contribution, None);
+
+	// Returns Ok(()) and emits NO events (DoNothing path)
 	assert!(result.is_ok());
 
-	expect_discard_funding_event(&nodes[0], &channel_id, second_contribution);
+	// Verify no events were emitted - the duplicate contribution is silently ignored
+	let events = nodes[0].node.get_and_clear_pending_events();
+	assert!(events.is_empty(), "Expected no events for duplicate contribution, got {:?}", events);
 }
 
 #[test]