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,10 +1785,54 @@ 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 hop_ids: Vec<NodeId> = core::iter::once(NodeId::from_pubkey(&our_node_pubkey))
+		.chain(hops.iter().map(|hop_pubkey| NodeId::from_pubkey(&hop_pubkey))).collect();
+
+	let filter_by_nodeids = |_short_channel_id: u64, _send_amt_msat: u64, _capacity_msat: u64,
+		source: &NodeId, target: &NodeId| {
+			if hop_ids.iter().find(|x| **x == *source).is_some()
+				&& hop_ids.iter().find(|x| **x == *target).is_some() {
+					0
+				} else {
+					u64::max_value()
+				}
+	};
+
+	let scorer = DynamicPenaltyScorer::with_penalty_func(filter_by_nodeids);
+
+	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};
-	use routing::router::{get_route, add_random_cltv_offset, default_node_features,
+	use routing::router::{get_route, build_route_from_hops_internal, add_random_cltv_offset, default_node_features,
 		PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees,
 		DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE};
 	use routing::scoring::{ChannelUsage, Score};