//! # Example
//!
//! ```
-//! # extern crate secp256k1;
+//! # 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 secp256k1::key::PublicKey;
+//! # use bitcoin::secp256k1::PublicKey;
//! #
//! # struct FakeLogger {};
//! # 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.
//! let params = ProbabilisticScoringParameters::default();
-//! let scorer = ProbabilisticScorer::new(params, &network_graph);
+//! let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
//!
//! // Or use custom channel penalties.
//! let params = ProbabilisticScoringParameters {
//! liquidity_penalty_multiplier_msat: 2 * 1000,
//! ..ProbabilisticScoringParameters::default()
//! };
-//! let scorer = ProbabilisticScorer::new(params, &network_graph);
+//! 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);
//! [`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;
+use util::time::Time;
use prelude::*;
-use core::cell::{RefCell, RefMut};
+use core::fmt;
+#[cfg(not(c_bindings))]
+use core::cell::RefCell;
+use core::cell::RefMut;
use core::ops::{Deref, DerefMut};
use core::time::Duration;
use io::{self, Read};
/// 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);
}
impl<S: Score, T: DerefMut<Target=S> $(+ $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) {
fn lock(&'a self) -> Self::Locked;
}
-/// (C-not exported)
+/// Refers to a scorer that is accessible under lock and also writeable to disk
+///
+/// We need this trait to be able to pass in a scorer to `lightning-background-processor` that will enable us to
+/// use the Persister to persist it.
+#[cfg(not(c_bindings))] // This doesn't make sense in bindings as all `Score`s are `Writeable`.
+pub trait WriteableScore<'a>: LockableScore<'a> + Writeable {}
+
+#[cfg(not(c_bindings))] // This doesn't make sense in bindings as all `Score`s are `Writeable`.
+impl<'a, T> WriteableScore<'a> for T where T: LockableScore<'a> + Writeable {}
+
+#[cfg(not(c_bindings))]
impl<'a, T: 'a + Score> LockableScore<'a> for Mutex<T> {
type Locked = MutexGuard<'a, T>;
}
}
+#[cfg(not(c_bindings))]
impl<'a, T: 'a + Score> LockableScore<'a> for RefCell<T> {
type Locked = RefMut<'a, T>;
}
#[cfg(c_bindings)]
/// (C-not exported)
-impl<'a, T: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore<T> {
- type Locked = MutexGuard<'a, T>;
+impl<'a, S: Score + 'a> LockableScore<'a> for MultiThreadedLockableScore<S> {
+ type Locked = MutexGuard<'a, S>;
- fn lock(&'a self) -> MutexGuard<'a, T> {
+ fn lock(&'a self) -> MutexGuard<'a, S> {
Mutex::lock(&self.score).unwrap()
}
}
+#[cfg(c_bindings)]
+impl<S: Score> Writeable for MultiThreadedLockableScore<S> {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+ S::write(&*self.lock(), writer)
+ }
+}
+
#[cfg(c_bindings)]
impl<T: Score> MultiThreadedLockableScore<T> {
/// Creates a new [`MultiThreadedLockableScore`] given an underlying [`Score`].
}
}
+/// 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 {
}
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
}
}
}
-/// [`Score`] implementation that provides reasonable default behavior.
+#[cfg(not(feature = "no-std"))]
+/// [`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.
///
-/// 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.
+/// 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.
///
-/// See [module-level documentation] for usage and [`ScoringParameters`] for customization.
+/// 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.
///
/// # 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::<ConfiguredTime>;
-
-#[cfg(not(feature = "no-std"))]
-type ConfiguredTime = std::time::Instant;
+/// [1]: https://arxiv.org/abs/2107.05322
+pub type ProbabilisticScorer<G, L> = ProbabilisticScorerUsingTime::<G, L, std::time::Instant>;
#[cfg(feature = "no-std")]
-type ConfiguredTime = time::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<T: Time> {
- params: ScoringParameters,
- // TODO: Remove entries of closed channels.
- channel_failures: HashMap<u64, ChannelFailure<T>>,
-}
-
-#[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<T: Time> {
- /// 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<T: Time> ScorerUsingTime<T> {
- /// Creates a new scorer using the given scoring parameters.
- pub fn new(params: ScoringParameters) -> Self {
- Self {
- params,
- channel_failures: HashMap::new(),
- }
- }
-}
-
-impl<T: Time> ChannelFailure<T> {
- 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<T: Time> Default for ScorerUsingTime<T> {
- 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<T: Time> Score for ScorerUsingTime<T> {
- 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<T: Time> Writeable for ScorerUsingTime<T> {
- #[inline]
- fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
- self.params.write(w)?;
- self.channel_failures.write(w)?;
- write_tlv_fields!(w, {});
- Ok(())
- }
-}
-
-impl<T: Time> Readable for ScorerUsingTime<T> {
- #[inline]
- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- let res = Ok(Self {
- params: Readable::read(r)?,
- channel_failures: Readable::read(r)?,
- });
- read_tlv_fields!(r, {});
- res
- }
-}
-
-impl<T: Time> Writeable for ChannelFailure<T> {
- #[inline]
- fn write<W: Writer>(&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<T: Time> Readable for ChannelFailure<T> {
- #[inline]
- fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
- 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
/// behavior.
///
/// [1]: https://arxiv.org/abs/2107.05322
-pub type ProbabilisticScorer<G> = ProbabilisticScorerUsingTime::<G, ConfiguredTime>;
+pub type ProbabilisticScorer<G, L> = ProbabilisticScorerUsingTime::<G, L, ::util::time::Eternity>;
/// Probabilistic [`Score`] implementation.
///
/// (C-not exported) generally all users should use the [`ProbabilisticScorer`] type alias.
-pub struct ProbabilisticScorerUsingTime<G: Deref<Target = NetworkGraph>, T: Time> {
+pub struct ProbabilisticScorerUsingTime<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time>
+where L::Target: Logger {
params: ProbabilisticScoringParameters,
network_graph: G,
+ logger: L,
// TODO: Remove entries of closed channels.
channel_liquidities: HashMap<u64, ChannelLiquidity<T>>,
}
half_life: Duration,
}
-impl<G: Deref<Target = NetworkGraph>, T: Time> ProbabilisticScorerUsingTime<G, T> {
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ProbabilisticScorerUsingTime<G, L, T> 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) -> Self {
+ pub fn new(params: ProbabilisticScoringParameters, network_graph: G, logger: L) -> Self {
Self {
params,
network_graph,
+ logger,
channel_liquidities: HashMap::new(),
}
}
assert!(self.channel_liquidities.insert(short_channel_id, liquidity).is_none());
self
}
+
+ /// Dump the contents of this scorer into the configured logger.
+ ///
+ /// Note that this writes roughly one line per channel for which we have a liquidity estimate,
+ /// which may be a substantial amount of log output.
+ pub fn debug_log_liquidity_stats(&self) {
+ let graph = self.network_graph.read_only();
+ for (scid, liq) in self.channel_liquidities.iter() {
+ if let Some(chan_debug) = graph.channels().get(scid) {
+ let log_direction = |source, target| {
+ if let Some((directed_info, _)) = chan_debug.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);
+ log_debug!(self.logger, "Liquidity from {:?} to {:?} via {} is in the range ({}, {})",
+ source, target, scid, dir_liq.min_liquidity_msat(), dir_liq.max_liquidity_msat());
+ } else {
+ log_debug!(self.logger, "No amount known for SCID {} from {:?} to {:?}", scid, source, target);
+ }
+ };
+
+ log_direction(&chan_debug.node_one, &chan_debug.node_two);
+ log_direction(&chan_debug.node_two, &chan_debug.node_one);
+ } else {
+ log_debug!(self.logger, "No network graph entry for SCID {}", scid);
+ }
+ }
+ }
}
impl ProbabilisticScoringParameters {
/// probabilities.
const NEGATIVE_LOG10_UPPER_BOUND: u64 = 2;
+/// The rough cutoff at which our precision falls off and we should stop bothering to try to log a
+/// ratio, as X in 1/X.
+const PRECISION_LOWER_BOUND_DENOMINATOR: u64 = approx::LOWER_BITS_BOUND;
+
/// The divisor used when computing the amount penalty.
const AMOUNT_PENALTY_DIVISOR: u64 = 1 << 20;
} else {
let numerator = (max_liquidity_msat - amount_msat).saturating_add(1);
let denominator = (max_liquidity_msat - min_liquidity_msat).saturating_add(1);
- let negative_log10_times_2048 =
- approx::negative_log10_times_2048(numerator, denominator);
- self.combined_penalty_msat(amount_msat, negative_log10_times_2048, params)
+ if amount_msat - min_liquidity_msat < denominator / PRECISION_LOWER_BOUND_DENOMINATOR {
+ // If the failure probability is < 1.5625% (as 1 - numerator/denominator < 1/64),
+ // don't bother trying to use the log approximation as it gets too noisy to be
+ // particularly helpful, instead just round down to 0 and return the base penalty.
+ params.base_penalty_msat
+ } else {
+ let negative_log10_times_2048 =
+ approx::negative_log10_times_2048(numerator, denominator);
+ self.combined_penalty_msat(amount_msat, negative_log10_times_2048, params)
+ }
}
}
impl<L: DerefMut<Target = u64>, T: Time, U: DerefMut<Target = T>> DirectedChannelLiquidity<L, T, U> {
/// Adjusts the channel liquidity balance bounds when failing to route `amount_msat`.
- fn failed_at_channel(&mut self, amount_msat: u64) {
+ fn failed_at_channel<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
if amount_msat < self.max_liquidity_msat() {
+ log_debug!(logger, "Setting max liquidity of {} to {}", chan_descr, amount_msat);
self.set_max_liquidity_msat(amount_msat);
+ } else {
+ log_trace!(logger, "Max liquidity of {} already more than {}", chan_descr, amount_msat);
}
}
/// Adjusts the channel liquidity balance bounds when failing to route `amount_msat` downstream.
- fn failed_downstream(&mut self, amount_msat: u64) {
+ fn failed_downstream<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
if amount_msat > self.min_liquidity_msat() {
+ log_debug!(logger, "Setting min liquidity of {} to {}", chan_descr, amount_msat);
self.set_min_liquidity_msat(amount_msat);
+ } else {
+ log_trace!(logger, "Min liquidity of {} already less than {}", chan_descr, amount_msat);
}
}
/// Adjusts the channel liquidity balance bounds when successfully routing `amount_msat`.
- fn successful(&mut self, amount_msat: u64) {
+ fn successful<Log: Deref>(&mut self, amount_msat: u64, chan_descr: fmt::Arguments, logger: &Log) where Log::Target: Logger {
let max_liquidity_msat = self.max_liquidity_msat().checked_sub(amount_msat).unwrap_or(0);
+ log_debug!(logger, "Subtracting {} from max liquidity of {} (setting it to {})", amount_msat, chan_descr, max_liquidity_msat);
self.set_max_liquidity_msat(max_liquidity_msat);
}
}
}
-impl<G: Deref<Target = NetworkGraph>, T: Time> Score for ProbabilisticScorerUsingTime<G, T> {
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for ProbabilisticScorerUsingTime<G, L, T> 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 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())
fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
let amount_msat = path.split_last().map(|(hop, _)| hop.fee_msat).unwrap_or(0);
let liquidity_offset_half_life = self.params.liquidity_offset_half_life;
+ log_trace!(self.logger, "Scoring path through to SCID {} as having failed at {} msat", short_channel_id, amount_msat);
let network_graph = self.network_graph.read_only();
- for hop in path {
+ for (hop_idx, hop) in path.iter().enumerate() {
let target = NodeId::from_pubkey(&hop.pubkey);
let channel_directed_from_source = network_graph.channels()
.get(&hop.short_channel_id)
.and_then(|channel| channel.as_directed_to(&target));
+ if hop.short_channel_id == short_channel_id && 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();
.entry(hop.short_channel_id)
.or_insert_with(ChannelLiquidity::new)
.as_directed_mut(source, &target, capacity_msat, liquidity_offset_half_life)
- .failed_at_channel(amount_msat);
+ .failed_at_channel(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
break;
}
.entry(hop.short_channel_id)
.or_insert_with(ChannelLiquidity::new)
.as_directed_mut(source, &target, capacity_msat, liquidity_offset_half_life)
- .failed_downstream(amount_msat);
+ .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);
}
}
}
fn payment_path_successful(&mut self, path: &[&RouteHop]) {
let amount_msat = path.split_last().map(|(hop, _)| hop.fee_msat).unwrap_or(0);
let liquidity_offset_half_life = self.params.liquidity_offset_half_life;
+ log_trace!(self.logger, "Scoring path through SCID {} as having succeeded at {} msat.",
+ path.split_last().map(|(hop, _)| hop.short_channel_id).unwrap_or(0), amount_msat);
let network_graph = self.network_graph.read_only();
for hop in path {
let target = NodeId::from_pubkey(&hop.pubkey);
.entry(hop.short_channel_id)
.or_insert_with(ChannelLiquidity::new)
.as_directed_mut(source, &target, capacity_msat, liquidity_offset_half_life)
- .successful(amount_msat);
+ .successful(amount_msat, format_args!("SCID {}, towards {:?}", hop.short_channel_id, target), &self.logger);
+ } else {
+ log_debug!(self.logger, "Not able to learn for channel with SCID {} as we do not have graph info for it (likely a route-hint last-hop).",
+ hop.short_channel_id);
}
}
}
const BITS: u32 = 64;
const HIGHEST_BIT: u32 = BITS - 1;
const LOWER_BITS: u32 = 6;
- const LOWER_BITS_BOUND: u64 = 1 << LOWER_BITS;
+ pub(super) const LOWER_BITS_BOUND: u64 = 1 << LOWER_BITS;
const LOWER_BITMASK: u64 = (1 << LOWER_BITS) - 1;
/// Look-up table for `log10(x) * 2048` where row `i` is used for each `x` having `i` as the
}
}
-impl<G: Deref<Target = NetworkGraph>, T: Time> Writeable for ProbabilisticScorerUsingTime<G, T> {
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Writeable for ProbabilisticScorerUsingTime<G, L, T> where L::Target: Logger {
#[inline]
fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
write_tlv_fields!(w, {
}
}
-impl<G: Deref<Target = NetworkGraph>, T: Time>
-ReadableArgs<(ProbabilisticScoringParameters, G)> for ProbabilisticScorerUsingTime<G, T> {
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time>
+ReadableArgs<(ProbabilisticScoringParameters, G, L)> for ProbabilisticScorerUsingTime<G, L, T> where L::Target: Logger {
#[inline]
fn read<R: Read>(
- r: &mut R, args: (ProbabilisticScoringParameters, G)
+ r: &mut R, args: (ProbabilisticScoringParameters, G, L)
) -> Result<Self, DecodeError> {
- let (params, network_graph) = args;
+ let (params, network_graph, logger) = args;
let mut channel_liquidities = HashMap::new();
read_tlv_fields!(r, {
(0, channel_liquidities, required)
Ok(Self {
params,
network_graph,
+ logger,
channel_liquidities,
})
}
}
}
-pub(crate) mod time {
- use core::ops::Sub;
- use core::time::Duration;
- /// A measurement of time.
- pub trait Time: Copy + Sub<Duration, Output = Self> where Self: Sized {
- /// Returns an instance corresponding to the current moment.
- fn now() -> Self;
-
- /// Returns the amount of time elapsed since `self` was created.
- fn elapsed(&self) -> Duration;
-
- /// Returns the amount of time passed between `earlier` and `self`.
- fn duration_since(&self, earlier: Self) -> Duration;
-
- /// Returns the amount of time passed since the beginning of [`Time`].
- ///
- /// Used during (de-)serialization.
- fn duration_since_epoch() -> Duration;
- }
-
- /// A state in which time has no meaning.
- #[derive(Clone, Copy, Debug, PartialEq, Eq)]
- pub struct Eternity;
-
- #[cfg(not(feature = "no-std"))]
- impl Time for std::time::Instant {
- fn now() -> Self {
- std::time::Instant::now()
- }
-
- fn duration_since(&self, earlier: Self) -> Duration {
- self.duration_since(earlier)
- }
-
- fn duration_since_epoch() -> Duration {
- use std::time::SystemTime;
- SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap()
- }
-
- fn elapsed(&self) -> Duration {
- std::time::Instant::elapsed(self)
- }
- }
-
- impl Time for Eternity {
- fn now() -> Self {
- Self
- }
-
- fn duration_since(&self, _earlier: Self) -> Duration {
- Duration::from_secs(0)
- }
-
- fn duration_since_epoch() -> Duration {
- Duration::from_secs(0)
- }
-
- fn elapsed(&self) -> Duration {
- Duration::from_secs(0)
- }
- }
-
- impl Sub<Duration> for Eternity {
- type Output = Self;
-
- fn sub(self, _other: Duration) -> Self {
- self
- }
- }
-}
-
-pub(crate) use self::time::Time;
-
#[cfg(test)]
mod tests {
- use super::{ChannelLiquidity, ProbabilisticScoringParameters, ProbabilisticScorerUsingTime, ScoringParameters, ScorerUsingTime, Time};
- use super::time::Eternity;
+ 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;
use bitcoin::hashes::Hash;
use bitcoin::hashes::sha256d::Hash as Sha256dHash;
use bitcoin::network::constants::Network;
use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
- use core::cell::Cell;
- use core::ops::Sub;
use core::time::Duration;
use io;
- // `Time` tests
-
- /// Time that can be advanced manually in tests.
- #[derive(Clone, Copy, Debug, PartialEq, Eq)]
- struct SinceEpoch(Duration);
-
- impl SinceEpoch {
- thread_local! {
- static ELAPSED: Cell<Duration> = core::cell::Cell::new(Duration::from_secs(0));
- }
-
- fn advance(duration: Duration) {
- Self::ELAPSED.with(|elapsed| elapsed.set(elapsed.get() + duration))
- }
- }
-
- impl Time for SinceEpoch {
- fn now() -> Self {
- Self(Self::duration_since_epoch())
- }
-
- fn duration_since(&self, earlier: Self) -> Duration {
- self.0 - earlier.0
- }
-
- fn duration_since_epoch() -> Duration {
- Self::ELAPSED.with(|elapsed| elapsed.get())
- }
-
- fn elapsed(&self) -> Duration {
- Self::duration_since_epoch() - self.0
- }
- }
-
- impl Sub<Duration> for SinceEpoch {
- type Output = Self;
-
- fn sub(self, other: Duration) -> Self {
- Self(self.0 - other)
- }
- }
-
- #[test]
- fn time_passes_when_advanced() {
- let now = SinceEpoch::now();
- assert_eq!(now.elapsed(), Duration::from_secs(0));
-
- SinceEpoch::advance(Duration::from_secs(1));
- SinceEpoch::advance(Duration::from_secs(1));
-
- let elapsed = now.elapsed();
- let later = SinceEpoch::now();
-
- assert_eq!(elapsed, Duration::from_secs(2));
- assert_eq!(later - elapsed, now);
- }
-
- #[test]
- fn time_never_passes_in_an_eternity() {
- let now = Eternity::now();
- let elapsed = now.elapsed();
- let later = Eternity::now();
-
- assert_eq!(now.elapsed(), Duration::from_secs(0));
- assert_eq!(later - elapsed, now);
- }
-
- // `Scorer` tests
-
- /// A scorer for testing with time that can be manually advanced.
- type Scorer = ScorerUsingTime::<SinceEpoch>;
-
fn source_privkey() -> SecretKey {
SecretKey::from_slice(&[42; 32]).unwrap()
}
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 = <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 = <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, SinceEpoch>;
+ type ProbabilisticScorer<'a> = ProbabilisticScorerUsingTime::<&'a NetworkGraph<&'a TestLogger>, &'a TestLogger, SinceEpoch>;
fn sender_privkey() -> SecretKey {
SecretKey::from_slice(&[41; 32]).unwrap()
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());
}
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();
};
let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_announcement.encode()[..])[..]);
let signed_announcement = ChannelAnnouncement {
- node_signature_1: secp_ctx.sign(&msghash, &node_1_key),
- node_signature_2: secp_ctx.sign(&msghash, &node_2_key),
- bitcoin_signature_1: secp_ctx.sign(&msghash, &node_1_secret),
- bitcoin_signature_2: secp_ctx.sign(&msghash, &node_2_secret),
+ node_signature_1: secp_ctx.sign_ecdsa(&msghash, &node_1_key),
+ node_signature_2: secp_ctx.sign_ecdsa(&msghash, &node_2_key),
+ bitcoin_signature_1: secp_ctx.sign_ecdsa(&msghash, &node_1_secret),
+ bitcoin_signature_2: secp_ctx.sign_ecdsa(&msghash, &node_2_secret),
contents: unsigned_announcement,
};
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();
};
let msghash = hash_to_message!(&Sha256dHash::hash(&unsigned_update.encode()[..])[..]);
let signed_update = ChannelUpdate {
- signature: secp_ctx.sign(&msghash, &node_key),
+ 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<RouteHop> {
#[test]
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)
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger)
.with_channel(42,
ChannelLiquidity {
min_liquidity_offset_msat: 700, max_liquidity_offset_msat: 100, last_updated
#[test]
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)
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger)
.with_channel(42,
ChannelLiquidity {
min_liquidity_offset_msat: 200, max_liquidity_offset_msat: 400, last_updated
#[test]
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)
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger)
.with_channel(42,
ChannelLiquidity {
min_liquidity_offset_msat: 200, max_liquidity_offset_msat: 400, last_updated
#[test]
fn increased_penalty_nearing_liquidity_upper_bound() {
- let network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
..ProbabilisticScoringParameters::zero_penalty()
};
- let scorer = ProbabilisticScorer::new(params, &network_graph);
+ 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, 1_024, 1_024_000, &source, &target), 3);
- assert_eq!(scorer.channel_penalty_msat(42, 10_240, 1_024_000, &source, &target), 6);
- 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()
};
- let scorer = ProbabilisticScorer::new(params, &network_graph)
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger)
.with_channel(42,
ChannelLiquidity {
min_liquidity_offset_msat: 40, max_liquidity_offset_msat: 40, last_updated
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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph);
+ 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::<Vec<_>>(), 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::<Vec<_>>());
- 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph);
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
let source = source_node_id();
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::<Vec<_>>(), 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph);
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
let source = source_node_id();
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::<Vec<_>>(), 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
..ProbabilisticScoringParameters::zero_penalty()
};
- let mut scorer = ProbabilisticScorer::new(params, &network_graph);
+ let mut scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
let sender = sender_node_id();
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::<Vec<_>>());
- 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
+ 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, 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::<Vec<_>>(), 42);
scorer.payment_path_failed(&payment_path_for_amount(128).iter().collect::<Vec<_>>(), 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
+ 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::<Vec<_>>(), 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
+ 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::<Vec<_>>(), 42);
scorer.payment_path_failed(&payment_path_for_amount(256).iter().collect::<Vec<_>>(), 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::<Vec<_>>());
- 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::<Vec<_>>(), 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
+ let mut scorer = ProbabilisticScorer::new(params, &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::<Vec<_>>(), 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::<Vec<_>>(), 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();
let mut serialized_scorer = io::Cursor::new(&serialized_scorer);
let deserialized_scorer =
- <ProbabilisticScorer>::read(&mut serialized_scorer, (params, &network_graph)).unwrap();
- assert_eq!(deserialized_scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 300);
+ <ProbabilisticScorer>::read(&mut serialized_scorer, (params, &network_graph, &logger)).unwrap();
+ assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 300);
}
#[test]
fn decays_persisted_liquidity_bounds() {
- let network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
+ let mut scorer = ProbabilisticScorer::new(params, &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::<Vec<_>>(), 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();
let mut serialized_scorer = io::Cursor::new(&serialized_scorer);
let deserialized_scorer =
- <ProbabilisticScorer>::read(&mut serialized_scorer, (params, &network_graph)).unwrap();
- assert_eq!(deserialized_scorer.channel_penalty_msat(42, 500, 1_000, &source, &target), 473);
+ <ProbabilisticScorer>::read(&mut serialized_scorer, (params, &network_graph, &logger)).unwrap();
+ assert_eq!(deserialized_scorer.channel_penalty_msat(42, &source, &target, usage), 473);
scorer.payment_path_failed(&payment_path_for_amount(250).iter().collect::<Vec<_>>(), 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]
fn scores_realistic_payments() {
// Shows the scores of "realistic" sends of 100k sats over channels of 1-10m sats (with a
// 50k sat reserve).
- let network_graph = network_graph();
+ let logger = TestLogger::new();
+ let network_graph = network_graph(&logger);
let params = ProbabilisticScoringParameters::default();
- let scorer = ProbabilisticScorer::new(params, &network_graph);
+ 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), 782);
- assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 7_450_000_000, &source, &target), 1002);
- assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 7_950_000_000, &source, &target), 970);
- assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 8_950_000_000, &source, &target), 907);
- assert_eq!(scorer.channel_penalty_msat(42, 100_000_000, 9_950_000_000, &source, &target), 877);
+ 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 network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
- assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 58);
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ 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);
- assert_eq!(scorer.channel_penalty_msat(42, 128, 1_024, &source, &target), 558);
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 558);
}
#[test]
fn adds_amount_penalty_to_liquidity_penalty() {
- let network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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,
amount_penalty_multiplier_msat: 0,
..ProbabilisticScoringParameters::zero_penalty()
};
- let scorer = ProbabilisticScorer::new(params, &network_graph);
- assert_eq!(scorer.channel_penalty_msat(42, 512_000, 1_024_000, &source, &target), 300);
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 300);
let params = ProbabilisticScoringParameters {
liquidity_penalty_multiplier_msat: 1_000,
amount_penalty_multiplier_msat: 256,
..ProbabilisticScoringParameters::zero_penalty()
};
- let scorer = ProbabilisticScorer::new(params, &network_graph);
- assert_eq!(scorer.channel_penalty_msat(42, 512_000, 1_024_000, &source, &target), 337);
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 337);
}
#[test]
fn calculates_log10_without_overflowing_u64_max_value() {
- let network_graph = network_graph();
+ let logger = TestLogger::new();
+ 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);
- assert_eq!(
- scorer.channel_penalty_msat(42, u64::max_value(), u64::max_value(), &source, &target),
- 80_000,
- );
+ let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+ 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, &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());
}
}