f: combine unblinded Trampoline payment test into other two

Author: arik-so

lightning/src/ln/blinded_payment_tests.rs

@@ -1963,7 +1963,14 @@ fn test_trampoline_inbound_payment_decoding() {
 }
 
 #[cfg(trampoline)]
-fn do_test_trampoline_single_hop_receive(success: bool) {
+enum TrampolineSingleHopReceiveCheck {
+	SuccessfulBlindedReceive,
+	SuccessfulUnblindedReceive,
+	InvalidOnionFailure,
+}
+
+#[cfg(trampoline)]
+fn do_test_trampoline_single_hop_receive(scenario: TrampolineSingleHopReceiveCheck) {
 	const TOTAL_NODE_COUNT: usize = 3;
 	let secp_ctx = Secp256k1::new();
 
@@ -1991,7 +1998,7 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 
 	let carol_alice_trampoline_session_priv = secret_from_hex("a0f4b8d7b6c2d0ffdfaf718f76e9decaef4d9fb38a8c4addb95c4007cc3eee03");
 	let carol_blinding_point = PublicKey::from_secret_key(&secp_ctx, &carol_alice_trampoline_session_priv);
-	let carol_blinded_hops = if success {
+	let carol_blinded_hops = if matches!(scenario, TrampolineSingleHopReceiveCheck::SuccessfulBlindedReceive | TrampolineSingleHopReceiveCheck::SuccessfulUnblindedReceive) {
 		let payee_tlvs = UnauthenticatedReceiveTlvs {
 			payment_secret,
 			payment_constraints: PaymentConstraints {
@@ -2081,29 +2088,44 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 
 	check_added_monitors!(&nodes[0], 1);
 
-	if success {
+	if matches!(scenario, TrampolineSingleHopReceiveCheck::SuccessfulBlindedReceive) {
 		pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
 		claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
 	} else {
 		let replacement_onion = {
-			// create a substitute onion where the last Trampoline hop is a forward
+			// Create a substitute onion:
+			// In the invalid onion failure scenario, it's to make the last payload a forward.
+			// In the unblinded receive scenario, which we (deliberately) do not support out of the
+			// box, it's to make the receive payload unblinded.
 			let trampoline_secret_key = secret_from_hex("0134928f7b7ca6769080d70f16be84c812c741f545b49a34db47ce338a205799");
 			let prng_seed = secret_from_hex("fe02b4b9054302a3ddf4e1e9f7c411d644aebbd295218ab009dca94435f775a9");
 			let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
 
 			let mut blinded_tail = route.paths[0].blinded_tail.clone().unwrap();
 
-			// append some dummy blinded hop so the intro hop looks like a forward
-			blinded_tail.hops.push(BlindedHop {
-				blinded_node_id: alice_node_id,
-				encrypted_payload: vec![],
-			});
+			if matches!(scenario, TrampolineSingleHopReceiveCheck::InvalidOnionFailure) {
+				// append some dummy blinded hop so the intro hop looks like a forward
+				blinded_tail.hops.push(BlindedHop {
+					blinded_node_id: alice_node_id,
+					encrypted_payload: vec![],
+				});
+			}
 
 			let (mut trampoline_payloads, outer_total_msat, outer_starting_htlc_offset) = onion_utils::build_trampoline_onion_payloads(&blinded_tail, amt_msat, &recipient_onion_fields, 32, &None).unwrap();
 
-			// pop the last dummy hop
 			trampoline_payloads.pop();
 
+			if matches!(scenario, TrampolineSingleHopReceiveCheck::SuccessfulUnblindedReceive) {
+				trampoline_payloads.push(msgs::OutboundTrampolinePayload::Receive {
+					payment_data: Some(msgs::FinalOnionHopData {
+						payment_secret,
+						total_msat: amt_msat,
+					}),
+					sender_intended_htlc_amt_msat: amt_msat,
+					cltv_expiry_height: 104,
+				});
+			}
+
 			let trampoline_onion_keys = onion_utils::construct_trampoline_onion_keys(&secp_ctx, &route.paths[0].blinded_tail.as_ref().unwrap(), &trampoline_secret_key).unwrap();
 			let trampoline_packet = onion_utils::construct_trampoline_onion_packet(
 				trampoline_payloads,
@@ -2142,30 +2164,36 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 		});
 
 		let route: &[&Node] = &[&nodes[1], &nodes[2]];
-		let args = PassAlongPathArgs::new(&nodes[0], route, amt_msat, payment_hash, first_message_event)
-			.with_payment_preimage(payment_preimage)
-			.without_claimable_event()
-			.expect_failure(HTLCDestination::InvalidOnion);
-		do_pass_along_path(args);
+		let args = PassAlongPathArgs::new(&nodes[0], route, amt_msat, payment_hash, first_message_event);
+
+		if matches!(scenario, TrampolineSingleHopReceiveCheck::InvalidOnionFailure) {
+			let args = args.expect_failure(HTLCDestination::InvalidOnion)
+				.with_payment_preimage(payment_preimage)
+				.without_claimable_event();
+			do_pass_along_path(args);
+
+			{
+				let unblinded_node_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
+				nodes[1].node.handle_update_fail_htlc(
+					nodes[2].node.get_our_node_id(), &unblinded_node_updates.update_fail_htlcs[0],
+				);
+				do_commitment_signed_dance(&nodes[1], &nodes[2], &unblinded_node_updates.commitment_signed, true, false);
+			}
+			{
+				let unblinded_node_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
+				nodes[0].node.handle_update_fail_htlc(
+					nodes[1].node.get_our_node_id(), &unblinded_node_updates.update_fail_htlcs[0],
+				);
+				do_commitment_signed_dance(&nodes[0], &nodes[1], &unblinded_node_updates.commitment_signed, false, false);
+			}
 
-		{
-			let unblinded_node_updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
-			nodes[1].node.handle_update_fail_htlc(
-				nodes[2].node.get_our_node_id(), &unblinded_node_updates.update_fail_htlcs[0]
-			);
-			do_commitment_signed_dance(&nodes[1], &nodes[2], &unblinded_node_updates.commitment_signed, true, false);
-		}
-		{
-			let unblinded_node_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
-			nodes[0].node.handle_update_fail_htlc(
-				nodes[1].node.get_our_node_id(), &unblinded_node_updates.update_fail_htlcs[0]
-			);
-			do_commitment_signed_dance(&nodes[0], &nodes[1], &unblinded_node_updates.commitment_signed, false, false);
-		}
-		{
 			let payment_failed_conditions = PaymentFailedConditions::new()
 				.expected_htlc_error_data(0x4000 | 22, &[0; 0]);
 			expect_payment_failed_conditions(&nodes[0], payment_hash, true, payment_failed_conditions);
+		} else {
+			let args = args.with_payment_secret(payment_secret);
+			do_pass_along_path(args);
+			claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
 		}
 	}
 }
@@ -2174,177 +2202,11 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 #[cfg(trampoline)]
 fn test_trampoline_single_hop_receive() {
 	// Simulate a payment of A (0) -> B (1) -> C(Trampoline (blinded intro)) (2)
-	do_test_trampoline_single_hop_receive(true);
-
-	// Simulate a payment failure of A (0) -> B (1) -> C(Trampoline (blinded forward)) (2)
-	do_test_trampoline_single_hop_receive(false);
-}
+	do_test_trampoline_single_hop_receive(TrampolineSingleHopReceiveCheck::SuccessfulBlindedReceive);
 
-#[test]
-#[cfg(trampoline)]
-fn test_trampoline_unblinded_receive() {
 	// Simulate a payment of A (0) -> B (1) -> C(Trampoline) (2)
+	do_test_trampoline_single_hop_receive(TrampolineSingleHopReceiveCheck::SuccessfulUnblindedReceive);
 
-	const TOTAL_NODE_COUNT: usize = 3;
-	let secp_ctx = Secp256k1::new();
-
-	let chanmon_cfgs = create_chanmon_cfgs(TOTAL_NODE_COUNT);
-	let node_cfgs = create_node_cfgs(TOTAL_NODE_COUNT, &chanmon_cfgs);
-	let node_chanmgrs = create_node_chanmgrs(TOTAL_NODE_COUNT, &node_cfgs, &vec![None; TOTAL_NODE_COUNT]);
-	let mut nodes = create_network(TOTAL_NODE_COUNT, &node_cfgs, &node_chanmgrs);
-
-	let (_, _, chan_id_alice_bob, _) = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 0);
-	let (_, _, chan_id_bob_carol, _) = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1_000_000, 0);
-
-	for i in 0..TOTAL_NODE_COUNT { // connect all nodes' blocks
-		connect_blocks(&nodes[i], (TOTAL_NODE_COUNT as u32) * CHAN_CONFIRM_DEPTH + 1 - nodes[i].best_block_info().1);
-	}
-
-	let alice_node_id = nodes[0].node().get_our_node_id();
-	let bob_node_id = nodes[1].node().get_our_node_id();
-	let carol_node_id = nodes[2].node().get_our_node_id();
-
-	let alice_bob_scid = nodes[0].node().list_channels().iter().find(|c| c.channel_id == chan_id_alice_bob).unwrap().short_channel_id.unwrap();
-	let bob_carol_scid = nodes[1].node().list_channels().iter().find(|c| c.channel_id == chan_id_bob_carol).unwrap().short_channel_id.unwrap();
-
-	let amt_msat = 1000;
-	let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
-	let payee_tlvs = blinded_path::payment::TrampolineForwardTlvs {
-		next_trampoline: alice_node_id,
-		payment_constraints: PaymentConstraints {
-			max_cltv_expiry: u32::max_value(),
-			htlc_minimum_msat: amt_msat,
-		},
-		features: BlindedHopFeatures::empty(),
-		payment_relay: PaymentRelay {
-			cltv_expiry_delta: 0,
-			fee_proportional_millionths: 0,
-			fee_base_msat: 0,
-		},
-		next_blinding_override: None,
-	};
-
-	let carol_unblinded_tlvs = payee_tlvs.encode();
-	let path = [(carol_node_id, WithoutLength(&carol_unblinded_tlvs))];
-	let carol_alice_trampoline_session_priv = secret_from_hex("a0f4b8d7b6c2d0ffdfaf718f76e9decaef4d9fb38a8c4addb95c4007cc3eee03");
-	let carol_blinding_point = PublicKey::from_secret_key(&secp_ctx, &carol_alice_trampoline_session_priv);
-	let carol_blinded_hops = blinded_path::utils::construct_blinded_hops(
-		&secp_ctx, path.into_iter(), &carol_alice_trampoline_session_priv
-	).unwrap();
-
-	let route = Route {
-		paths: vec![Path {
-			hops: vec![
-				// Bob
-				RouteHop {
-					pubkey: bob_node_id,
-					node_features: NodeFeatures::empty(),
-					short_channel_id: alice_bob_scid,
-					channel_features: ChannelFeatures::empty(),
-					fee_msat: 1000,
-					cltv_expiry_delta: 48,
-					maybe_announced_channel: false,
-				},
-
-				// Carol
-				RouteHop {
-					pubkey: carol_node_id,
-					node_features: NodeFeatures::empty(),
-					short_channel_id: bob_carol_scid,
-					channel_features: ChannelFeatures::empty(),
-					fee_msat: 0,
-					cltv_expiry_delta: 48,
-					maybe_announced_channel: false,
-				}
-			],
-			blinded_tail: Some(BlindedTail {
-				trampoline_hops: vec![
-					// Carol
-					TrampolineHop {
-						pubkey: carol_node_id,
-						node_features: Features::empty(),
-						fee_msat: amt_msat,
-						cltv_expiry_delta: 24,
-					},
-				],
-				hops: carol_blinded_hops,
-				blinding_point: carol_blinding_point,
-				excess_final_cltv_expiry_delta: 39,
-				final_value_msat: amt_msat,
-			})
-		}],
-		route_params: None,
-	};
-
-	nodes[0].node.send_payment_with_route(route.clone(), payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0)).unwrap();
-
-	let replacement_onion = {
-		// create a substitute onion where the last Trampoline hop is an unblinded receive, which we
-		// (deliberately) do not support out of the box, therefore necessitating this workaround
-		let trampoline_secret_key = secret_from_hex("0134928f7b7ca6769080d70f16be84c812c741f545b49a34db47ce338a205799");
-		let prng_seed = secret_from_hex("fe02b4b9054302a3ddf4e1e9f7c411d644aebbd295218ab009dca94435f775a9");
-		let recipient_onion_fields = RecipientOnionFields::spontaneous_empty();
-
-		let blinded_tail = route.paths[0].blinded_tail.clone().unwrap();
-		let (mut trampoline_payloads, outer_total_msat, outer_starting_htlc_offset) = onion_utils::build_trampoline_onion_payloads(&blinded_tail, amt_msat, &recipient_onion_fields, 32, &None).unwrap();
-
-		// pop the last dummy hop
-		trampoline_payloads.pop();
-
-		trampoline_payloads.push(msgs::OutboundTrampolinePayload::Receive {
-			payment_data: Some(msgs::FinalOnionHopData {
-				payment_secret,
-				total_msat: amt_msat,
-			}),
-			sender_intended_htlc_amt_msat: amt_msat,
-			cltv_expiry_height: 104,
-		});
-
-		let trampoline_onion_keys = onion_utils::construct_trampoline_onion_keys(&secp_ctx, &route.paths[0].blinded_tail.as_ref().unwrap(), &trampoline_secret_key).unwrap();
-		let trampoline_packet = onion_utils::construct_trampoline_onion_packet(
-			trampoline_payloads,
-			trampoline_onion_keys,
-			prng_seed.secret_bytes(),
-			&payment_hash,
-			None,
-		).unwrap();
-
-		let outer_session_priv = secret_from_hex("e52c20461ed7acd46c4e7b591a37610519179482887bd73bf3b94617f8f03677");
-
-		let (outer_payloads, _, _) = onion_utils::build_onion_payloads(&route.paths[0], outer_total_msat, &recipient_onion_fields, outer_starting_htlc_offset, &None, None, Some(trampoline_packet)).unwrap();
-		let outer_onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.clone().paths[0], &outer_session_priv).unwrap();
-		let outer_packet = onion_utils::construct_onion_packet(
-			outer_payloads,
-			outer_onion_keys,
-			prng_seed.secret_bytes(),
-			&payment_hash,
-		).unwrap();
-
-		outer_packet
-	};
-
-	check_added_monitors!(&nodes[0], 1);
-
-	// Check that we've queued the HTLCs of the async keysend payment.
-	let mut events = nodes[0].node.get_and_clear_pending_msg_events();
-	assert_eq!(events.len(), 1);
-	let mut first_message_event = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut events);
-	let mut update_message = match first_message_event {
-		MessageSendEvent::UpdateHTLCs { ref mut updates, .. } => {
-			assert_eq!(updates.update_add_htlcs.len(), 1);
-			updates.update_add_htlcs.get_mut(0)
-		},
-		_ => panic!()
-	};
-	update_message.map(|msg| {
-		msg.onion_routing_packet = replacement_onion.clone();
-	});
-
-	let route: &[&Node] = &[&nodes[1], &nodes[2]];
-	let args = PassAlongPathArgs::new(&nodes[0], route, amt_msat, payment_hash, first_message_event)
-		.with_payment_secret(payment_secret);
-	do_pass_along_path(args);
-
-	claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
+	// Simulate a payment failure of A (0) -> B (1) -> C(Trampoline (blinded forward)) (2)
+	do_test_trampoline_single_hop_receive(TrampolineSingleHopReceiveCheck::InvalidOnionFailure);
 }
-