WIP: Two-hop blinded payment path test

Author: jkczyz

lightning/src/ln/offers_tests.rs

@@ -19,7 +19,7 @@ use crate::blinded_path::BlindedPath;
 use crate::events::{Event, MessageSendEventsProvider, PaymentPurpose};
 use crate::ln::channelmanager::{PaymentId, RecentPaymentDetails, Retry};
 use crate::ln::functional_test_utils::*;
-use crate::ln::msgs::{OnionMessage, OnionMessageHandler};
+use crate::ln::msgs::{ChannelMessageHandler, Init, OnionMessage, OnionMessageHandler};
 use crate::offers::invoice::Bolt12Invoice;
 use crate::offers::invoice_request::InvoiceRequest;
 use crate::onion_message::{OffersMessage, ParsedOnionMessageContents, PeeledOnion};
@@ -38,6 +38,34 @@ macro_rules! expect_recent_payment {
 	}
 }
 
+fn connect_peers<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>) {
+	let node_id_a = node_a.node.get_our_node_id();
+	let node_id_b = node_b.node.get_our_node_id();
+
+	let init_a = Init {
+		features: node_a.init_features(&node_id_b),
+		networks: None,
+		remote_network_address: None,
+	};
+	let init_b = Init {
+		features: node_b.init_features(&node_id_a),
+		networks: None,
+		remote_network_address: None,
+	};
+
+	node_a.node.peer_connected(&node_id_b, &init_b, true).unwrap();
+	node_b.node.peer_connected(&node_id_a, &init_a, false).unwrap();
+	node_a.onion_messenger.peer_connected(&node_id_b, &init_b, true).unwrap();
+	node_b.onion_messenger.peer_connected(&node_id_a, &init_a, false).unwrap();
+}
+
+fn disconnect_peers<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>) {
+	node_a.node.peer_disconnected(&node_b.node.get_our_node_id());
+	node_b.node.peer_disconnected(&node_a.node.get_our_node_id());
+	node_a.onion_messenger.peer_disconnected(&node_b.node.get_our_node_id());
+	node_b.onion_messenger.peer_disconnected(&node_a.node.get_our_node_id());
+}
+
 fn route_bolt12_payment<'a, 'b, 'c>(
 	node: &Node<'a, 'b, 'c>, path: &[&Node<'a, 'b, 'c>], invoice: &Bolt12Invoice
 ) {
@@ -101,6 +129,94 @@ fn extract_invoice<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, message: &OnionMessage)
 	}
 }
 
