X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fscoring.rs;h=72c27fa238b7e5ec22fcd6cfc8025fa7d6c560c7;hb=79e2af949700281b7333f202a7292e3bf81dc674;hp=cffd2d90533b7290250b5a4886ad8c55fa5462fd;hpb=10f9795149cdfcd5160418d9cb5cee1ae310629d;p=rust-lightning diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs index cffd2d90..72c27fa2 100644 --- a/lightning/src/routing/scoring.rs +++ b/lightning/src/routing/scoring.rs @@ -17,9 +17,9 @@ //! ``` //! # extern crate bitcoin; //! # -//! # use lightning::routing::network_graph::NetworkGraph; +//! # use lightning::routing::gossip::NetworkGraph; //! # use lightning::routing::router::{RouteParameters, find_route}; -//! # use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters, Scorer, ScoringParameters}; +//! # use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters}; //! # use lightning::chain::keysinterface::{KeysManager, KeysInterface}; //! # use lightning::util::logger::{Logger, Record}; //! # use bitcoin::secp256k1::PublicKey; @@ -28,7 +28,7 @@ //! # impl Logger for FakeLogger { //! # fn log(&self, record: &Record) { unimplemented!() } //! # } -//! # fn find_scored_route(payer: PublicKey, route_params: RouteParameters, network_graph: NetworkGraph) { +//! # fn find_scored_route(payer: PublicKey, route_params: RouteParameters, network_graph: NetworkGraph<&FakeLogger>) { //! # let logger = FakeLogger {}; //! # //! // Use the default channel penalties. @@ -43,7 +43,7 @@ //! let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); //! # let random_seed_bytes = [42u8; 32]; //! -//! let route = find_route(&payer, &route_params, &network_graph, None, &logger, &scorer, &random_seed_bytes); +//! let route = find_route(&payer, &route_params, &network_graph.read_only(), None, &logger, &scorer, &random_seed_bytes); //! # } //! ``` //! @@ -55,7 +55,7 @@ //! [`find_route`]: crate::routing::router::find_route use ln::msgs::DecodeError; -use routing::network_graph::{NetworkGraph, NodeId}; +use routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; use routing::router::RouteHop; use util::ser::{Readable, ReadableArgs, Writeable, Writer}; use util::logger::Logger; @@ -93,7 +93,9 @@ pub trait Score $(: $supertrait)* { /// such as a chain data, network gossip, or invoice hints. For invoice hints, a capacity near /// [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount. /// Thus, implementations should be overflow-safe. - fn channel_penalty_msat(&self, short_channel_id: u64, send_amt_msat: u64, capacity_msat: u64, source: &NodeId, target: &NodeId) -> u64; + fn channel_penalty_msat( + &self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage + ) -> u64; /// Handles updating channel penalties after failing to route through a channel. fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64); @@ -103,8 +105,10 @@ pub trait Score $(: $supertrait)* { } impl $(+ $supertrait)*> Score for T { - fn channel_penalty_msat(&self, short_channel_id: u64, send_amt_msat: u64, capacity_msat: u64, source: &NodeId, target: &NodeId) -> u64 { - self.deref().channel_penalty_msat(short_channel_id, send_amt_msat, capacity_msat, source, target) + fn channel_penalty_msat( + &self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage + ) -> u64 { + self.deref().channel_penalty_msat(short_channel_id, source, target, usage) } fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) { @@ -202,6 +206,20 @@ impl<'a, S: Writeable> Writeable for MutexGuard<'a, S> { } } +/// Proposed use of a channel passed as a parameter to [`Score::channel_penalty_msat`]. +#[derive(Clone, Copy)] +pub struct ChannelUsage { + /// The amount to send through the channel, denominated in millisatoshis. + pub amount_msat: u64, + + /// Total amount, denominated in millisatoshis, already allocated to send through the channel + /// as part of a multi-path payment. + pub inflight_htlc_msat: u64, + + /// The effective capacity of the channel. + pub effective_capacity: EffectiveCapacity, +} + #[derive(Clone)] /// [`Score`] implementation that uses a fixed penalty. pub struct FixedPenaltyScorer { @@ -216,7 +234,7 @@ impl FixedPenaltyScorer { } impl Score for FixedPenaltyScorer { - fn channel_penalty_msat(&self, _: u64, _: u64, _: u64, _: &NodeId, _: &NodeId) -> u64 { + fn channel_penalty_msat(&self, _: u64, _: &NodeId, _: &NodeId, _: ChannelUsage) -> u64 { self.penalty_msat } @@ -241,25 +259,6 @@ impl ReadableArgs for FixedPenaltyScorer { } } -/// [`Score`] implementation that provides reasonable default behavior. -/// -/// Used to apply a fixed penalty to each channel, thus avoiding long paths when shorter paths with -/// slightly higher fees are available. Will further penalize channels that fail to relay payments. -/// -/// See [module-level documentation] for usage and [`ScoringParameters`] for customization. -/// -/// # Note -/// -/// Mixing the `no-std` feature between serialization and deserialization results in undefined -/// behavior. -/// -/// [module-level documentation]: crate::routing::scoring -#[deprecated( - since = "0.0.105", - note = "ProbabilisticScorer should be used instead of Scorer.", -)] -pub type Scorer = ScorerUsingTime::; - #[cfg(not(feature = "no-std"))] type ConfiguredTime = std::time::Instant; #[cfg(feature = "no-std")] @@ -267,233 +266,6 @@ use util::time::Eternity; #[cfg(feature = "no-std")] type ConfiguredTime = Eternity; -// Note that ideally we'd hide ScorerUsingTime from public view by sealing it as well, but rustdoc -// doesn't handle this well - instead exposing a `Scorer` which has no trait implementation(s) or -// methods at all. - -/// [`Score`] implementation. -/// -/// (C-not exported) generally all users should use the [`Scorer`] type alias. -pub struct ScorerUsingTime { - params: ScoringParameters, - // TODO: Remove entries of closed channels. - channel_failures: HashMap>, -} - -#[derive(Clone)] -/// Parameters for configuring [`Scorer`]. -pub struct ScoringParameters { - /// A fixed penalty in msats to apply to each channel. - /// - /// Default value: 500 msat - pub base_penalty_msat: u64, - - /// A penalty in msats to apply to a channel upon failing to relay a payment. - /// - /// This accumulates for each failure but may be reduced over time based on - /// [`failure_penalty_half_life`] or when successfully routing through a channel. - /// - /// Default value: 1,024,000 msat - /// - /// [`failure_penalty_half_life`]: Self::failure_penalty_half_life - pub failure_penalty_msat: u64, - - /// When the amount being sent over a channel is this many 1024ths of the total channel - /// capacity, we begin applying [`overuse_penalty_msat_per_1024th`]. - /// - /// Default value: 128 1024ths (i.e. begin penalizing when an HTLC uses 1/8th of a channel) - /// - /// [`overuse_penalty_msat_per_1024th`]: Self::overuse_penalty_msat_per_1024th - pub overuse_penalty_start_1024th: u16, - - /// A penalty applied, per whole 1024ths of the channel capacity which the amount being sent - /// over the channel exceeds [`overuse_penalty_start_1024th`] by. - /// - /// Default value: 20 msat (i.e. 2560 msat penalty to use 1/4th of a channel, 7680 msat penalty - /// to use half a channel, and 12,560 msat penalty to use 3/4ths of a channel) - /// - /// [`overuse_penalty_start_1024th`]: Self::overuse_penalty_start_1024th - pub overuse_penalty_msat_per_1024th: u64, - - /// The time required to elapse before any accumulated [`failure_penalty_msat`] penalties are - /// cut in half. - /// - /// Successfully routing through a channel will immediately cut the penalty in half as well. - /// - /// Default value: 1 hour - /// - /// # Note - /// - /// When built with the `no-std` feature, time will never elapse. Therefore, this penalty will - /// never decay. - /// - /// [`failure_penalty_msat`]: Self::failure_penalty_msat - pub failure_penalty_half_life: Duration, -} - -impl_writeable_tlv_based!(ScoringParameters, { - (0, base_penalty_msat, required), - (1, overuse_penalty_start_1024th, (default_value, 128)), - (2, failure_penalty_msat, required), - (3, overuse_penalty_msat_per_1024th, (default_value, 20)), - (4, failure_penalty_half_life, required), -}); - -/// Accounting for penalties against a channel for failing to relay any payments. -/// -/// Penalties decay over time, though accumulate as more failures occur. -struct ChannelFailure { - /// Accumulated penalty in msats for the channel as of `last_updated`. - undecayed_penalty_msat: u64, - - /// Last time the channel either failed to route or successfully routed a payment. Used to decay - /// `undecayed_penalty_msat`. - last_updated: T, -} - -impl ScorerUsingTime { - /// Creates a new scorer using the given scoring parameters. - pub fn new(params: ScoringParameters) -> Self { - Self { - params, - channel_failures: HashMap::new(), - } - } -} - -impl ChannelFailure { - fn new(failure_penalty_msat: u64) -> Self { - Self { - undecayed_penalty_msat: failure_penalty_msat, - last_updated: T::now(), - } - } - - fn add_penalty(&mut self, failure_penalty_msat: u64, half_life: Duration) { - self.undecayed_penalty_msat = self.decayed_penalty_msat(half_life) + failure_penalty_msat; - self.last_updated = T::now(); - } - - fn reduce_penalty(&mut self, half_life: Duration) { - self.undecayed_penalty_msat = self.decayed_penalty_msat(half_life) >> 1; - self.last_updated = T::now(); - } - - fn decayed_penalty_msat(&self, half_life: Duration) -> u64 { - self.last_updated.elapsed().as_secs() - .checked_div(half_life.as_secs()) - .and_then(|decays| self.undecayed_penalty_msat.checked_shr(decays as u32)) - .unwrap_or(0) - } -} - -impl Default for ScorerUsingTime { - fn default() -> Self { - Self::new(ScoringParameters::default()) - } -} - -impl Default for ScoringParameters { - fn default() -> Self { - Self { - base_penalty_msat: 500, - failure_penalty_msat: 1024 * 1000, - failure_penalty_half_life: Duration::from_secs(3600), - overuse_penalty_start_1024th: 1024 / 8, - overuse_penalty_msat_per_1024th: 20, - } - } -} - -impl Score for ScorerUsingTime { - fn channel_penalty_msat( - &self, short_channel_id: u64, send_amt_msat: u64, capacity_msat: u64, _source: &NodeId, _target: &NodeId - ) -> u64 { - let failure_penalty_msat = self.channel_failures - .get(&short_channel_id) - .map_or(0, |value| value.decayed_penalty_msat(self.params.failure_penalty_half_life)); - - let mut penalty_msat = self.params.base_penalty_msat + failure_penalty_msat; - let send_1024ths = send_amt_msat.checked_mul(1024).unwrap_or(u64::max_value()) / capacity_msat; - if send_1024ths > self.params.overuse_penalty_start_1024th as u64 { - penalty_msat = penalty_msat.checked_add( - (send_1024ths - self.params.overuse_penalty_start_1024th as u64) - .checked_mul(self.params.overuse_penalty_msat_per_1024th).unwrap_or(u64::max_value())) - .unwrap_or(u64::max_value()); - } - - penalty_msat - } - - fn payment_path_failed(&mut self, _path: &[&RouteHop], short_channel_id: u64) { - let failure_penalty_msat = self.params.failure_penalty_msat; - let half_life = self.params.failure_penalty_half_life; - self.channel_failures - .entry(short_channel_id) - .and_modify(|failure| failure.add_penalty(failure_penalty_msat, half_life)) - .or_insert_with(|| ChannelFailure::new(failure_penalty_msat)); - } - - fn payment_path_successful(&mut self, path: &[&RouteHop]) { - let half_life = self.params.failure_penalty_half_life; - for hop in path.iter() { - self.channel_failures - .entry(hop.short_channel_id) - .and_modify(|failure| failure.reduce_penalty(half_life)); - } - } -} - -impl Writeable for ScorerUsingTime { - #[inline] - fn write(&self, w: &mut W) -> Result<(), io::Error> { - self.params.write(w)?; - self.channel_failures.write(w)?; - write_tlv_fields!(w, {}); - Ok(()) - } -} - -impl Readable for ScorerUsingTime { - #[inline] - fn read(r: &mut R) -> Result { - let res = Ok(Self { - params: Readable::read(r)?, - channel_failures: Readable::read(r)?, - }); - read_tlv_fields!(r, {}); - res - } -} - -impl Writeable for ChannelFailure { - #[inline] - fn write(&self, w: &mut W) -> Result<(), io::Error> { - let duration_since_epoch = T::duration_since_epoch() - self.last_updated.elapsed(); - write_tlv_fields!(w, { - (0, self.undecayed_penalty_msat, required), - (2, duration_since_epoch, required), - }); - Ok(()) - } -} - -impl Readable for ChannelFailure { - #[inline] - fn read(r: &mut R) -> Result { - let mut undecayed_penalty_msat = 0; - let mut duration_since_epoch = Duration::from_secs(0); - read_tlv_fields!(r, { - (0, undecayed_penalty_msat, required), - (2, duration_since_epoch, required), - }); - Ok(Self { - undecayed_penalty_msat, - last_updated: T::now() - (T::duration_since_epoch() - duration_since_epoch), - }) - } -} - /// [`Score`] implementation using channel success probability distributions. /// /// Based on *Optimally Reliable & Cheap Payment Flows on the Lightning Network* by Rene Pickhardt @@ -521,7 +293,8 @@ pub type ProbabilisticScorer = ProbabilisticScorerUsingTime::, L: Deref, T: Time> where L::Target: Logger { +pub struct ProbabilisticScorerUsingTime>, L: Deref, T: Time> +where L::Target: Logger { params: ProbabilisticScoringParameters, network_graph: G, logger: L, @@ -533,7 +306,7 @@ pub struct ProbabilisticScorerUsingTime, L: Dere /// /// 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. /// @@ -588,6 +361,11 @@ 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. + /// + /// (C-not exported) + pub banned_nodes: HashSet, } /// Accounting for channel liquidity balance uncertainty. @@ -617,7 +395,7 @@ struct DirectedChannelLiquidity, T: Time, U: Deref, L: Deref, T: Time> ProbabilisticScorerUsingTime where L::Target: Logger { +impl>, L: Deref, T: Time> ProbabilisticScorerUsingTime where L::Target: Logger { /// Creates a new scorer using the given scoring parameters for sending payments from a node /// through a network graph. pub fn new(params: ProbabilisticScoringParameters, network_graph: G, logger: L) -> Self { @@ -661,6 +439,39 @@ impl, L: Deref, T: Time> ProbabilisticScorerUsin } } } + + /// Query the estimated minimum and maximum liquidity available for sending a payment over the + /// channel with `scid` towards the given `target` node. + pub fn estimated_channel_liquidity_range(&self, scid: u64, target: &NodeId) -> Option<(u64, u64)> { + let graph = self.network_graph.read_only(); + + if let Some(chan) = graph.channels().get(&scid) { + if let Some(liq) = self.channel_liquidities.get(&scid) { + if let Some((directed_info, source)) = chan.as_directed_to(target) { + let amt = directed_info.effective_capacity().as_msat(); + let dir_liq = liq.as_directed(source, target, amt, self.params.liquidity_offset_half_life); + return Some((dir_liq.min_liquidity_msat(), dir_liq.max_liquidity_msat())); + } + } + } + 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 { @@ -671,6 +482,15 @@ 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) { + for id in node_ids { + self.banned_nodes.insert(id); } } } @@ -682,6 +502,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(), } } } @@ -753,7 +574,7 @@ const AMOUNT_PENALTY_DIVISOR: u64 = 1 << 20; impl, T: Time, U: Deref> DirectedChannelLiquidity { /// 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 { @@ -790,7 +611,7 @@ impl, T: Time, U: Deref> DirectedChannelLiqui #[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. @@ -878,17 +699,31 @@ impl, T: Time, U: DerefMut> DirectedChanne } } -impl, L: Deref, T: Time> Score for ProbabilisticScorerUsingTime where L::Target: Logger { +impl>, L: Deref, T: Time> Score for ProbabilisticScorerUsingTime where L::Target: Logger { fn channel_penalty_msat( - &self, short_channel_id: u64, amount_msat: u64, capacity_msat: u64, source: &NodeId, - target: &NodeId + &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(); + } else { + return self.params.base_penalty_msat; + }; + } + let liquidity_offset_half_life = self.params.liquidity_offset_half_life; + let amount_msat = usage.amount_msat; + let capacity_msat = usage.effective_capacity.as_msat() + .saturating_sub(usage.inflight_htlc_msat); self.channel_liquidities .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) { @@ -1268,17 +1103,17 @@ mod approx { } } -impl, L: Deref, T: Time> Writeable for ProbabilisticScorerUsingTime where L::Target: Logger { +impl>, L: Deref, T: Time> Writeable for ProbabilisticScorerUsingTime where L::Target: Logger { #[inline] fn write(&self, w: &mut W) -> Result<(), io::Error> { write_tlv_fields!(w, { - (0, self.channel_liquidities, required) + (0, self.channel_liquidities, required), }); Ok(()) } } -impl, L: Deref, T: Time> +impl>, L: Deref, T: Time> ReadableArgs<(ProbabilisticScoringParameters, G, L)> for ProbabilisticScorerUsingTime where L::Target: Logger { #[inline] fn read( @@ -1287,7 +1122,7 @@ ReadableArgs<(ProbabilisticScoringParameters, G, L)> for ProbabilisticScorerUsin 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, @@ -1332,16 +1167,16 @@ impl Readable for ChannelLiquidity { #[cfg(test)] mod tests { - use super::{ChannelLiquidity, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime, ScoringParameters, ScorerUsingTime}; + use super::{ChannelLiquidity, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime}; use util::time::Time; use util::time::tests::SinceEpoch; use ln::features::{ChannelFeatures, NodeFeatures}; use ln::msgs::{ChannelAnnouncement, ChannelUpdate, OptionalField, UnsignedChannelAnnouncement, UnsignedChannelUpdate}; - use routing::scoring::Score; - use routing::network_graph::{NetworkGraph, NodeId}; + use routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; use routing::router::RouteHop; - use util::ser::{Readable, ReadableArgs, Writeable}; + use routing::scoring::{ChannelUsage, Score}; + use util::ser::{ReadableArgs, Writeable}; use util::test_utils::TestLogger; use bitcoin::blockdata::constants::genesis_block; @@ -1352,9 +1187,6 @@ mod tests { use core::time::Duration; use io; - /// A scorer for testing with time that can be manually advanced. - type Scorer = ScorerUsingTime::; - fn source_privkey() -> SecretKey { SecretKey::from_slice(&[42; 32]).unwrap() } @@ -1381,242 +1213,10 @@ mod tests { NodeId::from_pubkey(&target_pubkey()) } - #[test] - fn penalizes_without_channel_failures() { - let scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(1), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - SinceEpoch::advance(Duration::from_secs(1)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - } - - #[test] - fn accumulates_channel_failure_penalties() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 64, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_064); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_128); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_192); - } - - #[test] - fn decays_channel_failure_penalties_over_time() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - SinceEpoch::advance(Duration::from_secs(9)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - SinceEpoch::advance(Duration::from_secs(1)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - - SinceEpoch::advance(Duration::from_secs(10 * 8)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_001); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - } - - #[test] - fn decays_channel_failure_penalties_without_shift_overflow() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - // An unchecked right shift 64 bits or more in ChannelFailure::decayed_penalty_msat would - // cause an overflow. - SinceEpoch::advance(Duration::from_secs(10 * 64)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - } - - #[test] - fn accumulates_channel_failure_penalties_after_decay() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_768); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_384); - } - - #[test] - fn reduces_channel_failure_penalties_after_success() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - - let hop = RouteHop { - pubkey: PublicKey::from_slice(target.as_slice()).unwrap(), - node_features: NodeFeatures::known(), - short_channel_id: 42, - channel_features: ChannelFeatures::known(), - fee_msat: 1, - cltv_expiry_delta: 18, - }; - scorer.payment_path_successful(&[&hop]); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_128); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_064); - } - - #[test] - fn restores_persisted_channel_failure_penalties() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - - scorer.payment_path_failed(&[], 43); - assert_eq!(scorer.channel_penalty_msat(43, 1, 1, &source, &target), 1_512); - - let mut serialized_scorer = Vec::new(); - scorer.write(&mut serialized_scorer).unwrap(); - - let deserialized_scorer = ::read(&mut io::Cursor::new(&serialized_scorer)).unwrap(); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - assert_eq!(deserialized_scorer.channel_penalty_msat(43, 1, 1, &source, &target), 1_512); - } - - #[test] - fn decays_persisted_channel_failure_penalties() { - let mut scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 1_000, - failure_penalty_msat: 512, - failure_penalty_half_life: Duration::from_secs(10), - overuse_penalty_start_1024th: 1024, - overuse_penalty_msat_per_1024th: 0, - }); - let source = source_node_id(); - let target = target_node_id(); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_512); - - let mut serialized_scorer = Vec::new(); - scorer.write(&mut serialized_scorer).unwrap(); - - SinceEpoch::advance(Duration::from_secs(10)); - - let deserialized_scorer = ::read(&mut io::Cursor::new(&serialized_scorer)).unwrap(); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_256); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 1, 1, &source, &target), 1_128); - } - - #[test] - fn charges_per_1024th_penalty() { - let scorer = Scorer::new(ScoringParameters { - base_penalty_msat: 0, - failure_penalty_msat: 0, - failure_penalty_half_life: Duration::from_secs(0), - overuse_penalty_start_1024th: 256, - overuse_penalty_msat_per_1024th: 100, - }); - let source = source_node_id(); - let target = target_node_id(); - - assert_eq!(scorer.channel_penalty_msat(42, 1_000, 1_024_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 256_999, 1_024_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 257_000, 1_024_000, &source, &target), 100); - assert_eq!(scorer.channel_penalty_msat(42, 258_000, 1_024_000, &source, &target), 200); - assert_eq!(scorer.channel_penalty_msat(42, 512_000, 1_024_000, &source, &target), 256 * 100); - } - // `ProbabilisticScorer` tests /// A probabilistic scorer for testing with time that can be manually advanced. - type ProbabilisticScorer<'a> = ProbabilisticScorerUsingTime::<&'a NetworkGraph, &'a TestLogger, SinceEpoch>; + type ProbabilisticScorer<'a> = ProbabilisticScorerUsingTime::<&'a NetworkGraph<&'a TestLogger>, &'a TestLogger, SinceEpoch>; fn sender_privkey() -> SecretKey { SecretKey::from_slice(&[41; 32]).unwrap() @@ -1644,9 +1244,9 @@ mod tests { NodeId::from_pubkey(&recipient_pubkey()) } - fn network_graph() -> NetworkGraph { + fn network_graph(logger: &TestLogger) -> NetworkGraph<&TestLogger> { let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); - let mut network_graph = NetworkGraph::new(genesis_hash); + let mut network_graph = NetworkGraph::new(genesis_hash, logger); add_channel(&mut network_graph, 42, source_privkey(), target_privkey()); add_channel(&mut network_graph, 43, target_privkey(), recipient_privkey()); @@ -1654,7 +1254,7 @@ mod tests { } fn add_channel( - network_graph: &mut NetworkGraph, short_channel_id: u64, node_1_key: SecretKey, + network_graph: &mut NetworkGraph<&TestLogger>, short_channel_id: u64, node_1_key: SecretKey, node_2_key: SecretKey ) { let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); @@ -1681,13 +1281,14 @@ mod tests { }; let chain_source: Option<&::util::test_utils::TestChainSource> = None; network_graph.update_channel_from_announcement( - &signed_announcement, &chain_source, &secp_ctx).unwrap(); + &signed_announcement, &chain_source).unwrap(); update_channel(network_graph, short_channel_id, node_1_key, 0); update_channel(network_graph, short_channel_id, node_2_key, 1); } fn update_channel( - network_graph: &mut NetworkGraph, short_channel_id: u64, node_key: SecretKey, flags: u8 + network_graph: &mut NetworkGraph<&TestLogger>, short_channel_id: u64, node_key: SecretKey, + flags: u8 ) { let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); let secp_ctx = Secp256k1::new(); @@ -1708,7 +1309,7 @@ mod tests { signature: secp_ctx.sign_ecdsa(&msghash, &node_key), contents: unsigned_update, }; - network_graph.update_channel(&signed_update, &secp_ctx).unwrap(); + network_graph.update_channel(&signed_update).unwrap(); } fn payment_path_for_amount(amount_msat: u64) -> Vec { @@ -1744,7 +1345,7 @@ mod tests { fn liquidity_bounds_directed_from_lowest_node_id() { let logger = TestLogger::new(); let last_updated = SinceEpoch::now(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters::default(); let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger) .with_channel(42, @@ -1819,7 +1420,7 @@ mod tests { fn resets_liquidity_upper_bound_when_crossed_by_lower_bound() { let logger = TestLogger::new(); let last_updated = SinceEpoch::now(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters::default(); let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger) .with_channel(42, @@ -1877,7 +1478,7 @@ mod tests { fn resets_liquidity_lower_bound_when_crossed_by_upper_bound() { let logger = TestLogger::new(); let last_updated = SinceEpoch::now(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters::default(); let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger) .with_channel(42, @@ -1934,7 +1535,7 @@ mod tests { #[test] fn increased_penalty_nearing_liquidity_upper_bound() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -1943,25 +1544,44 @@ mod tests { let source = source_node_id(); let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 1_024, 1_024_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 10_240, 1_024_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 102_400, 1_024_000, &source, &target), 47); - assert_eq!(scorer.channel_penalty_msat(42, 1_024_000, 1_024_000, &source, &target), 2_000); - - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 58); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 125); - assert_eq!(scorer.channel_penalty_msat(42, 374, 1_024, &source, &target), 198); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 300); - assert_eq!(scorer.channel_penalty_msat(42, 640, 1_024, &source, &target), 425); - assert_eq!(scorer.channel_penalty_msat(42, 768, 1_024, &source, &target), 602); - assert_eq!(scorer.channel_penalty_msat(42, 896, 1_024, &source, &target), 902); + let usage = ChannelUsage { + amount_msat: 1_024, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 10_240, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 102_400, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 47); + let usage = ChannelUsage { amount_msat: 1_024_000, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); + + let usage = ChannelUsage { + amount_msat: 128, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 58); + let usage = ChannelUsage { amount_msat: 256, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 125); + let usage = ChannelUsage { amount_msat: 374, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 198); + let usage = ChannelUsage { amount_msat: 512, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); + let usage = ChannelUsage { amount_msat: 640, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 425); + let usage = ChannelUsage { amount_msat: 768, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 602); + let usage = ChannelUsage { amount_msat: 896, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 902); } #[test] fn constant_penalty_outside_liquidity_bounds() { let logger = TestLogger::new(); let last_updated = SinceEpoch::now(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -1974,16 +1594,23 @@ mod tests { let source = source_node_id(); let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 39, 100, &source, &target), 0); - assert_ne!(scorer.channel_penalty_msat(42, 50, 100, &source, &target), 0); - assert_ne!(scorer.channel_penalty_msat(42, 50, 100, &source, &target), u64::max_value()); - assert_eq!(scorer.channel_penalty_msat(42, 61, 100, &source, &target), u64::max_value()); + let usage = ChannelUsage { + amount_msat: 39, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 100 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 50, ..usage }; + assert_ne!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + assert_ne!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); + let usage = ChannelUsage { amount_msat: 61, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); } #[test] fn does_not_further_penalize_own_channel() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -1991,22 +1618,27 @@ mod tests { let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger); let sender = sender_node_id(); let source = source_node_id(); + let usage = ChannelUsage { + amount_msat: 500, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; let failed_path = payment_path_for_amount(500); let successful_path = payment_path_for_amount(200); - assert_eq!(scorer.channel_penalty_msat(41, 500, 1_000, &sender, &source), 301); + assert_eq!(scorer.channel_penalty_msat(41, &sender, &source, usage), 301); scorer.payment_path_failed(&failed_path.iter().collect::>(), 41); - assert_eq!(scorer.channel_penalty_msat(41, 500, 1_000, &sender, &source), 301); + assert_eq!(scorer.channel_penalty_msat(41, &sender, &source, usage), 301); scorer.payment_path_successful(&successful_path.iter().collect::>()); - assert_eq!(scorer.channel_penalty_msat(41, 500, 1_000, &sender, &source), 301); + assert_eq!(scorer.channel_penalty_msat(41, &sender, &source, usage), 301); } #[test] fn sets_liquidity_lower_bound_on_downstream_failure() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -2016,21 +1648,31 @@ mod tests { let target = target_node_id(); let path = payment_path_for_amount(500); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 128); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 301); - assert_eq!(scorer.channel_penalty_msat(42, 750, 1_000, &source, &target), 602); + let usage = ChannelUsage { + amount_msat: 250, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 128); + let usage = ChannelUsage { amount_msat: 500, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 301); + let usage = ChannelUsage { amount_msat: 750, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 602); scorer.payment_path_failed(&path.iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 750, 1_000, &source, &target), 300); + let usage = ChannelUsage { amount_msat: 250, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 500, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 750, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); } #[test] fn sets_liquidity_upper_bound_on_failure() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -2040,21 +1682,31 @@ mod tests { let target = target_node_id(); let path = payment_path_for_amount(500); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 128); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 301); - assert_eq!(scorer.channel_penalty_msat(42, 750, 1_000, &source, &target), 602); + let usage = ChannelUsage { + amount_msat: 250, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 128); + let usage = ChannelUsage { amount_msat: 500, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 301); + let usage = ChannelUsage { amount_msat: 750, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 602); scorer.payment_path_failed(&path.iter().collect::>(), 42); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 300); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), u64::max_value()); - assert_eq!(scorer.channel_penalty_msat(42, 750, 1_000, &source, &target), u64::max_value()); + let usage = ChannelUsage { amount_msat: 250, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); + let usage = ChannelUsage { amount_msat: 500, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); + let usage = ChannelUsage { amount_msat: 750, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); } #[test] fn reduces_liquidity_upper_bound_along_path_on_success() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() @@ -2064,23 +1716,28 @@ mod tests { let source = source_node_id(); let target = target_node_id(); let recipient = recipient_node_id(); + let usage = ChannelUsage { + amount_msat: 250, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; let path = payment_path_for_amount(500); - assert_eq!(scorer.channel_penalty_msat(41, 250, 1_000, &sender, &source), 128); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 128); - assert_eq!(scorer.channel_penalty_msat(43, 250, 1_000, &target, &recipient), 128); + assert_eq!(scorer.channel_penalty_msat(41, &sender, &source, usage), 128); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 128); + assert_eq!(scorer.channel_penalty_msat(43, &target, &recipient, usage), 128); scorer.payment_path_successful(&path.iter().collect::>()); - assert_eq!(scorer.channel_penalty_msat(41, 250, 1_000, &sender, &source), 128); - assert_eq!(scorer.channel_penalty_msat(42, 250, 1_000, &source, &target), 300); - assert_eq!(scorer.channel_penalty_msat(43, 250, 1_000, &target, &recipient), 300); + assert_eq!(scorer.channel_penalty_msat(41, &sender, &source, usage), 128); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); + assert_eq!(scorer.channel_penalty_msat(43, &target, &recipient, usage), 300); } #[test] fn decays_liquidity_bounds_over_time() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, liquidity_offset_half_life: Duration::from_secs(10), @@ -2090,50 +1747,76 @@ mod tests { let source = source_node_id(); let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 0, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 1_024, 1_024, &source, &target), 2_000); + let usage = ChannelUsage { + amount_msat: 0, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 1_024, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); scorer.payment_path_failed(&payment_path_for_amount(768).iter().collect::>(), 42); scorer.payment_path_failed(&payment_path_for_amount(128).iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 93); - assert_eq!(scorer.channel_penalty_msat(42, 768, 1_024, &source, &target), 1_479); - assert_eq!(scorer.channel_penalty_msat(42, 896, 1_024, &source, &target), u64::max_value()); + let usage = ChannelUsage { amount_msat: 128, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 256, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 93); + let usage = ChannelUsage { amount_msat: 768, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_479); + let usage = ChannelUsage { amount_msat: 896, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); SinceEpoch::advance(Duration::from_secs(9)); - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 93); - assert_eq!(scorer.channel_penalty_msat(42, 768, 1_024, &source, &target), 1_479); - assert_eq!(scorer.channel_penalty_msat(42, 896, 1_024, &source, &target), u64::max_value()); + let usage = ChannelUsage { amount_msat: 128, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 256, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 93); + let usage = ChannelUsage { amount_msat: 768, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_479); + let usage = ChannelUsage { amount_msat: 896, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); SinceEpoch::advance(Duration::from_secs(1)); - assert_eq!(scorer.channel_penalty_msat(42, 64, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 34); - assert_eq!(scorer.channel_penalty_msat(42, 896, 1_024, &source, &target), 1_970); - assert_eq!(scorer.channel_penalty_msat(42, 960, 1_024, &source, &target), u64::max_value()); + let usage = ChannelUsage { amount_msat: 64, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 128, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 34); + let usage = ChannelUsage { amount_msat: 896, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_970); + let usage = ChannelUsage { amount_msat: 960, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); // Fully decay liquidity lower bound. SinceEpoch::advance(Duration::from_secs(10 * 7)); - assert_eq!(scorer.channel_penalty_msat(42, 0, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 1, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 1_023, 1_024, &source, &target), 2_000); - assert_eq!(scorer.channel_penalty_msat(42, 1_024, 1_024, &source, &target), 2_000); + let usage = ChannelUsage { amount_msat: 0, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 1, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 1_023, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); + let usage = ChannelUsage { amount_msat: 1_024, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); // Fully decay liquidity upper bound. SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 0, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 1_024, 1_024, &source, &target), 2_000); + let usage = ChannelUsage { amount_msat: 0, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 1_024, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 0, 1_024, &source, &target), 0); - assert_eq!(scorer.channel_penalty_msat(42, 1_024, 1_024, &source, &target), 2_000); + let usage = ChannelUsage { amount_msat: 0, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); + let usage = ChannelUsage { amount_msat: 1_024, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2_000); } #[test] fn decays_liquidity_bounds_without_shift_overflow() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, liquidity_offset_half_life: Duration::from_secs(10), @@ -2142,24 +1825,29 @@ mod tests { let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger); let source = source_node_id(); let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 125); + let usage = ChannelUsage { + amount_msat: 256, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 125); scorer.payment_path_failed(&payment_path_for_amount(512).iter().collect::>(), 42); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 281); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 281); // An unchecked right shift 64 bits or more in DirectedChannelLiquidity::decayed_offset_msat // would cause an overflow. SinceEpoch::advance(Duration::from_secs(10 * 64)); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 125); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 125); SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 256, 1_024, &source, &target), 125); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 125); } #[test] fn restricts_liquidity_bounds_after_decay() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, liquidity_offset_half_life: Duration::from_secs(10), @@ -2168,54 +1856,64 @@ mod tests { let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger); let source = source_node_id(); let target = target_node_id(); + let usage = ChannelUsage { + amount_msat: 512, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024 }, + }; - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 300); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); // More knowledge gives higher confidence (256, 768), meaning a lower penalty. scorer.payment_path_failed(&payment_path_for_amount(768).iter().collect::>(), 42); scorer.payment_path_failed(&payment_path_for_amount(256).iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 281); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 281); // Decaying knowledge gives less confidence (128, 896), meaning a higher penalty. SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 291); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 291); // Reducing the upper bound gives more confidence (128, 832) that the payment amount (512) // is closer to the upper bound, meaning a higher penalty. scorer.payment_path_successful(&payment_path_for_amount(64).iter().collect::>()); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 331); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 331); // Increasing the lower bound gives more confidence (256, 832) that the payment amount (512) // is closer to the lower bound, meaning a lower penalty. scorer.payment_path_failed(&payment_path_for_amount(256).iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 245); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 245); // Further decaying affects the lower bound more than the upper bound (128, 928). SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 512, 1_024, &source, &target), 280); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 280); } #[test] fn restores_persisted_liquidity_bounds() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, 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 { + amount_msat: 500, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; scorer.payment_path_failed(&payment_path_for_amount(500).iter().collect::>(), 42); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 473); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 473); scorer.payment_path_failed(&payment_path_for_amount(250).iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 300); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); let mut serialized_scorer = Vec::new(); scorer.write(&mut serialized_scorer).unwrap(); @@ -2223,24 +1921,29 @@ mod tests { let mut serialized_scorer = io::Cursor::new(&serialized_scorer); let deserialized_scorer = ::read(&mut serialized_scorer, (params, &network_graph, &logger)).unwrap(); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 300); + assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 300); } #[test] fn decays_persisted_liquidity_bounds() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, 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 { + amount_msat: 500, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; scorer.payment_path_failed(&payment_path_for_amount(500).iter().collect::>(), 42); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), u64::max_value()); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); let mut serialized_scorer = Vec::new(); scorer.write(&mut serialized_scorer).unwrap(); @@ -2250,13 +1953,13 @@ mod tests { let mut serialized_scorer = io::Cursor::new(&serialized_scorer); let deserialized_scorer = ::read(&mut serialized_scorer, (params, &network_graph, &logger)).unwrap(); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 473); + assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 473); scorer.payment_path_failed(&payment_path_for_amount(250).iter().collect::>(), 43); - assert_eq!(scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 300); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 365); + assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 365); } #[test] @@ -2264,52 +1967,97 @@ mod tests { // Shows the scores of "realistic" sends of 100k sats over channels of 1-10m sats (with a // 50k sat reserve). let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let params = ProbabilisticScoringParameters::default(); let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); let source = source_node_id(); let target = target_node_id(); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 950_000_000, &source, &target), 3613); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 1_950_000_000, &source, &target), 1977); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 2_950_000_000, &source, &target), 1474); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 3_950_000_000, &source, &target), 1223); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 4_950_000_000, &source, &target), 877); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 5_950_000_000, &source, &target), 845); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 6_950_000_000, &source, &target), 500); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 7_450_000_000, &source, &target), 500); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 7_950_000_000, &source, &target), 500); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 8_950_000_000, &source, &target), 500); - assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 9_950_000_000, &source, &target), 500); + let usage = ChannelUsage { + amount_msat: 100_000_000, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 950_000_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 3613); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1977); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 2_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1474); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 3_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1223); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 4_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 877); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 5_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 845); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 6_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_450_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 8_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); + let usage = ChannelUsage { + effective_capacity: EffectiveCapacity::Total { capacity_msat: 9_950_000_000 }, ..usage + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); } #[test] fn adds_base_penalty_to_liquidity_penalty() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let source = source_node_id(); let target = target_node_id(); + let usage = ChannelUsage { + amount_msat: 128, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024 }, + }; let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, ..ProbabilisticScoringParameters::zero_penalty() }; let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 58); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 58); let params = ProbabilisticScoringParameters { base_penalty_msat: 500, liquidity_penalty_multiplier_msat: 1_000, ..Default::default() }; let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); - assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 558); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 558); } #[test] fn adds_amount_penalty_to_liquidity_penalty() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let source = source_node_id(); let target = target_node_id(); + let usage = ChannelUsage { + amount_msat: 512_000, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000 }, + }; let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, @@ -2317,7 +2065,7 @@ mod tests { ..ProbabilisticScoringParameters::zero_penalty() }; let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); - assert_eq!(scorer.channel_penalty_msat(42, 512_000, 1_024_000, &source, &target), 300); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 1_000, @@ -2325,24 +2073,70 @@ mod tests { ..ProbabilisticScoringParameters::zero_penalty() }; let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); - assert_eq!(scorer.channel_penalty_msat(42, 512_000, 1_024_000, &source, &target), 337); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 337); } #[test] fn calculates_log10_without_overflowing_u64_max_value() { let logger = TestLogger::new(); - let network_graph = network_graph(); + let network_graph = network_graph(&logger); let source = source_node_id(); let target = target_node_id(); + let usage = ChannelUsage { + amount_msat: u64::max_value(), + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Infinite, + }; let params = ProbabilisticScoringParameters { liquidity_penalty_multiplier_msat: 40_000, ..ProbabilisticScoringParameters::zero_penalty() }; let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); - assert_eq!( - scorer.channel_penalty_msat(42, u64::max_value(), u64::max_value(), &source, &target), - 80_000, - ); + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 80_000); + } + + #[test] + fn accounts_for_inflight_htlc_usage() { + let logger = TestLogger::new(); + let network_graph = network_graph(&logger); + let params = ProbabilisticScoringParameters::default(); + let scorer = ProbabilisticScorer::new(params, &network_graph, &logger); + let source = source_node_id(); + let target = target_node_id(); + + let usage = ChannelUsage { + amount_msat: 750, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000 }, + }; + assert_ne!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); + + let usage = ChannelUsage { inflight_htlc_msat: 251, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); + } + + #[test] + fn removes_uncertainity_when_exact_liquidity_known() { + let logger = TestLogger::new(); + let network_graph = network_graph(&logger); + let params = ProbabilisticScoringParameters::default(); + let scorer = ProbabilisticScorer::new(params.clone(), &network_graph, &logger); + let source = source_node_id(); + let target = target_node_id(); + + let base_penalty_msat = params.base_penalty_msat; + let usage = ChannelUsage { + amount_msat: 750, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::ExactLiquidity { liquidity_msat: 1_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), base_penalty_msat); + + let usage = ChannelUsage { amount_msat: 1_000, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), base_penalty_msat); + + let usage = ChannelUsage { amount_msat: 1_001, ..usage }; + assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); } }