Move blinded keysend tests into new async_payments_tests.rs

Blinded keysend is only planned to be supported in the async payments context.

Author: valentinewallace

lightning/src/ln/async_payments_tests.rs

@@ -8,11 +8,16 @@
 // licenses.
 
 use crate::blinded_path::message::{MessageContext, OffersContext};
-use crate::events::{Event, MessageSendEventsProvider, PaymentFailureReason};
-use crate::ln::channelmanager::PaymentId;
+use crate::events::{Event, HTLCDestination, MessageSendEventsProvider, PaymentFailureReason};
+use crate::ln::blinded_payment_tests::{blinded_payment_path, get_blinded_route_parameters};
+use crate::ln::channelmanager;
+use crate::ln::channelmanager::{PaymentId, RecipientOnionFields};
 use crate::ln::functional_test_utils::*;
+use crate::ln::inbound_payment;
+use crate::ln::msgs::ChannelMessageHandler;
 use crate::ln::msgs::OnionMessageHandler;
 use crate::ln::offers_tests;
+use crate::ln::onion_utils::INVALID_ONION_BLINDING;
 use crate::ln::outbound_payment::Retry;
 use crate::offers::nonce::Nonce;
 use crate::onion_message::async_payments::{
@@ -22,14 +27,251 @@ use crate::onion_message::messenger::{Destination, MessageRouter, MessageSendIns
 use crate::onion_message::offers::OffersMessage;
 use crate::onion_message::packet::ParsedOnionMessageContents;
 use crate::prelude::*;
+use crate::routing::router::{PaymentParameters, RouteParameters};
+use crate::sign::NodeSigner;
 use crate::types::features::Bolt12InvoiceFeatures;
+use crate::types::payment::{PaymentPreimage, PaymentSecret};
+use crate::util::config::UserConfig;
 use bitcoin::secp256k1::Secp256k1;
 
 use core::convert::Infallible;
 use core::time::Duration;
 
 #[test]
-#[cfg(async_payments)]
+fn blinded_keysend() {
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+	let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
+	let chan_upd_1_2 =
+		create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
+
+	let inbound_payment_key = nodes[2].keys_manager.get_inbound_payment_key();
+	let payment_secret = inbound_payment::create_for_spontaneous_payment(
+		&inbound_payment_key,
+		None,
+		u32::MAX,
+		nodes[2].node.duration_since_epoch().as_secs(),
+		None,
+	)
+	.unwrap();
+
+	let amt_msat = 5000;
+	let keysend_preimage = PaymentPreimage([42; 32]);
+	let route_params = get_blinded_route_parameters(
+		amt_msat,
+		payment_secret,
+		1,
+		1_0000_0000,
+		nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
+		&[&chan_upd_1_2],
+		&chanmon_cfgs[2].keys_manager,
+	);
+
+	let payment_hash = nodes[0]
+		.node
+		.send_spontaneous_payment(
+			Some(keysend_preimage),
+			RecipientOnionFields::spontaneous_empty(),
+			PaymentId(keysend_preimage.0),
+			route_params,
+			Retry::Attempts(0),
+		)
+		.unwrap();
+	check_added_monitors(&nodes[0], 1);
+
+	let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]];
+	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), 1);
+
+	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],
+		amt_msat,
+		payment_hash,
+		Some(payment_secret),
+		ev.clone(),
+		true,
+		Some(keysend_preimage),
+	);
+	claim_payment_along_route(ClaimAlongRouteArgs::new(
+		&nodes[0],
+		expected_route,
+		keysend_preimage,
+	));
+}
+
+#[test]
+fn blinded_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, None]);
+	let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
+
+	create_announced_chan_between_nodes(&nodes, 0, 1);
+	create_announced_chan_between_nodes(&nodes, 0, 2);
+	let chan_1_3 = create_announced_chan_between_nodes(&nodes, 1, 3);
+	let chan_2_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
+
+	let inbound_payment_key = nodes[3].keys_manager.get_inbound_payment_key();
+	let payment_secret = inbound_payment::create_for_spontaneous_payment(
+		&inbound_payment_key,
+		None,
+		u32::MAX,
+		nodes[3].node.duration_since_epoch().as_secs(),
+		None,
+	)
+	.unwrap();
+
+	let amt_msat = 15_000_000;
+	let keysend_preimage = PaymentPreimage([42; 32]);
+	let route_params = {
+		let pay_params = PaymentParameters::blinded(vec![
+			blinded_payment_path(
+				payment_secret,
+				1,
+				1_0000_0000,
+				vec![nodes[1].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
+				&[&chan_1_3.0.contents],
+				&chanmon_cfgs[3].keys_manager,
+			),
+			blinded_payment_path(
+				payment_secret,
+				1,
+				1_0000_0000,
+				vec![nodes[2].node.get_our_node_id(), nodes[3].node.get_our_node_id()],
+				&[&chan_2_3.0.contents],
+				&chanmon_cfgs[3].keys_manager,
+			),
+		])
+		.with_bolt12_features(channelmanager::provided_bolt12_invoice_features(
+			&UserConfig::default(),
+		))
+		.unwrap();
+		RouteParameters::from_payment_params_and_value(pay_params, amt_msat)
+	};
+
+	let payment_hash = nodes[0]
+		.node
+		.send_spontaneous_payment(
+			Some(keysend_preimage),
+			RecipientOnionFields::spontaneous_empty(),
+			PaymentId(keysend_preimage.0),
+			route_params,
+			Retry::Attempts(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);
+
+	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],
+		amt_msat,
+		payment_hash.clone(),
+		Some(payment_secret),
+		ev.clone(),
+		false,
+		Some(keysend_preimage),
+	);
+
+	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],
+		amt_msat,
+		payment_hash.clone(),
+		Some(payment_secret),
+		ev.clone(),
+		true,
+		Some(keysend_preimage),
+	);
+	claim_payment_along_route(ClaimAlongRouteArgs::new(
+		&nodes[0],
+		expected_route,
+		keysend_preimage,
+	));
+}
+
+#[test]
+fn invalid_keysend_payment_secret() {
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
+	let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
+	let chan_upd_1_2 =
+		create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0).0.contents;
+
+	let invalid_payment_secret = PaymentSecret([42; 32]);
+	let amt_msat = 5000;
+	let keysend_preimage = PaymentPreimage([42; 32]);
+	let route_params = get_blinded_route_parameters(
+		amt_msat,
+		invalid_payment_secret,
+		1,
+		1_0000_0000,
+		nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(),
+		&[&chan_upd_1_2],
+		&chanmon_cfgs[2].keys_manager,
+	);
+
+	let payment_hash = nodes[0]
+		.node
+		.send_spontaneous_payment(
+			Some(keysend_preimage),
+			RecipientOnionFields::spontaneous_empty(),
+			PaymentId(keysend_preimage.0),
+			route_params,
+			Retry::Attempts(0),
+		)
+		.unwrap();
+	check_added_monitors(&nodes[0], 1);
+
+	let expected_route: &[&[&Node]] = &[&[&nodes[1], &nodes[2]]];
+	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
+	assert_eq!(events.len(), 1);
+
+	let ev = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
+	let args =
+		PassAlongPathArgs::new(&nodes[0], &expected_route[0], amt_msat, payment_hash, ev.clone())
+			.with_payment_secret(invalid_payment_secret)
+			.with_payment_preimage(keysend_preimage)
+			.expect_failure(HTLCDestination::FailedPayment { payment_hash });
+	do_pass_along_path(args);
+
+	let updates_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
+	assert_eq!(updates_2_1.update_fail_malformed_htlcs.len(), 1);
+	let update_malformed = &updates_2_1.update_fail_malformed_htlcs[0];
+	assert_eq!(update_malformed.sha256_of_onion, [0; 32]);
+	assert_eq!(update_malformed.failure_code, INVALID_ONION_BLINDING);
+	nodes[1]
+		.node
+		.handle_update_fail_malformed_htlc(nodes[2].node.get_our_node_id(), update_malformed);
+	do_commitment_signed_dance(&nodes[1], &nodes[2], &updates_2_1.commitment_signed, true, false);
+
+	let updates_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
+	assert_eq!(updates_1_0.update_fail_htlcs.len(), 1);
+	nodes[0].node.handle_update_fail_htlc(
+		nodes[1].node.get_our_node_id(),
+		&updates_1_0.update_fail_htlcs[0],
+	);
+	do_commitment_signed_dance(&nodes[0], &nodes[1], &updates_1_0.commitment_signed, false, false);
+	expect_payment_failed_conditions(
+		&nodes[0],
+		payment_hash,
+		false,
+		PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]),
+	);
+}
+
+#[test]
 fn static_invoice_unknown_required_features() {
 	// Test that we will fail to pay a static invoice with unsupported required features.
 	let secp_ctx = Secp256k1::new();