f - reject mpp keysend during receive instead of upon claim

Author: alecchendev

lightning/src/ln/channelmanager.rs

@@ -3577,6 +3577,10 @@ where
 													purpose: purpose.clone(), htlcs: Vec::new(), onion_fields: None,
 												}
 											});
+										if !self.default_configuration.accept_mpp_keysend && is_keysend && !claimable_payment.htlcs.is_empty() {
+											log_trace!(self.logger, "Failing new keysend HTLC with payment_hash {} as we already had an existing keysend HTLC with the same payment hash and our config states we don't accept MPP keysend", log_bytes!(payment_hash.0));
+											fail_htlc!(claimable_htlc, payment_hash);
+										}
 										if purpose != claimable_payment.purpose {
 											let log_keysend = |keysend| if keysend { "keysend" } else { "non-keysend" };
 											log_trace!(self.logger, "Failing new {} HTLC with payment_hash {} as we already had an existing {} HTLC with the same payment hash", log_keysend(is_keysend), log_bytes!(payment_hash.0), log_keysend(!is_keysend));
@@ -4233,15 +4237,6 @@ where
 				break;
 			}
 			expected_amt_msat = htlc.total_value_received;
-
-			if let OnionPayload::Spontaneous(_) = &htlc.onion_payload {
-				if !self.default_configuration.accept_mpp_keysend && sources.len() != 1 {
-					log_info!(self.logger, "Rejecting a received MPP spontaneous payment since our config states we don't accept them.");
-					valid_mpp = false;
-					break;
-				}
-			}
-
 			claimable_amt_msat += htlc.value;
 		}
 		mem::drop(per_peer_state);

lightning/src/ln/functional_tests.rs

@@ -8201,10 +8201,10 @@ fn do_test_mpp_keysend(accept_mpp_keysend: bool) {
 	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, Some(mpp_keysend_config)]);
 	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
 
-	create_announced_chan_between_nodes(&nodes, 0, 1).0.contents.short_channel_id;
-	create_announced_chan_between_nodes(&nodes, 0, 2).0.contents.short_channel_id;
-	create_announced_chan_between_nodes(&nodes, 1, 3).0.contents.short_channel_id;
-	create_announced_chan_between_nodes(&nodes, 2, 3).0.contents.short_channel_id;
+	create_announced_chan_between_nodes(&nodes, 0, 1);
+	create_announced_chan_between_nodes(&nodes, 0, 2);
+	create_announced_chan_between_nodes(&nodes, 1, 3);
+	let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
 	let network_graph = nodes[0].network_graph.clone();
 
 	let payer_pubkey = nodes[0].node.get_our_node_id();
@@ -8228,14 +8228,58 @@ fn do_test_mpp_keysend(accept_mpp_keysend: bool) {
 	let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]];
 	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
 	assert_eq!(events.len(), 2);
-	for (path_idx, expected_path) in expected_route.iter().enumerate() {
-		let ev = remove_first_msg_event_to_node(&expected_path[0].node.get_our_node_id(), &mut events);
-		let expect_payment = path_idx == expected_route.len() - 1;
-		pass_along_path(&nodes[0], *expected_path, recv_value, payment_hash.clone(),
-			Some(payment_secret), ev, expect_payment, Some(payment_preimage));
-	}
 
-	claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
+	let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
+	pass_along_path(&nodes[0], expected_route[0], recv_value, payment_hash.clone(),
+		Some(payment_secret), ev.clone(), false, Some(payment_preimage));
+
+	if accept_mpp_keysend {
+		let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
+		pass_along_path(&nodes[0], expected_route[1], recv_value, payment_hash.clone(),
+			Some(payment_secret), ev.clone(), true, Some(payment_preimage));
+		claim_payment_along_route(&nodes[0], expected_route, false, payment_preimage);
+	} else {
+		let ev = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut events);
+		let mut payment_event = SendEvent::from_event(ev.clone());
+
+		assert_eq!(nodes[2].node.get_our_node_id(), payment_event.node_id);
+
+		nodes[2].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
+		commitment_signed_dance!(nodes[2], nodes[0], payment_event.commitment_msg, false);
+
+		expect_pending_htlcs_forwardable!(nodes[2]);
+		check_added_monitors!(nodes[2], 1);
+
+		let mut events_2 = nodes[2].node.get_and_clear_pending_msg_events();
+		assert_eq!(events_2.len(), 1);
+		payment_event = SendEvent::from_event(events_2.remove(0));
+
+		nodes[3].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &payment_event.msgs[0]);
+		check_added_monitors!(nodes[3], 0);
+		commitment_signed_dance!(nodes[3], nodes[2], payment_event.commitment_msg, false);
+
+		expect_pending_htlcs_forwardable_ignore!(nodes[3]);
+		nodes[3].node.process_pending_htlc_forwards();
+		expect_pending_htlcs_forwardable_and_htlc_handling_failed_ignore!(nodes[3],
+			vec![HTLCDestination::FailedPayment { payment_hash: payment_hash }]);
+		nodes[3].node.process_pending_htlc_forwards();
+
+		check_added_monitors!(nodes[3], 1);
+
+		let fail_updates_1 = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
+		nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &fail_updates_1.update_fail_htlcs[0]);
+		commitment_signed_dance!(nodes[2], nodes[3], fail_updates_1.commitment_signed, false);
+
+		expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[2],
+			vec![HTLCDestination::NextHopChannel { node_id: Some(nodes[3].node.get_our_node_id()), channel_id: chan_2_3.2 }]);
+		check_added_monitors!(nodes[2], 1);
+
+		let fail_updates_2 = get_htlc_update_msgs!(nodes[2], nodes[0].node.get_our_node_id());
+		nodes[0].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &fail_updates_2.update_fail_htlcs[0]);
+		commitment_signed_dance!(nodes[0], nodes[2], fail_updates_2.commitment_signed, false);
+
+		expect_payment_failed_conditions(&nodes[0], payment_hash, true, PaymentFailedConditions::new().mpp_parts_remain());
+	}
 }
 
 #[test]
@@ -8244,7 +8288,6 @@ fn test_mpp_keysend() {
 }
 
 #[test]
-#[should_panic]
 fn test_mpp_keysend_fail() {
 	do_test_mpp_keysend(false);
 }