Apply MPP receive timeout to keysend payments

Incomplete keysend MPPs skipped the receive timeout path,
allowing partial payments to hold HTLC slots until CLTV
expiry instead of failing after `MPP_TIMEOUT_TICKS`.
Apply the existing `total_mpp_amount_msat` completeness
check to all MPP receives and add a regression test
covering the keysend case.

The timeout logic was originally added only for
invoice-backed MPPs in 2022, and that invoice-only
guard remained when receive-side MPP keysend support
landed in 2023, leaving this gap latent until now.

Co-Authored-By: HAL 9000

Author: tnull

lightning/src/ln/channelmanager.rs

@@ -8878,27 +8878,24 @@ impl<
 						debug_assert!(false);
 						return false;
 					}
-					if let OnionPayload::Invoice { .. } = payment.htlcs[0].onion_payload {
-						// Check if we've received all the parts we need for an MPP (the value of the parts adds to total_msat).
-						// In this case we're not going to handle any timeouts of the parts here.
-						// This condition determining whether the MPP is complete here must match
-						// exactly the condition used in `process_pending_htlc_forwards`.
-						let total_intended_recvd_value =
-							payment.htlcs.iter().map(|h| h.sender_intended_value).sum();
-						let total_mpp_value = payment.onion_fields.total_mpp_amount_msat;
-						if total_mpp_value <= total_intended_recvd_value {
-							return true;
-						} else if payment.htlcs.iter_mut().any(|htlc| {
-							htlc.timer_ticks += 1;
-							return htlc.timer_ticks >= MPP_TIMEOUT_TICKS;
-						}) {
-							let htlcs = payment
-								.htlcs
-								.drain(..)
-								.map(|htlc: ClaimableHTLC| (htlc.prev_hop, *payment_hash));
-							timed_out_mpp_htlcs.extend(htlcs);
-							return false;
-						}
+					// Check if we've received all the parts we need for an MPP.
+					// This condition determining whether the MPP is complete here must match
+					// exactly the condition used in `process_pending_htlc_forwards`.
+					let total_intended_recvd_value =
+						payment.htlcs.iter().map(|h| h.sender_intended_value).sum();
+					let total_mpp_value = payment.onion_fields.total_mpp_amount_msat;
+					if total_mpp_value <= total_intended_recvd_value {
+						return true;
+					} else if payment.htlcs.iter_mut().any(|htlc| {
+						htlc.timer_ticks += 1;
+						return htlc.timer_ticks >= MPP_TIMEOUT_TICKS;
+					}) {
+						let htlcs = payment
+							.htlcs
+							.drain(..)
+							.map(|htlc: ClaimableHTLC| (htlc.prev_hop, *payment_hash));
+						timed_out_mpp_htlcs.extend(htlcs);
+						return false;
 					}
 					true
 				},

lightning/src/ln/payment_tests.rs

@@ -426,12 +426,102 @@ fn do_mpp_receive_timeout(send_partial_mpp: bool) {
 	}
 }
 
