Add random CLTV offset in dedicated method.

Author: tnull

lightning/src/routing/router.rs

@@ -609,12 +609,18 @@ fn compute_fees(amount_msat: u64, channel_fees: RoutingFees) -> Option<u64> {
 pub fn find_route<L: Deref, S: Score>(
 	our_node_pubkey: &PublicKey, route_params: &RouteParameters, network: &NetworkGraph,
 	first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S, random_seed_bytes: &[u8; 32]
-) -> Result<Route, LightningError>
+	) -> Result<Route, LightningError>
 where L::Target: Logger {
-	get_route(
+	match get_route(
 		our_node_pubkey, &route_params.payment_params, network, first_hops, route_params.final_value_msat,
 		route_params.final_cltv_expiry_delta, logger, scorer, random_seed_bytes
-	)
+		) {
+		Ok(mut route) => { 
+			add_random_cltv_offset(&mut route, &route_params.payment_params, network, random_seed_bytes);
+			Ok(route)
+		},
+		Err(err) => Err(err),
+	}
 }
 
 pub(crate) fn get_route<L: Deref, S: Score>(
@@ -664,7 +670,6 @@ where L::Target: Logger {
 	// 8. The last path in every selected route is likely to be more than we need.
 	//    Reduce its value-to-transfer and recompute fees.
 	// 9. Choose the best route by the lowest total fee.
-	// 10. Add a random 'shadow route' offset to the CLTV expiry delta values to improve privacy.
 
 	// As for the actual search algorithm,
 	// we do a payee-to-payer pseudo-Dijkstra's sorting by each node's distance from the payee
@@ -1515,14 +1520,27 @@ where L::Target: Logger {
 		}
 	}
 
-	// Step (10).
-	// Add a random 'shadow route' offset to the CLTV expiry delta values to improve privacy.
-	for path in selected_paths.iter_mut() {
+
+	let route = Route {
+		paths: selected_paths.into_iter().map(|path| path.into_iter().collect()).collect::<Result<Vec<_>, _>>()?,
+		payment_params: Some(payment_params.clone()),
+	};
+	log_info!(logger, "Got route to {}: {}", payment_params.payee_pubkey, log_route!(route));
+	Ok(route)
+}
+
+// Add a random 'shadow route' offset to the CLTV expiry delta values to improve privacy.
+fn add_random_cltv_offset(route: &mut Route, payment_params: &PaymentParameters, network: &NetworkGraph, random_seed_bytes: &[u8; 32]) {
+	let network_graph = network.read_only();
+	let network_channels = network_graph.channels();
+	let network_nodes = network_graph.nodes();
+
+	for path in route.paths.iter_mut() {
 		let mut shadow_ctlv_expiry_delta_offset: u32 = 0;
 
 		// Choose the last publicly known node as the starting point for the random walk
-		if let Some(starting_hop) = path.iter().rev().find(|h| network_nodes.contains_key(&NodeId::from_pubkey(&h.as_ref().unwrap().pubkey))) {
-			let mut cur_node_id = NodeId::from_pubkey(&starting_hop.as_ref().unwrap().pubkey);
+		if let Some(starting_hop) = path.iter().rev().find(|h| network_nodes.contains_key(&NodeId::from_pubkey(&h.pubkey))) {
+			let mut cur_node_id = NodeId::from_pubkey(&starting_hop.pubkey);
 
 			// Init PRNG with path nonce
 			let mut path_nonce = [0u8; 8];
@@ -1574,28 +1592,19 @@ where L::Target: Logger {
 
 		// Limit the offset so we never exceed the max_total_cltv_expiry_delta
 		let max_path_offset = payment_params.max_total_cltv_expiry_delta
-			.checked_sub(path.iter().fold(0, |acc,b| b.as_ref().unwrap().cltv_expiry_delta.max(acc)))
+			.checked_sub(path.iter().fold(0, |acc,b| b.cltv_expiry_delta.max(acc)))
 			.unwrap_or(shadow_ctlv_expiry_delta_offset);
 		shadow_ctlv_expiry_delta_offset = cmp::min(shadow_ctlv_expiry_delta_offset, 
 												   max_path_offset.checked_sub(max_path_offset.wrapping_rem(40)).unwrap_or(max_path_offset));
 
 		// Add 'shadow' CLTV offset to all hops but the final one
-		for h in path {
-			if let Ok(hop) = h {
-				if hop.pubkey != payment_params.payee_pubkey {
-					hop.cltv_expiry_delta = hop.cltv_expiry_delta
-						.checked_add(shadow_ctlv_expiry_delta_offset).unwrap_or(hop.cltv_expiry_delta);
-				}
+		for hop in path {
+			if hop.pubkey != payment_params.payee_pubkey {
+				hop.cltv_expiry_delta = hop.cltv_expiry_delta
+					.checked_add(shadow_ctlv_expiry_delta_offset).unwrap_or(hop.cltv_expiry_delta);
 			}
 		}
 	}
-
-	let route = Route {
-		paths: selected_paths.into_iter().map(|path| path.into_iter().collect()).collect::<Result<Vec<_>, _>>()?,
-		payment_params: Some(payment_params.clone()),
-	};
-	log_info!(logger, "Got route to {}: {}", payment_params.payee_pubkey, log_route!(route));
-	Ok(route)
 }
 
 #[cfg(test)]

lightning/src/routing/scoring.rs

@@ -20,6 +20,7 @@
 //! # use lightning::routing::network_graph::NetworkGraph;
 //! # use lightning::routing::router::{RouteParameters, find_route};
 //! # use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters, Scorer, ScoringParameters};
+//! # use lightning::chain::keysinterface::{KeysManager, KeysInterface};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use secp256k1::key::PublicKey;
 //! #
@@ -40,8 +41,11 @@
 //!     ..ProbabilisticScoringParameters::default()
 //! };
 //! let scorer = ProbabilisticScorer::new(params, &network_graph);
+//! let random_seed = [42u8; 32];
+//! let keys_manager = KeysManager::new(&random_seed, 1234, 5678);
+//! let random_seed_bytes = keys_manager.get_secure_random_bytes();
 //!
-//! let route = find_route(&payer, &route_params, &network_graph, None, &logger, &scorer);
+//! let route = find_route(&payer, &route_params, &network_graph, None, &logger, &scorer, &random_seed_bytes);
 //! # }
 //! ```
 //!