Simplify test_trampoline_single_hop_receive

Previously, this test purported to test for a successful and a failing payment
to a single-hop blinded path containing one trampoline node. However, to induce
the failure the test was manually reconstructing the trampoline onion in a
complicated way that encoded the final onion payload as a receive, when for its
purposes it would be simplier for the recipient to just fail the payment
backwards.

In order to not regress in test coverage, the failure method the test was
previously using is re-added in the next commit as a dedicated test.

XXX this new test surfaced a bug that needs to be fixed

Author: valentinewallace

lightning/src/ln/blinded_payment_tests.rs

@@ -1998,7 +1998,6 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 		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();
 
@@ -2008,54 +2007,19 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 	let amt_msat = 1000;
 	let (payment_preimage, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
 
-	// We need the session priv to compute the trampoline session priv and construct an invalid onion packet later.
-	let override_random_bytes = [3; 32];
-	*nodes[0].keys_manager.override_random_bytes.lock().unwrap() = Some(override_random_bytes);
-
-	let outer_onion_session_priv = SecretKey::from_slice(&override_random_bytes[..]).unwrap();
-	let carol_alice_trampoline_session_priv = onion_utils::compute_trampoline_session_priv(&outer_onion_session_priv);
-	let carol_blinding_point = PublicKey::from_secret_key(&secp_ctx, &carol_alice_trampoline_session_priv);
-	let carol_blinded_hops = if success {
-		let payee_tlvs = UnauthenticatedReceiveTlvs {
-			payment_secret,
-			payment_constraints: PaymentConstraints {
-				max_cltv_expiry: u32::max_value(),
-				htlc_minimum_msat: amt_msat,
-			},
-			payment_context: PaymentContext::Bolt12Refund(Bolt12RefundContext {}),
-		};
-
-		let nonce = Nonce([42u8; 16]);
-		let expanded_key = nodes[2].keys_manager.get_inbound_payment_key();
-		let payee_tlvs = payee_tlvs.authenticate(nonce, &expanded_key);
-		let carol_unblinded_tlvs = payee_tlvs.encode();
-
-		let path = [((carol_node_id, None), WithoutLength(&carol_unblinded_tlvs))];
-		blinded_path::utils::construct_blinded_hops(
-			&secp_ctx, path.into_iter(), &carol_alice_trampoline_session_priv,
-		).unwrap()
-	} else {
-		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, None), WithoutLength(&carol_unblinded_tlvs))];
-		blinded_path::utils::construct_blinded_hops(
-			&secp_ctx, path.into_iter(), &carol_alice_trampoline_session_priv,
-		).unwrap()
+	// Create a 1-hop blinded path for Carol.
+	let payee_tlvs = UnauthenticatedReceiveTlvs {
+		payment_secret,
+		payment_constraints: PaymentConstraints {
+			max_cltv_expiry: u32::max_value(),
+			htlc_minimum_msat: amt_msat,
+		},
+		payment_context: PaymentContext::Bolt12Refund(Bolt12RefundContext {}),
 	};
+	let nonce = Nonce([42u8; 16]);
+	let expanded_key = nodes[2].keys_manager.get_inbound_payment_key();
+	let payee_tlvs = payee_tlvs.authenticate(nonce, &expanded_key);
+	let blinded_path = BlindedPaymentPath::new(&[], carol_node_id, payee_tlvs, u64::MAX, 0, nodes[2].keys_manager, &secp_ctx).unwrap();
 
 	let route = Route {
 		paths: vec![Path {
@@ -2092,8 +2056,8 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 						cltv_expiry_delta: 24,
 					},
 				],
-				hops: carol_blinded_hops,
-				blinding_point: carol_blinding_point,
+				hops: blinded_path.blinded_hops().to_vec(),
+				blinding_point: blinded_path.blinding_point(),
 				excess_final_cltv_expiry_delta: 39,
 				final_value_msat: amt_msat,
 			})
@@ -2104,87 +2068,11 @@ fn do_test_trampoline_single_hop_receive(success: bool) {
 	nodes[0].node.send_payment_with_route(route.clone(), payment_hash, RecipientOnionFields::spontaneous_empty(), PaymentId(payment_hash.0)).unwrap();
 	check_added_monitors!(&nodes[0], 1);
 
+	pass_along_route(&nodes[0], &[&[&nodes[1], &nodes[2]]], amt_msat, payment_hash, payment_secret);
 	if success {
-		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
-			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![],
-			});
-
-			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();
-
-			let trampoline_onion_keys = onion_utils::construct_trampoline_onion_keys(&secp_ctx, &route.paths[0].blinded_tail.as_ref().unwrap(), &carol_alice_trampoline_session_priv);
-			let trampoline_packet = onion_utils::construct_trampoline_onion_packet(
-				trampoline_payloads,
-				trampoline_onion_keys,
-				override_random_bytes,
-				&payment_hash,
-				None,
-			).unwrap();
-
-			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_onion_session_priv);
-			let outer_packet = onion_utils::construct_onion_packet(
-				outer_payloads,
-				outer_onion_keys,
-				override_random_bytes,
-				&payment_hash,
-			).unwrap();
-
-			outer_packet
-		};
-
-		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_preimage(payment_preimage)
-			.without_claimable_event()
-			.expect_failure(HTLCHandlingFailureType::InvalidOnion);
-		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 payment_failed_conditions = PaymentFailedConditions::new()
-				.expected_htlc_error_data(LocalHTLCFailureReason::InvalidOnionPayload, &[0; 0]);
-			expect_payment_failed_conditions(&nodes[0], payment_hash, true, payment_failed_conditions);
-		}
+		fail_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_hash);
 	}
 }