+fn do_keysend_mpp_receive_timeout() {
+	let chanmon_cfgs = create_chanmon_cfgs(4);
+	let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
+	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
+
+	let node_a_id = nodes[0].node.get_our_node_id();
+	let node_b_id = nodes[1].node.get_our_node_id();
+	let node_c_id = nodes[2].node.get_our_node_id();
+	let node_d_id = nodes[3].node.get_our_node_id();
+
+	let (chan_1_update, _, _, _) = create_announced_chan_between_nodes(&nodes, 0, 1);
+	let (chan_2_update, _, _, _) = create_announced_chan_between_nodes(&nodes, 0, 2);
+	let (chan_3_update, _, chan_3_id, _) = create_announced_chan_between_nodes(&nodes, 1, 3);
+	let (chan_4_update, _, _, _) = create_announced_chan_between_nodes(&nodes, 2, 3);
+
+	let payment_params = PaymentParameters::for_keysend(node_d_id, TEST_FINAL_CLTV, true);
+	let (mut route, hash, payment_preimage, payment_secret) =
+		get_route_and_payment_hash!(nodes[0], nodes[3], payment_params, 100_000);
+	let path = route.paths[0].clone();
+	route.paths.push(path);
+	route.paths[0].hops[0].pubkey = node_b_id;
+	route.paths[0].hops[0].short_channel_id = chan_1_update.contents.short_channel_id;
+	route.paths[0].hops[1].short_channel_id = chan_3_update.contents.short_channel_id;
+	route.paths[1].hops[0].pubkey = node_c_id;
+	route.paths[1].hops[0].short_channel_id = chan_2_update.contents.short_channel_id;
+	route.paths[1].hops[1].short_channel_id = chan_4_update.contents.short_channel_id;
+	route.route_params.as_mut().unwrap().final_value_msat *= 2;
+
+	// Initiate the MPP keysend and only relay the first half so the payment remains incomplete.
+	let onion = RecipientOnionFields::secret_only(payment_secret, 200_000);
+	let route_params = route.route_params.clone().unwrap();
+	nodes[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
+	nodes[0]
+		.node
+		.send_spontaneous_payment(
+			Some(payment_preimage),
+			onion,
+			PaymentId(hash.0),
+			route_params,
+			Retry::Attempts(0),
+		)
+		.unwrap();
+	check_added_monitors(&nodes[0], 2);
+	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), 2);
+
+	let node_1_msgs = remove_first_msg_event_to_node(&node_b_id, &mut events);
+	let path = &[&nodes[1], &nodes[3]];
+	pass_along_path(&nodes[0], path, 200_000, hash, Some(payment_secret), node_1_msgs, false, None);
+
+	for _ in 0..MPP_TIMEOUT_TICKS {
+		nodes[3].node.timer_tick_occurred();
+	}
+
+	// This should mirror invoice-backed MPP handling: the incomplete keysend MPP should time out
+	// and fail backward instead of remaining claimable until CLTV expiry.
+	let fail = HTLCHandlingFailureType::Receive { payment_hash: hash };
+	expect_and_process_pending_htlcs_and_htlc_handling_failed(&nodes[3], &[fail]);
+
+	let htlc_fail_updates = get_htlc_update_msgs(&nodes[3], &node_b_id);
+	assert_eq!(htlc_fail_updates.update_fail_htlcs.len(), 1);
+	nodes[1].node.handle_update_fail_htlc(node_d_id, &htlc_fail_updates.update_fail_htlcs[0]);
+	check_added_monitors(&nodes[3], 1);
+
+	let commitment = &htlc_fail_updates.commitment_signed;
+	do_commitment_signed_dance(&nodes[1], &nodes[3], commitment, false, false);
+
+	let fail_type =
+		HTLCHandlingFailureType::Forward { node_id: Some(node_d_id), channel_id: chan_3_id };
+	expect_and_process_pending_htlcs_and_htlc_handling_failed(&nodes[1], &[fail_type]);
+
+	let htlc_fail_updates = get_htlc_update_msgs(&nodes[1], &node_a_id);
+	assert_eq!(htlc_fail_updates.update_fail_htlcs.len(), 1);
+	nodes[0].node.handle_update_fail_htlc(node_b_id, &htlc_fail_updates.update_fail_htlcs[0]);
+	check_added_monitors(&nodes[1], 1);
+	let commitment = &htlc_fail_updates.commitment_signed;
+	do_commitment_signed_dance(&nodes[0], &nodes[1], commitment, false, false);
+
+	let mut conditions = PaymentFailedConditions::new()
+		.mpp_parts_remain()
+		.expected_htlc_error_data(LocalHTLCFailureReason::MPPTimeout, &[][..]);
+	expect_payment_failed_conditions(&nodes[0], hash, false, conditions);
+}
+
 #[test]
 fn mpp_receive_timeout() {
 	do_mpp_receive_timeout(true);
 	do_mpp_receive_timeout(false);
 }
 
+#[test]
+fn keysend_mpp_receive_timeout() {
+	do_keysend_mpp_receive_timeout();
+}
+
 #[test]
 fn test_keysend_payments() {
 	do_test_keysend_payments(false);