X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fscoring.rs;h=3c451098eef369b2de1cd513c96bd586145dd5af;hb=608c8adfd575ffb26d4485ebd74f42aabc64c6ad;hp=d1195dc8d674b343fcb769f9490724e4a4c14d21;hpb=4cd990142780233d163b68f21ada293656ca6b54;p=rust-lightning diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs index d1195dc8..3c451098 100644 --- a/lightning/src/routing/scoring.rs +++ b/lightning/src/routing/scoring.rs @@ -20,7 +20,7 @@ //! # use lightning::routing::gossip::NetworkGraph; //! # use lightning::routing::router::{RouteParameters, find_route}; //! # use lightning::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringParameters}; -//! # use lightning::chain::keysinterface::{KeysManager, KeysInterface}; +//! # use lightning::chain::keysinterface::KeysManager; //! # use lightning::util::logger::{Logger, Record}; //! # use bitcoin::secp256k1::PublicKey; //! # @@ -54,21 +54,21 @@ //! //! [`find_route`]: crate::routing::router::find_route -use ln::msgs::DecodeError; -use routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; -use routing::router::RouteHop; -use util::ser::{Readable, ReadableArgs, Writeable, Writer}; -use util::logger::Logger; -use util::time::Time; +use crate::ln::msgs::DecodeError; +use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; +use crate::routing::router::RouteHop; +use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer}; +use crate::util::logger::Logger; +use crate::util::time::Time; -use prelude::*; +use crate::prelude::*; use core::{cmp, fmt}; use core::cell::{RefCell, RefMut}; use core::convert::TryInto; use core::ops::{Deref, DerefMut}; use core::time::Duration; -use io::{self, Read}; -use sync::{Mutex, MutexGuard}; +use crate::io::{self, Read}; +use crate::sync::{Mutex, MutexGuard}; /// We define Score ever-so-slightly differently based on whether we are being built for C bindings /// or not. For users, `LockableScore` must somehow be writeable to disk. For Rust users, this is @@ -225,6 +225,16 @@ impl<'a, T: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore { } } +#[cfg(c_bindings)] +impl Writeable for MultiThreadedLockableScore { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { + self.lock().write(writer) + } +} + +#[cfg(c_bindings)] +impl<'a, T: Score + 'a> WriteableScore<'a> for MultiThreadedLockableScore {} + #[cfg(c_bindings)] impl MultiThreadedLockableScore { /// Creates a new [`MultiThreadedLockableScore`] given an underlying [`Score`]. @@ -309,25 +319,34 @@ impl ReadableArgs for FixedPenaltyScorer { #[cfg(not(feature = "no-std"))] type ConfiguredTime = std::time::Instant; #[cfg(feature = "no-std")] -use util::time::Eternity; +use crate::util::time::Eternity; #[cfg(feature = "no-std")] type ConfiguredTime = Eternity; /// [`Score`] implementation using channel success probability distributions. /// -/// Based on *Optimally Reliable & Cheap Payment Flows on the Lightning Network* by Rene Pickhardt -/// and Stefan Richter [[1]]. Given the uncertainty of channel liquidity balances, probability -/// distributions are defined based on knowledge learned from successful and unsuccessful attempts. -/// Then the negative `log10` of the success probability is used to determine the cost of routing a -/// specific HTLC amount through a channel. +/// Channels are tracked with upper and lower liquidity bounds - when an HTLC fails at a channel, +/// we learn that the upper-bound on the available liquidity is lower than the amount of the HTLC. +/// When a payment is forwarded through a channel (but fails later in the route), we learn the +/// lower-bound on the channel's available liquidity must be at least the value of the HTLC. /// -/// Knowledge about channel liquidity balances takes the form of upper and lower bounds on the -/// possible liquidity. Certainty of the bounds is decreased over time using a decay function. See -/// [`ProbabilisticScoringParameters`] for details. +/// These bounds are then used to determine a success probability using the formula from +/// *Optimally Reliable & Cheap Payment Flows on the Lightning Network* by Rene Pickhardt +/// and Stefan Richter [[1]] (i.e. `(upper_bound - payment_amount) / (upper_bound - lower_bound)`). /// -/// Since the scorer aims to learn the current channel liquidity balances, it works best for nodes -/// with high payment volume or that actively probe the [`NetworkGraph`]. Nodes with low payment -/// volume are more likely to experience failed payment paths, which would need to be retried. +/// This probability is combined with the [`liquidity_penalty_multiplier_msat`] and +/// [`liquidity_penalty_amount_multiplier_msat`] parameters to calculate a concrete penalty in +/// milli-satoshis. The penalties, when added across all hops, have the property of being linear in +/// terms of the entire path's success probability. This allows the router to directly compare +/// penalties for different paths. See the documentation of those parameters for the exact formulas. +/// +/// The liquidity bounds are decayed by halving them every [`liquidity_offset_half_life`]. +/// +/// Further, we track the history of our upper and lower liquidity bounds for each channel, +/// allowing us to assign a second penalty (using [`historical_liquidity_penalty_multiplier_msat`] +/// and [`historical_liquidity_penalty_amount_multiplier_msat`]) based on the same probability +/// formula, but using the history of a channel rather than our latest estimates for the liquidity +/// bounds. /// /// # Note /// @@ -335,6 +354,11 @@ type ConfiguredTime = Eternity; /// behavior. /// /// [1]: https://arxiv.org/abs/2107.05322 +/// [`liquidity_penalty_multiplier_msat`]: ProbabilisticScoringParameters::liquidity_penalty_multiplier_msat +/// [`liquidity_penalty_amount_multiplier_msat`]: ProbabilisticScoringParameters::liquidity_penalty_amount_multiplier_msat +/// [`liquidity_offset_half_life`]: ProbabilisticScoringParameters::liquidity_offset_half_life +/// [`historical_liquidity_penalty_multiplier_msat`]: ProbabilisticScoringParameters::historical_liquidity_penalty_multiplier_msat +/// [`historical_liquidity_penalty_amount_multiplier_msat`]: ProbabilisticScoringParameters::historical_liquidity_penalty_amount_multiplier_msat pub type ProbabilisticScorer = ProbabilisticScorerUsingTime::; /// Probabilistic [`Score`] implementation. @@ -388,19 +412,27 @@ pub struct ProbabilisticScoringParameters { /// uncertainty bounds of the channel liquidity balance. Amounts above the upper bound will /// result in a `u64::max_value` penalty, however. /// + /// `-log10(success_probability) * liquidity_penalty_multiplier_msat` + /// /// Default value: 30,000 msat /// /// [`liquidity_offset_half_life`]: Self::liquidity_offset_half_life pub liquidity_penalty_multiplier_msat: u64, - /// The time required to elapse before any knowledge learned about channel liquidity balances is - /// cut in half. + /// Whenever this amount of time elapses since the last update to a channel's liquidity bounds, + /// the distance from the bounds to "zero" is cut in half. In other words, the lower-bound on + /// the available liquidity is halved and the upper-bound moves half-way to the channel's total + /// capacity. /// - /// The bounds are defined in terms of offsets and are initially zero. Increasing the offsets - /// gives tighter bounds on the channel liquidity balance. Thus, halving the offsets decreases - /// the certainty of the channel liquidity balance. + /// Because halving the liquidity bounds grows the uncertainty on the channel's liquidity, + /// the penalty for an amount within the new bounds may change. See the [`ProbabilisticScorer`] + /// struct documentation for more info on the way the liquidity bounds are used. /// - /// Default value: 1 hour + /// For example, if the channel's capacity is 1 million sats, and the current upper and lower + /// liquidity bounds are 200,000 sats and 600,000 sats, after this amount of time the upper + /// and lower liquidity bounds will be decayed to 100,000 and 800,000 sats. + /// + /// Default value: 6 hours /// /// # Note /// @@ -758,7 +790,7 @@ impl ProbabilisticScoringParameters { base_penalty_msat: 0, base_penalty_amount_multiplier_msat: 0, liquidity_penalty_multiplier_msat: 0, - liquidity_offset_half_life: Duration::from_secs(3600), + liquidity_offset_half_life: Duration::from_secs(6 * 60 * 60), liquidity_penalty_amount_multiplier_msat: 0, historical_liquidity_penalty_multiplier_msat: 0, historical_liquidity_penalty_amount_multiplier_msat: 0, @@ -784,7 +816,7 @@ impl Default for ProbabilisticScoringParameters { base_penalty_msat: 500, base_penalty_amount_multiplier_msat: 8192, liquidity_penalty_multiplier_msat: 30_000, - liquidity_offset_half_life: Duration::from_secs(3600), + liquidity_offset_half_life: Duration::from_secs(6 * 60 * 60), liquidity_penalty_amount_multiplier_msat: 192, historical_liquidity_penalty_multiplier_msat: 10_000, historical_liquidity_penalty_amount_multiplier_msat: 64, @@ -1081,7 +1113,7 @@ impl>, L: Deref, T: Time> Score for Probabilis return base_penalty_msat; } }, - EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat: Some(htlc_maximum_msat) } => { + EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat } => { if htlc_maximum_msat >= capacity_msat/2 { anti_probing_penalty_msat = self.params.anti_probing_penalty_msat; } @@ -1111,31 +1143,32 @@ impl>, L: Deref, T: Time> Score for Probabilis .get(&hop.short_channel_id) .and_then(|channel| channel.as_directed_to(&target)); - if hop.short_channel_id == short_channel_id && hop_idx == 0 { + let at_failed_channel = hop.short_channel_id == short_channel_id; + if at_failed_channel && hop_idx == 0 { log_warn!(self.logger, "Payment failed at the first hop - we do not attempt to learn channel info in such cases as we can directly observe local state.\n\tBecause we know the local state, we should generally not see failures here - this may be an indication that your channel peer on channel {} is broken and you may wish to close the channel.", hop.short_channel_id); } // Only score announced channels. if let Some((channel, source)) = channel_directed_from_source { let capacity_msat = channel.effective_capacity().as_msat(); - if hop.short_channel_id == short_channel_id { + if at_failed_channel { self.channel_liquidities .entry(hop.short_channel_id) .or_insert_with(ChannelLiquidity::new) .as_directed_mut(source, &target, capacity_msat, &self.params) .failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger); - break; + } else { + self.channel_liquidities + .entry(hop.short_channel_id) + .or_insert_with(ChannelLiquidity::new) + .as_directed_mut(source, &target, capacity_msat, &self.params) + .failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger); } - - self.channel_liquidities - .entry(hop.short_channel_id) - .or_insert_with(ChannelLiquidity::new) - .as_directed_mut(source, &target, capacity_msat, &self.params) - .failed_downstream(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger); } else { log_debug!(self.logger, "Not able to penalize channel with SCID {} as we do not have graph info for it (likely a route-hint last-hop).", hop.short_channel_id); } + if at_failed_channel { break; } } } @@ -1569,16 +1602,17 @@ impl Readable for ChannelLiquidity { #[cfg(test)] mod tests { use super::{ChannelLiquidity, HistoricalBucketRangeTracker, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime}; - use util::time::Time; - use util::time::tests::SinceEpoch; - - use ln::channelmanager; - use ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate}; - use routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; - use routing::router::RouteHop; - use routing::scoring::{ChannelUsage, Score}; - use util::ser::{ReadableArgs, Writeable}; - use util::test_utils::TestLogger; + use crate::util::config::UserConfig; + use crate::util::time::Time; + use crate::util::time::tests::SinceEpoch; + + use crate::ln::channelmanager; + use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate}; + use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId}; + use crate::routing::router::RouteHop; + use crate::routing::scoring::{ChannelUsage, Score}; + use crate::util::ser::{ReadableArgs, Writeable}; + use crate::util::test_utils::TestLogger; use bitcoin::blockdata::constants::genesis_block; use bitcoin::hashes::Hash; @@ -1586,7 +1620,7 @@ mod tests { use bitcoin::network::constants::Network; use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; use core::time::Duration; - use io; + use crate::io; fn source_privkey() -> SecretKey { SecretKey::from_slice(&[42; 32]).unwrap() @@ -1663,7 +1697,7 @@ mod tests { let node_2_secret = &SecretKey::from_slice(&[40; 32]).unwrap(); let secp_ctx = Secp256k1::new(); let unsigned_announcement = UnsignedChannelAnnouncement { - features: channelmanager::provided_channel_features(), + features: channelmanager::provided_channel_features(&UserConfig::default()), chain_hash: genesis_hash, short_channel_id, node_id_1: PublicKey::from_secret_key(&secp_ctx, &node_1_key), @@ -1680,7 +1714,7 @@ mod tests { bitcoin_signature_2: secp_ctx.sign_ecdsa(&msghash, &node_2_secret), contents: unsigned_announcement, }; - let chain_source: Option<&::util::test_utils::TestChainSource> = None; + let chain_source: Option<&crate::util::test_utils::TestChainSource> = None; network_graph.update_channel_from_announcement( &signed_announcement, &chain_source).unwrap(); update_channel(network_graph, short_channel_id, node_1_key, 0); @@ -1713,32 +1747,23 @@ mod tests { network_graph.update_channel(&signed_update).unwrap(); } + fn path_hop(pubkey: PublicKey, short_channel_id: u64, fee_msat: u64) -> RouteHop { + let config = UserConfig::default(); + RouteHop { + pubkey, + node_features: channelmanager::provided_node_features(&config), + short_channel_id, + channel_features: channelmanager::provided_channel_features(&config), + fee_msat, + cltv_expiry_delta: 18, + } + } + fn payment_path_for_amount(amount_msat: u64) -> Vec { vec![ - RouteHop { - pubkey: source_pubkey(), - node_features: channelmanager::provided_node_features(), - short_channel_id: 41, - channel_features: channelmanager::provided_channel_features(), - fee_msat: 1, - cltv_expiry_delta: 18, - }, - RouteHop { - pubkey: target_pubkey(), - node_features: channelmanager::provided_node_features(), - short_channel_id: 42, - channel_features: channelmanager::provided_channel_features(), - fee_msat: 2, - cltv_expiry_delta: 18, - }, - RouteHop { - pubkey: recipient_pubkey(), - node_features: channelmanager::provided_node_features(), - short_channel_id: 43, - channel_features: channelmanager::provided_channel_features(), - fee_msat: amount_msat, - cltv_expiry_delta: 18, - }, + path_hop(source_pubkey(), 41, 1), + path_hop(target_pubkey(), 42, 2), + path_hop(recipient_pubkey(), 43, amount_msat), ] } @@ -1953,7 +1978,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 1_024, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); let usage = ChannelUsage { amount_msat: 10_240, ..usage }; @@ -1966,7 +1991,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 128, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 58); let usage = ChannelUsage { amount_msat: 256, ..usage }; @@ -2006,7 +2031,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 39, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 100, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 100, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); let usage = ChannelUsage { amount_msat: 50, ..usage }; @@ -2030,7 +2055,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 500, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; let failed_path = payment_path_for_amount(500); let successful_path = payment_path_for_amount(200); @@ -2060,7 +2085,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 250, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 128); let usage = ChannelUsage { amount_msat: 500, ..usage }; @@ -2095,7 +2120,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 250, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 128); let usage = ChannelUsage { amount_msat: 500, ..usage }; @@ -2113,6 +2138,65 @@ mod tests { assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); } + #[test] + fn ignores_channels_after_removed_failed_channel() { + // Previously, if we'd tried to send over a channel which was removed from the network + // graph before we call `payment_path_failed` (which is the default if the we get a "no + // such channel" error in the `InvoicePayer`), we would call `failed_downstream` on all + // channels in the route, even ones which they payment never reached. This tests to ensure + // we do not score such channels. + let secp_ctx = Secp256k1::new(); + let logger = TestLogger::new(); + let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); + let mut network_graph = NetworkGraph::new(genesis_hash, &logger); + let secret_a = SecretKey::from_slice(&[42; 32]).unwrap(); + let secret_b = SecretKey::from_slice(&[43; 32]).unwrap(); + let secret_c = SecretKey::from_slice(&[44; 32]).unwrap(); + let secret_d = SecretKey::from_slice(&[45; 32]).unwrap(); + add_channel(&mut network_graph, 42, secret_a, secret_b); + // Don't add the channel from B -> C. + add_channel(&mut network_graph, 44, secret_c, secret_d); + + let pub_a = PublicKey::from_secret_key(&secp_ctx, &secret_a); + let pub_b = PublicKey::from_secret_key(&secp_ctx, &secret_b); + let pub_c = PublicKey::from_secret_key(&secp_ctx, &secret_c); + let pub_d = PublicKey::from_secret_key(&secp_ctx, &secret_d); + + let path = vec![ + path_hop(pub_b, 42, 1), + path_hop(pub_c, 43, 2), + path_hop(pub_d, 44, 100), + ]; + + let node_a = NodeId::from_pubkey(&pub_a); + let node_b = NodeId::from_pubkey(&pub_b); + let node_c = NodeId::from_pubkey(&pub_c); + let node_d = NodeId::from_pubkey(&pub_d); + + let params = ProbabilisticScoringParameters { + liquidity_penalty_multiplier_msat: 1_000, + ..ProbabilisticScoringParameters::zero_penalty() + }; + let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger); + + let usage = ChannelUsage { + amount_msat: 250, + inflight_htlc_msat: 0, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, + }; + assert_eq!(scorer.channel_penalty_msat(42, &node_a, &node_b, usage), 128); + // Note that a default liquidity bound is used for B -> C as no channel exists + assert_eq!(scorer.channel_penalty_msat(43, &node_b, &node_c, usage), 128); + assert_eq!(scorer.channel_penalty_msat(44, &node_c, &node_d, usage), 128); + + scorer.payment_path_failed(&path.iter().collect::>(), 43); + + assert_eq!(scorer.channel_penalty_msat(42, &node_a, &node_b, usage), 80); + // Note that a default liquidity bound is used for B -> C as no channel exists + assert_eq!(scorer.channel_penalty_msat(43, &node_b, &node_c, usage), 128); + assert_eq!(scorer.channel_penalty_msat(44, &node_c, &node_d, usage), 128); + } + #[test] fn reduces_liquidity_upper_bound_along_path_on_success() { let logger = TestLogger::new(); @@ -2129,7 +2213,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 250, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; let path = payment_path_for_amount(500); @@ -2161,7 +2245,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 0, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_024) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_024 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); let usage = ChannelUsage { amount_msat: 1_023, ..usage }; @@ -2239,7 +2323,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 256, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 125); @@ -2270,7 +2354,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300); @@ -2315,7 +2399,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 500, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; scorer.payment_path_failed(&payment_path_for_amount(500).iter().collect::>(), 42); @@ -2352,7 +2436,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 500, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; scorer.payment_path_failed(&payment_path_for_amount(500).iter().collect::>(), 42); @@ -2389,47 +2473,47 @@ mod tests { let usage = ChannelUsage { amount_msat: 100_000_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 950_000_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 950_000_000, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 4375); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2739); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 2_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 2_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2236); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 3_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 3_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1983); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 4_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 4_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1637); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 5_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 5_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1606); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 6_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 6_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1331); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_450_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_450_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1387); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1379); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 8_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 8_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1363); let usage = ChannelUsage { - effective_capacity: EffectiveCapacity::Total { capacity_msat: 9_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage + effective_capacity: EffectiveCapacity::Total { capacity_msat: 9_950_000_000, htlc_maximum_msat: 1_000 }, ..usage }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1355); } @@ -2443,7 +2527,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 128, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_000 }, }; let params = ProbabilisticScoringParameters { @@ -2479,7 +2563,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 1_000 }, }; let params = ProbabilisticScoringParameters { @@ -2534,7 +2618,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 750, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 }, }; assert_ne!(scorer.channel_penalty_msat(42, &source, &target, usage), u64::max_value()); @@ -2583,7 +2667,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 100, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: Some(1_024) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024, htlc_maximum_msat: 1_024 }, }; // With no historical data the normal liquidity penalty calculation is used. assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 47); @@ -2618,7 +2702,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(1_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 1_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); @@ -2626,7 +2710,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(1_024_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 1_024_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); @@ -2634,7 +2718,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(512_000) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 512_000 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500); @@ -2642,7 +2726,7 @@ mod tests { let usage = ChannelUsage { amount_msat: 512_000, inflight_htlc_msat: 0, - effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: Some(511_999) }, + effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_024_000, htlc_maximum_msat: 511_999 }, }; assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); }