+#[test]
+fn creates_and_pays_for_offer_using_two_hop_blinded_path() {
+	let chanmon_cfgs = create_chanmon_cfgs(6);
+	let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
+	let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None; 6]);
+	let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
+
+	create_unannounced_chan_between_nodes_with_value(&nodes, 0, 1, 10_000_000, 1_000_000_000);
+	create_unannounced_chan_between_nodes_with_value(&nodes, 2, 3, 10_000_000, 1_000_000_000);
+	create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 10_000_000, 1_000_000_000);
+	create_announced_chan_between_nodes_with_value(&nodes, 1, 4, 10_000_000, 1_000_000_000);
+	create_announced_chan_between_nodes_with_value(&nodes, 1, 5, 10_000_000, 1_000_000_000);
+	create_announced_chan_between_nodes_with_value(&nodes, 2, 4, 10_000_000, 1_000_000_000);
+	create_announced_chan_between_nodes_with_value(&nodes, 2, 5, 10_000_000, 1_000_000_000);
+
+	let alice = &nodes[0];
+	let alice_id = alice.node.get_our_node_id();
+	let bob = &nodes[1];
+	let bob_id = bob.node.get_our_node_id();
+	let charlie = &nodes[2];
+	let charlie_id = charlie.node.get_our_node_id();
+	let david = &nodes[3];
+	let david_id = david.node.get_our_node_id();
+
+	disconnect_peers(alice, charlie);
+	disconnect_peers(alice, david);
+	disconnect_peers(alice, &nodes[4]);
+	disconnect_peers(alice, &nodes[5]);
+
+	disconnect_peers(david, bob);
+	disconnect_peers(david, &nodes[4]);
+	disconnect_peers(david, &nodes[5]);
+
+	let offer = alice.node
+		.create_offer_builder("coffee".to_string()).unwrap()
+		.amount_msats(10_000_000)
+		.build().unwrap();
+	assert_ne!(offer.signing_pubkey(), alice_id);
+	assert!(!offer.paths().is_empty());
+	for path in offer.paths() {
+		dbg!(alice_id);
+		dbg!(bob_id);
+		dbg!(charlie_id);
+		dbg!(david_id);
+		assert_eq!(path.introduction_node_id, bob_id);
+	}
+
+	let payment_id = PaymentId([1; 32]);
+	david.node.pay_for_offer(&offer, None, None, None, payment_id, Retry::Attempts(0), None)
+		.unwrap();
+	expect_recent_payment!(david, RecentPaymentDetails::AwaitingInvoice, payment_id);
+
+	connect_peers(david, bob);
+
+	let onion_message = david.onion_messenger.next_onion_message_for_peer(bob_id).unwrap();
+	bob.onion_messenger.handle_onion_message(&david_id, &onion_message);
+
+	connect_peers(alice, charlie);
+
+	let onion_message = bob.onion_messenger.next_onion_message_for_peer(alice_id).unwrap();
+	alice.onion_messenger.handle_onion_message(&bob_id, &onion_message);
+
+	let (invoice_request, reply_path) = extract_invoice_request(alice, &onion_message);
+	assert_eq!(invoice_request.amount_msats(), None);
+	assert_ne!(invoice_request.payer_id(), david_id);
+	assert_eq!(reply_path.unwrap().introduction_node_id, charlie_id);
+
+	let onion_message = alice.onion_messenger.next_onion_message_for_peer(charlie_id).unwrap();
+	charlie.onion_messenger.handle_onion_message(&alice_id, &onion_message);
+
+	let onion_message = charlie.onion_messenger.next_onion_message_for_peer(david_id).unwrap();
+	david.onion_messenger.handle_onion_message(&charlie_id, &onion_message);
+
+	let invoice = extract_invoice(david, &onion_message);
+	assert_eq!(invoice.amount_msats(), 10_000_000);
+	assert_ne!(invoice.signing_pubkey(), alice_id);
+	assert!(!invoice.payment_paths().is_empty());
+	for (_, path) in invoice.payment_paths() {
+		assert_eq!(path.introduction_node_id, bob_id);
+	}
+
+	route_bolt12_payment(david, &[charlie, bob, alice], &invoice);
+	expect_recent_payment!(david, RecentPaymentDetails::Pending, payment_id);
+
+	claim_bolt12_payment(david, &[charlie, bob, alice]);
+	expect_recent_payment!(david, RecentPaymentDetails::Fulfilled, payment_id);
+}
+
 /// Checks that an offer can be paid through blinded paths and that ephemeral pubkeys are used
 /// rather than exposing a node's pubkey. Since a direct connection is currently required, the
 /// node's pubkey is instead used as the introduction node in any blinded paths.

lightning/src/ln/onion_payment.rs

@@ -43,8 +43,8 @@ fn check_blinded_forward(
 	let outgoing_cltv_value = inbound_cltv_expiry.checked_sub(
 		payment_relay.cltv_expiry_delta as u32
 	).ok_or(())?;
-	if inbound_amt_msat < payment_constraints.htlc_minimum_msat ||
-		outgoing_cltv_value > payment_constraints.max_cltv_expiry
+	if dbg!(dbg!(inbound_amt_msat) < dbg!(payment_constraints.htlc_minimum_msat)) ||
+		dbg!(dbg!(outgoing_cltv_value) > dbg!(payment_constraints.max_cltv_expiry))
 		{ return Err(()) }
 	if features.requires_unknown_bits_from(&BlindedHopFeatures::empty()) { return Err(()) }
 	Ok((amt_to_forward, outgoing_cltv_value))