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};
+ use routing::scoring::{ChannelUsage, Score, ProbabilisticScorer, ProbabilisticScoringParameters};
use chain::transaction::OutPoint;
use chain::keysinterface::KeysInterface;
use ln::features::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures};
}
}
}
+
+ #[test]
+ fn avoids_banned_nodes() {
+ let (secp_ctx, network_graph, _, _, logger) = build_line_graph();
+ let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+
+ let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let random_seed_bytes = keys_manager.get_secure_random_bytes();
+
+ 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.
+ 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());
+
+ // Then check that we can't get a route if we ban an intermediate node.
+ scorer.add_banned(&NodeId::from_pubkey(&nodes[3]));
+ 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_err());
+
+ // Finally make sure we can route again, when we remove the ban.
+ scorer.remove_banned(&NodeId::from_pubkey(&nodes[3]));
+ 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());
+ }
}
#[cfg(all(test, not(feature = "no-std")))]
///
/// Used to configure base, liquidity, and amount penalties, the sum of which comprises the channel
/// penalty (i.e., the amount in msats willing to be paid to avoid routing through the channel).
-#[derive(Clone, Copy)]
+#[derive(Clone)]
pub struct ProbabilisticScoringParameters {
/// A fixed penalty in msats to apply to each channel.
///
///
/// Default value: 256 msat
pub amount_penalty_multiplier_msat: u64,
+
+ /// A list of nodes that won't be considered during path finding.
+ ///
+ /// (C-not exported)
+ pub banned_nodes: HashSet<NodeId>,
}
/// Accounting for channel liquidity balance uncertainty.
}
None
}
+
+ /// 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);
+ }
+
+ /// 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);
+ }
+
+ /// Clears the list of nodes that are avoided during path finding.
+ pub fn clear_banned(&mut self) {
+ self.params.banned_nodes = HashSet::new();
+ }
}
impl ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 0,
liquidity_offset_half_life: Duration::from_secs(3600),
amount_penalty_multiplier_msat: 0,
+ banned_nodes: HashSet::new(),
+ }
+ }
+
+ /// Marks all nodes in the given list as banned, i.e.,
+ /// they will be avoided during path finding.
+ pub fn add_banned_from_list(&mut self, node_ids: Vec<NodeId>) {
+ for id in node_ids {
+ self.banned_nodes.insert(id);
}
}
}
liquidity_penalty_multiplier_msat: 40_000,
liquidity_offset_half_life: Duration::from_secs(3600),
amount_penalty_multiplier_msat: 256,
+ banned_nodes: HashSet::new(),
}
}
}
impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiquidity<L, T, U> {
/// Returns a penalty for routing the given HTLC `amount_msat` through the channel in this
/// direction.
- fn penalty_msat(&self, amount_msat: u64, params: ProbabilisticScoringParameters) -> u64 {
+ fn penalty_msat(&self, amount_msat: u64, params: &ProbabilisticScoringParameters) -> u64 {
let max_liquidity_msat = self.max_liquidity_msat();
let min_liquidity_msat = core::cmp::min(self.min_liquidity_msat(), max_liquidity_msat);
if amount_msat <= min_liquidity_msat {
#[inline(always)]
fn combined_penalty_msat(
&self, amount_msat: u64, negative_log10_times_2048: u64,
- params: ProbabilisticScoringParameters
+ params: &ProbabilisticScoringParameters
) -> u64 {
let liquidity_penalty_msat = {
// Upper bound the liquidity penalty to ensure some channel is selected.
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 EffectiveCapacity::ExactLiquidity { liquidity_msat } = usage.effective_capacity {
if usage.amount_msat > liquidity_msat {
return u64::max_value();
.get(&short_channel_id)
.unwrap_or(&ChannelLiquidity::new())
.as_directed(source, target, capacity_msat, liquidity_offset_half_life)
- .penalty_msat(amount_msat, self.params)
+ .penalty_msat(amount_msat, &self.params)
}
fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
#[inline]
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
write_tlv_fields!(w, {
- (0, self.channel_liquidities, required)
+ (0, self.channel_liquidities, required),
});
Ok(())
}
let (params, network_graph, logger) = args;
let mut channel_liquidities = HashMap::new();
read_tlv_fields!(r, {
- (0, channel_liquidities, required)
+ (0, channel_liquidities, required),
});
Ok(Self {
params,
liquidity_offset_half_life: Duration::from_secs(10),
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ let mut scorer = ProbabilisticScorer::new(params.clone(), &network_graph, &logger);
let source = source_node_id();
let target = target_node_id();
let usage = ChannelUsage {
liquidity_offset_half_life: Duration::from_secs(10),
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ let mut scorer = ProbabilisticScorer::new(params.clone(), &network_graph, &logger);
let source = source_node_id();
let target = target_node_id();
let usage = ChannelUsage {
let logger = TestLogger::new();
let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters::default();
- let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ let scorer = ProbabilisticScorer::new(params.clone(), &network_graph, &logger);
let source = source_node_id();
let target = target_node_id();
projects / rust-lightning / commitdiff