Remove dup_htlc_second_reject tests

These tests made sure that when we received a duplicate HTLC with the
same payment hash after receiving the expected amount, we would
automatically fail back the second HTLC while allowing the user to
choose to either claim or fail back the first. This behavior will no
longer be desired when allowing MPPs to overshoot `total_msat`.

Author: alecchendev

lightning/src/ln/functional_tests.rs

@@ -9006,107 +9006,6 @@ fn test_tx_confirmed_skipping_blocks_immediate_broadcast() {
 	do_test_tx_confirmed_skipping_blocks_immediate_broadcast(true);
 }
 
-fn do_test_dup_htlc_second_rejected(test_for_second_fail_panic: bool) {
-	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 _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 10001);
-
-	let payment_params = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV)
-		.with_features(nodes[1].node.invoice_features());
-	let route = get_route!(nodes[0], payment_params, 10_000, TEST_FINAL_CLTV).unwrap();
-
-	let (our_payment_preimage, our_payment_hash, our_payment_secret) = get_payment_preimage_hash!(&nodes[1]);
-
-	{
-		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap();
-		check_added_monitors!(nodes[0], 1);
-		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
-		assert_eq!(events.len(), 1);
-		let mut payment_event = SendEvent::from_event(events.pop().unwrap());
-		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
-		commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
-	}
-	expect_pending_htlcs_forwardable!(nodes[1]);
-	expect_payment_claimable!(nodes[1], our_payment_hash, our_payment_secret, 10_000);
-
-	{
-		// Note that we use a different PaymentId here to allow us to duplicativly pay
-		nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret), PaymentId(our_payment_secret.0)).unwrap();
-		check_added_monitors!(nodes[0], 1);
-		let mut events = nodes[0].node.get_and_clear_pending_msg_events();
-		assert_eq!(events.len(), 1);
-		let mut payment_event = SendEvent::from_event(events.pop().unwrap());
-		nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
-		commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
-		// At this point, nodes[1] would notice it has too much value for the payment. It will
-		// assume the second is a privacy attack (no longer particularly relevant
-		// post-payment_secrets) and fail back the new HTLC. Previously, it'd also have failed back
-		// the first HTLC delivered above.
-	}
-
-	expect_pending_htlcs_forwardable_ignore!(nodes[1]);
-	nodes[1].node.process_pending_htlc_forwards();
-
-	if test_for_second_fail_panic {
-		// Now we go fail back the first HTLC from the user end.
-		nodes[1].node.fail_htlc_backwards(&our_payment_hash);
-
-		let expected_destinations = vec![
-			HTLCDestination::FailedPayment { payment_hash: our_payment_hash },
-			HTLCDestination::FailedPayment { payment_hash: our_payment_hash },
-		];
-		expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1],  expected_destinations);
-		nodes[1].node.process_pending_htlc_forwards();
-
-		check_added_monitors!(nodes[1], 1);
-		let fail_updates_1 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
-		assert_eq!(fail_updates_1.update_fail_htlcs.len(), 2);
-
-		nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates_1.update_fail_htlcs[0]);
-		nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates_1.update_fail_htlcs[1]);
-		commitment_signed_dance!(nodes[0], nodes[1], fail_updates_1.commitment_signed, false);
-
-		let failure_events = nodes[0].node.get_and_clear_pending_events();
-		assert_eq!(failure_events.len(), 4);
-		if let Event::PaymentPathFailed { .. } = failure_events[0] {} else { panic!(); }
-		if let Event::PaymentFailed { .. } = failure_events[1] {} else { panic!(); }
-		if let Event::PaymentPathFailed { .. } = failure_events[2] {} else { panic!(); }
-		if let Event::PaymentFailed { .. } = failure_events[3] {} else { panic!(); }
-	} else {
-		// Let the second HTLC fail and claim the first
-		expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[1], vec![HTLCDestination::FailedPayment { payment_hash: our_payment_hash }]);
-		nodes[1].node.process_pending_htlc_forwards();
-
-		check_added_monitors!(nodes[1], 1);
-		let fail_updates_1 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
-		nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_updates_1.update_fail_htlcs[0]);
-		commitment_signed_dance!(nodes[0], nodes[1], fail_updates_1.commitment_signed, false);
-
-		expect_payment_failed_conditions(&nodes[0], our_payment_hash, true, PaymentFailedConditions::new());
-
-		claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
-	}
-}
-
-#[test]
-fn test_dup_htlc_second_fail_panic() {
-	// Previously, if we received two HTLCs back-to-back, where the second overran the expected
-	// value for the payment, we'd fail back both HTLCs after generating a `PaymentClaimable` event.
-	// Then, if the user failed the second payment, they'd hit a "tried to fail an already failed
-	// HTLC" debug panic. This tests for this behavior, checking that only one HTLC is auto-failed.
-	do_test_dup_htlc_second_rejected(true);
-}
-
-#[test]
-fn test_dup_htlc_second_rejected() {
-	// Test that if we receive a second HTLC for an MPP payment that overruns the payment amount we
-	// simply reject the second HTLC but are still able to claim the first HTLC.
-	do_test_dup_htlc_second_rejected(false);
-}
-
 #[test]
 fn test_inconsistent_mpp_params() {
 	// Test that if we recieve two HTLCs with different payment parameters we fail back the first