Implement build_route_from_hops.

Author: tnull

lightning/src/routing/router.rs

@@ -17,7 +17,7 @@ use bitcoin::secp256k1::PublicKey;
 use ln::channelmanager::ChannelDetails;
 use ln::features::{ChannelFeatures, InvoiceFeatures, NodeFeatures};
 use ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT};
-use routing::scoring::{ChannelUsage, Score};
+use routing::scoring::{ChannelUsage, Score, DynamicPenaltyScorer};
 use routing::network_graph::{DirectedChannelInfoWithUpdate, EffectiveCapacity, NetworkGraph, ReadOnlyNetworkGraph, NodeId, RoutingFees};
 use util::ser::{Writeable, Readable};
 use util::logger::{Level, Logger};
@@ -151,7 +151,7 @@ impl Readable for Route {
 
 /// Parameters needed to find a [`Route`].
 ///
-/// Passed to [`find_route`] and also provided in [`Event::PaymentPathFailed`] for retrying a failed
+/// Passed to [`find_route`] and [`build_route_from_hops`], but also provided in [`Event::PaymentPathFailed`] for retrying a failed
 /// payment path.
 ///
 /// [`Event::PaymentPathFailed`]: crate::util::events::Event::PaymentPathFailed
@@ -1785,6 +1785,49 @@ fn add_random_cltv_offset(route: &mut Route, payment_params: &PaymentParameters,
 	}
 }
 
+/// Build a route from us (payer) with the given hops ending at the target node (payee).
+///
+/// Re-uses logic from `find_route`, so the restrictions described there also apply here.
+pub fn build_route_from_hops<L: Deref>(
+	our_node_pubkey: &PublicKey, hops: &[PublicKey], route_params: &RouteParameters, network: &NetworkGraph,
+	logger: L, random_seed_bytes: &[u8; 32]) -> Result<Route, LightningError>
+where L::Target: Logger {
+	let network_graph = network.read_only();
+	match build_route_from_hops_internal(
+		our_node_pubkey, hops, &route_params.payment_params, &network_graph,
+		route_params.final_value_msat, route_params.final_cltv_expiry_delta, logger, random_seed_bytes
+		) {
+		Ok(mut route) => {
+			add_random_cltv_offset(&mut route, &route_params.payment_params, &network_graph, random_seed_bytes);
+			Ok(route)
+		},
+		Err(err) => Err(err),
+	}
+}
+
+fn build_route_from_hops_internal<L: Deref>(
+	our_node_pubkey: &PublicKey, hops: &[PublicKey], payment_params: &PaymentParameters,
+	network_graph: &ReadOnlyNetworkGraph, final_value_msat: u64, final_cltv_expiry_delta: u32,
+	logger: L, random_seed_bytes: &[u8; 32]) -> Result<Route, LightningError> where L::Target: Logger {
+
+	let node_ids_iter = hops.iter().map(|hop_pubkey| NodeId::from_pubkey(&hop_pubkey));
+	let hop_iter = core::iter::once(NodeId::from_pubkey(&our_node_pubkey))
+		.chain(node_ids_iter.clone())
+		.zip(node_ids_iter);
+	let filter_channels = |_short_channel_id: u64, source: &NodeId, target: &NodeId,
+		_usage: ChannelUsage| {
+			match hop_iter.clone().find(|(cur_id, next_id)| { *cur_id == *source && *next_id == *target }) {
+				Some(_) => 0,
+				None => u64::max_value()
+			}
+	};
+
+	let scorer = DynamicPenaltyScorer::with_penalty_func(filter_channels);
+
+	get_route(our_node_pubkey, payment_params, network_graph, None, final_value_msat,
+		final_cltv_expiry_delta, logger, &scorer, random_seed_bytes)
+}
+
 #[cfg(test)]
 mod tests {
 	use routing::network_graph::{NetworkGraph, NetGraphMsgHandler, NodeId};