From 84c94a8fd90e61bc0aa27eb57997fc5f1041ccde Mon Sep 17 00:00:00 2001 From: Elias Rohrer Date: Thu, 26 May 2022 18:20:05 -0700 Subject: [PATCH] Remove previously deprecated `Scorer` --- lightning/src/routing/router.rs | 16 +- lightning/src/routing/scoring.rs | 527 +------------------------------ 2 files changed, 4 insertions(+), 539 deletions(-) diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 8731e66d..5d4d4ac1 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -5700,7 +5700,7 @@ mod benches { use chain::keysinterface::{KeysManager,KeysInterface}; use ln::channelmanager::{ChannelCounterparty, ChannelDetails}; use ln::features::{InitFeatures, InvoiceFeatures}; - use routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringParameters, Scorer}; + use routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringParameters}; use util::logger::{Logger, Record}; use util::test_utils::TestLogger; @@ -5772,20 +5772,6 @@ mod benches { generate_routes(bench, &network_graph, scorer, InvoiceFeatures::known()); } - #[bench] - fn generate_routes_with_default_scorer(bench: &mut Bencher) { - let network_graph = read_network_graph(); - let scorer = Scorer::default(); - generate_routes(bench, &network_graph, scorer, InvoiceFeatures::empty()); - } - - #[bench] - fn generate_mpp_routes_with_default_scorer(bench: &mut Bencher) { - let network_graph = read_network_graph(); - let scorer = Scorer::default(); - generate_routes(bench, &network_graph, scorer, InvoiceFeatures::known()); - } - #[bench] fn generate_routes_with_probabilistic_scorer(bench: &mut Bencher) { let logger = TestLogger::new(); diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs index 38e3c838..339979b1 100644 --- a/lightning/src/routing/scoring.rs +++ b/lightning/src/routing/scoring.rs @@ -19,7 +19,7 @@ //! # //! # use lightning::routing::network_graph::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; @@ -259,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")] @@ -285,236 +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, _source: &NodeId, _target: &NodeId, usage: ChannelUsage - ) -> 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_amt_msat = usage.amount_msat; - let capacity_msat = usage.effective_capacity.as_msat() - .saturating_sub(usage.inflight_htlc_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 @@ -1363,7 +1114,7 @@ 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; @@ -1372,7 +1123,7 @@ mod tests { use routing::scoring::{ChannelUsage, Score}; use routing::network_graph::{EffectiveCapacity, NetworkGraph, NodeId}; use routing::router::RouteHop; - use util::ser::{Readable, ReadableArgs, Writeable}; + use util::ser::{ReadableArgs, Writeable}; use util::test_utils::TestLogger; use bitcoin::blockdata::constants::genesis_block; @@ -1383,9 +1134,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() } @@ -1412,275 +1160,6 @@ 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - SinceEpoch::advance(Duration::from_secs(1)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_064); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_128); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_512); - - SinceEpoch::advance(Duration::from_secs(9)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_512); - - SinceEpoch::advance(Duration::from_secs(1)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_256); - - SinceEpoch::advance(Duration::from_secs(10 * 8)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_001); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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, &source, &target, usage), 1_000); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_256); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_768); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_000); - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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, &source, &target, usage), 1_128); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_512); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1_256); - - scorer.payment_path_failed(&[], 43); - assert_eq!(scorer.channel_penalty_msat(43, &source, &target, usage), 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, &source, &target, usage), 1_256); - assert_eq!(deserialized_scorer.channel_penalty_msat(43, &source, &target, usage), 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(); - let usage = ChannelUsage { - amount_msat: 1, inflight_htlc_msat: 0, effective_capacity: EffectiveCapacity::Unknown - }; - - scorer.payment_path_failed(&[], 42); - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 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, &source, &target, usage), 1_256); - - SinceEpoch::advance(Duration::from_secs(10)); - assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 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(); - - let usage = ChannelUsage { - amount_msat: 1_000, - 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: 256_999, ..usage }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 0); - - let usage = ChannelUsage { amount_msat: 257_000, ..usage }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 100); - - let usage = ChannelUsage { amount_msat: 258_000, ..usage }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 200); - - let usage = ChannelUsage { amount_msat: 512_000, ..usage }; - assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 256 * 100); - } - // `ProbabilisticScorer` tests /// A probabilistic scorer for testing with time that can be manually advanced. -- 2.30.2