Support receiving, validating, and claiming MPP keysend

alecchendev · alecchendev · commit 40d4bd0f03a6 · 2023-05-01T23:21:09.000-05:00
diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
@@ -3492,9 +3492,13 @@ where
 								}
 
 								macro_rules! check_total_value {
-									($payment_data: expr, $payment_preimage: expr) => {{
+									($payment_data: expr, $payment_preimage: expr, $is_keysend: expr) => {{
 										let mut payment_claimable_generated = false;
-										let purpose = || {
+										let purpose = if $is_keysend {
+											events::PaymentPurpose::SpontaneousPayment(
+												$payment_preimage.expect("Should never call check_total_value with $is_keysend as true but no preimage")
+											)
+										} else {
 											events::PaymentPurpose::InvoicePayment {
 												payment_preimage: $payment_preimage,
 												payment_secret: $payment_data.payment_secret,
@@ -3510,7 +3514,7 @@ where
 											.or_insert_with(|| {
 												committed_to_claimable = true;
 												ClaimablePayment {
-													purpose: purpose(), htlcs: Vec::new(), onion_fields: None,
+													purpose: purpose.clone(), htlcs: Vec::new(), onion_fields: None,
 												}
 											});
 										if let Some(earlier_fields) = &mut claimable_payment.onion_fields {
@@ -3521,7 +3525,7 @@ where
 											claimable_payment.onion_fields = Some(onion_fields);
 										}
 										let ref mut htlcs = &mut claimable_payment.htlcs;
-										if htlcs.len() == 1 {
+										if !htlcs.is_empty() && !$is_keysend {
 											if let OnionPayload::Spontaneous(_) = htlcs[0].onion_payload {
 												log_trace!(self.logger, "Failing new HTLC with payment_hash {} as we already had an existing keysend HTLC with the same payment hash", log_bytes!(payment_hash.0));
 												fail_htlc!(claimable_htlc, payment_hash);
@@ -3532,17 +3536,12 @@ where
 										for htlc in htlcs.iter() {
 											total_value += htlc.sender_intended_value;
 											earliest_expiry = cmp::min(earliest_expiry, htlc.cltv_expiry);
-											match &htlc.onion_payload {
-												OnionPayload::Invoice { .. } => {
-													if htlc.total_msat != $payment_data.total_msat {
-														log_trace!(self.logger, "Failing HTLCs with payment_hash {} as the HTLCs had inconsistent total values (eg {} and {})",
-															log_bytes!(payment_hash.0), $payment_data.total_msat, htlc.total_msat);
-														total_value = msgs::MAX_VALUE_MSAT;
-													}
-													if total_value >= msgs::MAX_VALUE_MSAT { break; }
-												},
-												_ => unreachable!(),
+											if htlc.total_msat != $payment_data.total_msat {
+												log_trace!(self.logger, "Failing HTLCs with payment_hash {} as the HTLCs had inconsistent total values (eg {} and {})",
+													log_bytes!(payment_hash.0), $payment_data.total_msat, htlc.total_msat);
+												total_value = msgs::MAX_VALUE_MSAT;
 											}
+											if total_value >= msgs::MAX_VALUE_MSAT { break; }
 										}
 										// The condition determining whether an MPP is complete must
 										// match exactly the condition used in `timer_tick_occurred`
@@ -3563,7 +3562,7 @@ where
 											new_events.push(events::Event::PaymentClaimable {
 												receiver_node_id: Some(receiver_node_id),
 												payment_hash,
-												purpose: purpose(),
+												purpose,
 												amount_msat,
 												via_channel_id: Some(prev_channel_id),
 												via_user_channel_id: Some(prev_user_channel_id),
@@ -3611,40 +3610,44 @@ where
 														fail_htlc!(claimable_htlc, payment_hash);
 													}
 												}
-												check_total_value!(payment_data, payment_preimage);
+												check_total_value!(payment_data, payment_preimage, false);
 											},
 											OnionPayload::Spontaneous(preimage) => {
-												let mut claimable_payments = self.claimable_payments.lock().unwrap();
-												if claimable_payments.pending_claiming_payments.contains_key(&payment_hash) {
-													fail_htlc!(claimable_htlc, payment_hash);
-												}
-												match claimable_payments.claimable_payments.entry(payment_hash) {
-													hash_map::Entry::Vacant(e) => {
-														let amount_msat = claimable_htlc.value;
-														claimable_htlc.total_value_received = Some(amount_msat);
-														let claim_deadline = Some(claimable_htlc.cltv_expiry - HTLC_FAIL_BACK_BUFFER);
-														let purpose = events::PaymentPurpose::SpontaneousPayment(preimage);
-														e.insert(ClaimablePayment {
-															purpose: purpose.clone(),
-															onion_fields: Some(onion_fields.clone()),
-															htlcs: vec![claimable_htlc],
-														});
-														let prev_channel_id = prev_funding_outpoint.to_channel_id();
-														new_events.push(events::Event::PaymentClaimable {
-															receiver_node_id: Some(receiver_node_id),
-															payment_hash,
-															amount_msat,
-															purpose,
-															via_channel_id: Some(prev_channel_id),
-															via_user_channel_id: Some(prev_user_channel_id),
-															claim_deadline,
-															onion_fields: Some(onion_fields),
-														});
-													},
-													hash_map::Entry::Occupied(_) => {
-														log_trace!(self.logger, "Failing new keysend HTLC with payment_hash {} for a duplicative payment hash", log_bytes!(payment_hash.0));
+												if let Some(payment_data) = payment_data {
+													check_total_value!(payment_data, Some(preimage), true);
+												} else {
+													let mut claimable_payments = self.claimable_payments.lock().unwrap();
+													if claimable_payments.pending_claiming_payments.contains_key(&payment_hash) {
 														fail_htlc!(claimable_htlc, payment_hash);
 													}
+													match claimable_payments.claimable_payments.entry(payment_hash) {
+														hash_map::Entry::Vacant(e) => {
+															let amount_msat = claimable_htlc.value;
+															claimable_htlc.total_value_received = Some(amount_msat);
+															let claim_deadline = Some(claimable_htlc.cltv_expiry - HTLC_FAIL_BACK_BUFFER);
+															let purpose = events::PaymentPurpose::SpontaneousPayment(preimage);
+															e.insert(ClaimablePayment {
+																purpose: purpose.clone(),
+																onion_fields: Some(onion_fields.clone()),
+																htlcs: vec![claimable_htlc],
+															});
+															let prev_channel_id = prev_funding_outpoint.to_channel_id();
+															new_events.push(events::Event::PaymentClaimable {
+																receiver_node_id: Some(receiver_node_id),
+																payment_hash,
+																amount_msat,
+																purpose,
+																via_channel_id: Some(prev_channel_id),
+																via_user_channel_id: Some(prev_user_channel_id),
+																claim_deadline,
+																onion_fields: Some(onion_fields),
+															});
+														},
+														hash_map::Entry::Occupied(_) => {
+															log_trace!(self.logger, "Failing new keysend HTLC with payment_hash {} for a duplicative payment hash", log_bytes!(payment_hash.0));
+															fail_htlc!(claimable_htlc, payment_hash);
+														}
+													}
 												}
 											}
 										}
@@ -3663,7 +3666,7 @@ where
 												log_bytes!(payment_hash.0), payment_data.total_msat, inbound_payment.get().min_value_msat.unwrap());
 											fail_htlc!(claimable_htlc, payment_hash);
 										} else {
-											let payment_claimable_generated = check_total_value!(payment_data, inbound_payment.get().payment_preimage);
+											let payment_claimable_generated = check_total_value!(payment_data, inbound_payment.get().payment_preimage, false);
 											if payment_claimable_generated {
 												inbound_payment.remove_entry();
 											}
@@ -4138,12 +4141,16 @@ where
 	/// event matches your expectation. If you fail to do so and call this method, you may provide
 	/// the sender "proof-of-payment" when they did not fulfill the full expected payment.
 	///
+	/// To accept multi-part keysend payments you must set [`UserConfig::accept_mpp_keysend`] to
+	/// true.
+	///
 	/// [`Event::PaymentClaimable`]: crate::events::Event::PaymentClaimable
 	/// [`Event::PaymentClaimable::claim_deadline`]: crate::events::Event::PaymentClaimable::claim_deadline
 	/// [`Event::PaymentClaimed`]: crate::events::Event::PaymentClaimed
 	/// [`process_pending_events`]: EventsProvider::process_pending_events
 	/// [`create_inbound_payment`]: Self::create_inbound_payment
 	/// [`create_inbound_payment_for_hash`]: Self::create_inbound_payment_for_hash
+	/// [`UserConfig::accept_mpp_keysend`]: crate::util::config::UserConfig::accept_mpp_keysend
 	pub fn claim_funds(&self, payment_preimage: PaymentPreimage) {
 		let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0).into_inner());
 
@@ -4204,9 +4211,9 @@ where
 			expected_amt_msat = htlc.total_value_received;
 
 			if let OnionPayload::Spontaneous(_) = &htlc.onion_payload {
-				// We don't currently support MPP for spontaneous payments, so just check
+				// If the user chooses not to support MPP for spontaneous payments, just check
 				// that there's one payment here and move on.
-				if sources.len() != 1 {
+				if !self.default_configuration.accept_mpp_keysend && sources.len() != 1 {
 					log_error!(self.logger, "Somehow ended up with an MPP spontaneous payment - this should not be reachable!");
 					debug_assert!(false);
 					valid_mpp = false;
diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs
@@ -2074,7 +2074,7 @@ pub fn do_pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_p
 							},
 							PaymentPurpose::SpontaneousPayment(payment_preimage) => {
 								assert_eq!(expected_preimage.unwrap(), *payment_preimage);
-								assert!(our_payment_secret.is_none());
+								assert_eq!(our_payment_secret, onion_fields.as_ref().unwrap().payment_secret);
 							},
 						}
 						assert_eq!(*amount_msat, recv_value);
diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs
@@ -27,7 +27,7 @@ use crate::ln::{chan_utils, onion_utils};
 use crate::ln::chan_utils::{OFFERED_HTLC_SCRIPT_WEIGHT, htlc_success_tx_weight, htlc_timeout_tx_weight, HTLCOutputInCommitment};
 use crate::routing::gossip::{NetworkGraph, NetworkUpdate};
 use crate::routing::router::{Path, PaymentParameters, Route, RouteHop, RouteParameters, find_route, get_route};
-use crate::ln::features::{ChannelFeatures, NodeFeatures};
+use crate::ln::features::{ChannelFeatures, NodeFeatures, InvoiceFeatures};
 use crate::ln::msgs;
 use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
 use crate::util::enforcing_trait_impls::EnforcingSigner;
@@ -8215,6 +8215,67 @@ fn test_simple_mpp() {
 	claim_payment_along_route(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage);
 }
 
+fn do_test_mpp_keysend(accept_mpp_keysend: bool) {
+	let mut mpp_keysend_config = test_default_channel_config();
+	mpp_keysend_config.accept_mpp_keysend = accept_mpp_keysend;
+	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, 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;
+	let network_graph = nodes[0].network_graph.clone();
+
+	let payer_pubkey = nodes[0].node.get_our_node_id();
+	let payee_pubkey = nodes[3].node.get_our_node_id();
+	let recv_value = 15_000_000;
+	let mut invoice_features = InvoiceFeatures::for_keysend();
+	invoice_features.set_basic_mpp_optional();
+	let route_params = RouteParameters {
+		payment_params: PaymentParameters::from_node_id(payee_pubkey, 40).with_features(invoice_features),
+		// Approxiamating the amount to make the router use MPP is not reliable in
+		// case those thresholds change, but helpful to test where the router may
+		// block mpp keysend
+		final_value_msat: recv_value,
+	};
+	let scorer = test_utils::TestScorer::new();
+	let random_seed_bytes = chanmon_cfgs[0].keys_manager.get_secure_random_bytes();
+	let route = find_route(&payer_pubkey, &route_params, &network_graph, None, nodes[0].logger,
+		&scorer, &random_seed_bytes).unwrap();
+
+	let payment_preimage = PaymentPreimage([42; 32]);
+	let payment_secret = PaymentSecret(payment_preimage.0);
+	let payment_hash = nodes[0].node.send_spontaneous_payment(&route, Some(payment_preimage),
+		RecipientOnionFields::spontaneous_empty(), PaymentId(payment_preimage.0)).unwrap();
+	check_added_monitors!(nodes[0], 2);
+
+	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);
+}
+
+#[test]
+fn test_mpp_keysend() {
+	do_test_mpp_keysend(true);
+}
+
+#[test]
+#[should_panic]
+fn test_mpp_keysend_fail() {
+	do_test_mpp_keysend(false);
+}
+
 #[test]
 fn test_preimage_storage() {
 	// Simple test of payment preimage storage allowing no client-side storage to claim payments

Original file line number	Diff line number	Diff line change
`@@ -2074,7 +2074,7 @@ pub fn do_pass_along_path<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_p`
`2074`	`2074`	`},`
`2075`	`2075`	`PaymentPurpose::SpontaneousPayment(payment_preimage) => {`
`2076`	`2076`	`assert_eq!(expected_preimage.unwrap(), *payment_preimage);`
`2077`		`- assert!(our_payment_secret.is_none());`
	`2077`	`+ assert_eq!(our_payment_secret, onion_fields.as_ref().unwrap().payment_secret);`
`2078`	`2078`	`},`
`2079`	`2079`	`}`
`2080`	`2080`	`assert_eq!(*amount_msat, recv_value);`