From 1ddc6f10890d990452fe7ec5639b6c5d83ff3b1b Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Mon, 4 Jul 2022 09:36:06 +0200 Subject: [PATCH] Allow to set manual node penalties A user might want to explicitly penalize or prioritize a particular node. We now allow them to do so by specifying a manual penalty override for a given node that is then returned by the scorer. --- lightning/src/routing/router.rs | 16 +++++++++++--- lightning/src/routing/scoring.rs | 36 +++++++++++++++++++++----------- 2 files changed, 37 insertions(+), 15 deletions(-) diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 420a473ff..06d4328d2 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -1876,7 +1876,7 @@ fn build_route_from_hops_internal( #[cfg(test)] mod tests { - use routing::gossip::{NetworkGraph, P2PGossipSync, NodeId}; + use routing::gossip::{NetworkGraph, P2PGossipSync, NodeId, EffectiveCapacity}; 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}; @@ -5717,7 +5717,7 @@ mod tests { } #[test] - fn avoids_banned_nodes() { + fn honors_manual_penalties() { let (secp_ctx, network_graph, _, _, logger) = build_line_graph(); let (_, our_id, _, nodes) = get_nodes(&secp_ctx); @@ -5727,7 +5727,17 @@ mod tests { let scorer_params = ProbabilisticScoringParameters::default(); let mut scorer = ProbabilisticScorer::new(scorer_params, Arc::clone(&network_graph), Arc::clone(&logger)); - // First check we can get a route. + // First check set manual penalties are returned by the scorer. + let usage = ChannelUsage { + amount_msat: 0, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(1_000) }, + }; + scorer.set_manual_penalty(&NodeId::from_pubkey(&nodes[3]), 123); + scorer.set_manual_penalty(&NodeId::from_pubkey(&nodes[4]), 456); + assert_eq!(scorer.channel_penalty_msat(42, &NodeId::from_pubkey(&nodes[3]), &NodeId::from_pubkey(&nodes[4]), usage), 456); + + // Then check we can get a normal route let payment_params = PaymentParameters::from_node_id(nodes[10]); let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, 42, Arc::clone(&logger), &scorer, &random_seed_bytes); assert!(route.is_ok()); diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs index 524f0ed31..dfbfb8a05 100644 --- a/lightning/src/routing/scoring.rs +++ b/lightning/src/routing/scoring.rs @@ -362,10 +362,12 @@ pub struct ProbabilisticScoringParameters { /// Default value: 256 msat pub amount_penalty_multiplier_msat: u64, - /// A list of nodes that won't be considered during path finding. + /// Manual penalties used for the given nodes. Allows to set a particular penalty for a given + /// node. Note that a manual penalty of `u64::max_value()` means the node would not ever be + /// considered during path finding. /// /// (C-not exported) - pub banned_nodes: HashSet, + pub manual_node_penalties: HashMap, /// This penalty is applied when `htlc_maximum_msat` is equal to or larger than half of the /// channel's capacity, which makes us prefer nodes with a smaller `htlc_maximum_msat`. We @@ -468,17 +470,27 @@ impl>, L: Deref, T: Time> ProbabilisticScorerU /// Marks the node with the given `node_id` as banned, i.e., /// it will be avoided during path finding. pub fn add_banned(&mut self, node_id: &NodeId) { - self.params.banned_nodes.insert(*node_id); + self.params.manual_node_penalties.insert(*node_id, u64::max_value()); } /// Removes the node with the given `node_id` from the list of nodes to avoid. pub fn remove_banned(&mut self, node_id: &NodeId) { - self.params.banned_nodes.remove(node_id); + self.params.manual_node_penalties.remove(node_id); } - /// Clears the list of nodes that are avoided during path finding. - pub fn clear_banned(&mut self) { - self.params.banned_nodes = HashSet::new(); + /// Sets a manual penalty for the given node. + pub fn set_manual_penalty(&mut self, node_id: &NodeId, penalty: u64) { + self.params.manual_node_penalties.insert(*node_id, penalty); + } + + /// Removes the node with the given `node_id` from the list of manual penalties. + pub fn remove_manual_penalty(&mut self, node_id: &NodeId) { + self.params.manual_node_penalties.remove(node_id); + } + + /// Clears the list of manual penalties that are applied during path finding. + pub fn clear_manual_penalties(&mut self) { + self.params.manual_node_penalties = HashMap::new(); } } @@ -490,7 +502,7 @@ impl ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 0, liquidity_offset_half_life: Duration::from_secs(3600), amount_penalty_multiplier_msat: 0, - banned_nodes: HashSet::new(), + manual_node_penalties: HashMap::new(), anti_probing_penalty_msat: 0, } } @@ -499,7 +511,7 @@ impl ProbabilisticScoringParameters { /// they will be avoided during path finding. pub fn add_banned_from_list(&mut self, node_ids: Vec) { for id in node_ids { - self.banned_nodes.insert(id); + self.manual_node_penalties.insert(id, u64::max_value()); } } } @@ -511,7 +523,7 @@ impl Default for ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 40_000, liquidity_offset_half_life: Duration::from_secs(3600), amount_penalty_multiplier_msat: 256, - banned_nodes: HashSet::new(), + manual_node_penalties: HashMap::new(), anti_probing_penalty_msat: 250, } } @@ -713,8 +725,8 @@ impl>, L: Deref, T: Time> Score for Probabilis fn channel_penalty_msat( &self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage ) -> u64 { - if self.params.banned_nodes.contains(source) || self.params.banned_nodes.contains(target) { - return u64::max_value(); + if let Some(penalty) = self.params.manual_node_penalties.get(target) { + return *penalty; } let mut anti_probing_penalty_msat = 0; -- 2.39.5