f move method to onion_utils + use build_payloads_callback

Author: valentinewallace

lightning/src/ln/blinded_payment_tests.rs

@@ -282,10 +282,9 @@ fn do_forward_checks_failure(check: ForwardCheckFail, intro_fails: bool) {
 
 	let amt_msat = 5000;
 	let (_, payment_hash, payment_secret) = get_payment_preimage_hash(&nodes[3], Some(amt_msat), None);
-	let mut route_params = get_blinded_route_parameters(amt_msat, payment_secret, 1, 1_0000_0000,
+	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, &chan_upd_2_3], &chanmon_cfgs[3].keys_manager);
-	route_params.payment_params.max_intermediate_hops = 17;
 
 	let route = get_route(&nodes[0], &route_params).unwrap();
 	node_cfgs[0].router.expect_find_route(route_params.clone(), Ok(route.clone()));
@@ -805,7 +804,6 @@ fn do_multi_hop_receiver_fail(check: ReceiveCheckFail) {
 	let mut 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);
-	route_params.payment_params.max_intermediate_hops = 18;
 
 	let route = if check == ReceiveCheckFail::ProcessPendingHTLCsCheck {
 		let mut route = get_route(&nodes[0], &route_params).unwrap();

lightning/src/ln/onion_utils.rs

@@ -11,11 +11,12 @@ use crate::blinded_path::BlindedHop;
 use crate::crypto::chacha20::ChaCha20;
 use crate::crypto::streams::ChaChaReader;
 use crate::ln::channelmanager::{HTLCSource, RecipientOnionFields};
+use crate::ln::features::{ChannelFeatures, NodeFeatures};
 use crate::ln::msgs;
 use crate::ln::wire::Encode;
 use crate::ln::{PaymentHash, PaymentPreimage};
 use crate::routing::gossip::NetworkUpdate;
-use crate::routing::router::{Path, RouteHop};
+use crate::routing::router::{Path, Payee, RouteHop, RouteParameters, MAX_PATH_LENGTH_ESTIMATE};
 use crate::sign::NodeSigner;
 use crate::util::errors::{self, APIError};
 use crate::util::logger::Logger;
@@ -310,6 +311,81 @@ pub(super) fn build_onion_payloads<'a>(
 	Ok((res, value_msat, cltv))
 }
 
+pub(crate) fn set_max_path_length(
+	route_params: &mut RouteParameters, recipient_onion: &RecipientOnionFields,
+	keysend_preimage: Option<PaymentPreimage>, best_block_height: u32,
+) -> Result<(), ()> {
+	const PAYLOAD_HMAC_LEN: usize = 32;
+	let unblinded_intermed_payload_len = msgs::OutboundOnionPayload::Forward {
+		short_channel_id: 42,
+		amt_to_forward: u64::max_value(),
+		outgoing_cltv_value: u32::max_value(),
+	}
+	.serialized_length()
+	.saturating_add(PAYLOAD_HMAC_LEN);
+
+	let (cltv_expiry_delta, num_reserved_hops, blinded_tail_opt) =
+		match &route_params.payment_params.payee {
+			Payee::Blinded { route_hints, .. } => {
+				let (blinded_payinfo, largest_path) = route_hints
+					.iter()
+					.max_by(|(_, path_a), (_, path_b)| {
+						path_a.serialized_length().cmp(&path_b.serialized_length())
+					})
+					.ok_or(())?;
+				let blinded_tail = BlindedTailHopIter {
+					hops: largest_path.blinded_hops.iter(),
+					blinding_point: largest_path.blinding_point,
+					final_value_msat: route_params.final_value_msat,
+					excess_final_cltv_expiry_delta: 0,
+				};
+				(
+					blinded_payinfo.cltv_expiry_delta as u32,
+					largest_path.blinded_hops.len(),
+					Some(blinded_tail),
+				)
+			},
+			Payee::Clear { final_cltv_expiry_delta, .. } => {
+				(*final_cltv_expiry_delta, 1 as usize, None)
+			},
+		};
+
+	let unblinded_route_hop = RouteHop {
+		pubkey: PublicKey::from_slice(&[2; 33]).unwrap(),
+		node_features: NodeFeatures::empty(),
+		short_channel_id: 42,
+		channel_features: ChannelFeatures::empty(),
+		fee_msat: route_params.final_value_msat,
+		cltv_expiry_delta,
+		maybe_announced_channel: false,
+	};
+	let mut num_reserved_bytes: usize = 0;
+	let build_payloads_res = build_onion_payloads_callback(
+		core::iter::once(&unblinded_route_hop),
+		blinded_tail_opt,
+		route_params.final_value_msat,
+		&recipient_onion,
+		best_block_height,
+		&keysend_preimage,
+		|_, payload| {
+			num_reserved_bytes = num_reserved_bytes
+				.saturating_add(payload.serialized_length())
+				.saturating_add(PAYLOAD_HMAC_LEN);
+		},
+	);
+	debug_assert!(build_payloads_res.is_ok());
+
+	let max_path_length = 1300usize
+		.checked_sub(num_reserved_bytes)
+		.map(|p| p / unblinded_intermed_payload_len)
+		.and_then(|l| u8::try_from(l.saturating_add(num_reserved_hops)).ok())
+		.ok_or(())?;
+
+	route_params.payment_params.max_path_length =
+		core::cmp::min(max_path_length, MAX_PATH_LENGTH_ESTIMATE);
+	Ok(())
+}
+
 /// Length of the onion data packet. Before TLV-based onions this was 20 65-byte hops, though now
 /// the hops can be of variable length.
 pub(crate) const ONION_DATA_LEN: usize = 20 * 65;

lightning/src/ln/outbound_payment.rs

@@ -17,16 +17,16 @@ use crate::sign::{EntropySource, NodeSigner, Recipient};
 use crate::events::{self, PaymentFailureReason};
 use crate::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use crate::ln::channelmanager::{ChannelDetails, EventCompletionAction, HTLCSource, PaymentId};
-use crate::ln::msgs;
+use crate::ln::onion_utils;
 use crate::ln::onion_utils::{DecodedOnionFailure, HTLCFailReason};
 use crate::offers::invoice::Bolt12Invoice;
-use crate::routing::router::{BlindedTail, InFlightHtlcs, MAX_PATH_LENGTH_ESTIMATE, Path, Payee, PaymentParameters, Route, RouteParameters, Router};
+use crate::routing::router::{BlindedTail, InFlightHtlcs, Path, PaymentParameters, Route, RouteParameters, Router};
 use crate::util::errors::APIError;
 use crate::util::logger::Logger;
 use crate::util::time::Time;
 #[cfg(all(feature = "std", test))]
 use crate::util::time::tests::SinceEpoch;
-use crate::util::ser::{ReadableArgs, Writeable};
+use crate::util::ser::ReadableArgs;
 
 use core::fmt::{self, Display, Formatter};
 use core::ops::Deref;
@@ -914,7 +914,7 @@ impl OutboundPayments {
 			}
 		}
 
-		set_max_path_length(
+		onion_utils::set_max_path_length(
 			&mut route_params, &recipient_onion, keysend_preimage, best_block_height
 		)
 			.map_err(|()| {
@@ -1787,74 +1787,6 @@ impl OutboundPayments {
 	}
 }
 
-fn set_max_path_length(
-	route_params: &mut RouteParameters, recipient_onion: &RecipientOnionFields,
-	keysend_preimage: Option<PaymentPreimage>, best_block_height: u32,
-) -> Result<(), ()> {
-	const PAYLOAD_HMAC_LEN: usize = 32;
-	const UNBLINDED_INTERMED_PAYLOAD_LEN: usize = PAYLOAD_HMAC_LEN
-		+ 1 + 1 + 8 // amt_to_forward
-		+ 1 + 1 + 4 // outgoing_cltv
-		+ 1 + 1 + 8; // short_channel_id
-
-	let num_reserved_bytes = match &route_params.payment_params.payee {
-		Payee::Blinded { route_hints, .. } => {
-			let (blinded_payinfo, largest_path) = route_hints
-				.iter()
-				.max_by(|(_, path_a), (_, path_b)|
-					path_a.serialized_length().cmp(&path_b.serialized_length()))
-				.ok_or(())?;
-
-			largest_path.blinded_hops
-				.iter()
-				.rev()
-				.skip(1)
-				.map(|bh| msgs::OutboundOnionPayload::BlindedForward {
-					encrypted_tlvs: &bh.encrypted_payload,
-					// For simplicity, always set the intro_node_blinding_point in the
-					// final payload.
-					intro_node_blinding_point: None,
-				})
-				.chain(core::iter::once(msgs::OutboundOnionPayload::BlindedReceive {
-					sender_intended_htlc_amt_msat: route_params.final_value_msat,
-					total_msat: route_params.final_value_msat,
-					cltv_expiry_height:
-						best_block_height.saturating_add(blinded_payinfo.cltv_expiry_delta as u32),
-					encrypted_tlvs: largest_path.blinded_hops
-						.last()
-						.map(|bh| &bh.encrypted_payload)
-						.unwrap_or(&Vec::new()),
-					intro_node_blinding_point: Some(largest_path.blinding_point),
-					keysend_preimage,
-					custom_tlvs: &recipient_onion.custom_tlvs,
-				}))
-				.map(|payload| payload.serialized_length().saturating_add(PAYLOAD_HMAC_LEN))
-				.fold(0, |acc: usize, payload_len| acc.saturating_add(payload_len))
-		},
-		Payee::Clear { final_cltv_expiry_delta, .. } => {
-			msgs::OutboundOnionPayload::Receive {
-				payment_data: recipient_onion.payment_secret.map(|payment_secret| {
-					msgs::FinalOnionHopData { payment_secret, total_msat: route_params.final_value_msat }
-				}),
-				payment_metadata: recipient_onion.payment_metadata.as_ref(),
-				keysend_preimage,
-				custom_tlvs: &recipient_onion.custom_tlvs,
-				sender_intended_htlc_amt_msat: route_params.final_value_msat,
-				cltv_expiry_height: best_block_height.saturating_add(*final_cltv_expiry_delta),
-			}
-			.serialized_length()
-			.saturating_add(PAYLOAD_HMAC_LEN)
-		}
-	};
-	let max_intermediate_unblinded_hops = 1300usize.checked_sub(num_reserved_bytes)
-		.map(|p| p / UNBLINDED_INTERMED_PAYLOAD_LEN)
-		.and_then(|l| u8::try_from(l).ok())
-		.ok_or(())?;
-
-	route_params.payment_params.max_intermediate_hops = core::cmp::min(max_intermediate_unblinded_hops, MAX_PATH_LENGTH_ESTIMATE);
-	Ok(())
-}
-
 /// Returns whether a payment with the given [`PaymentHash`] and [`PaymentId`] is, in fact, a
 /// payment probe.
 pub(super) fn payment_is_probe(payment_hash: &PaymentHash, payment_id: &PaymentId,