Add a per-amount base penalty in the `ProbabilisticScorer`

There's not much reason to not have a per-hop-per-amount penalty in
the `ProbabilisticScorer` to go along with the per-hop penalty to
let it scale up to larger amounts, so we add one here.

Notably, we use a divisor of 2^30 instead of 2^20 (like the
equivalent liquidity penalty) as it allows for more flexibility,
and there's not really any reason to worry about us not being able
to create high enough penalties.

Closes #1616

diff --git a/lightning/src/routing/scoring.rs b/lightning/src/routing/scoring.rs
index e2e0bdd18a6eddf714ce3288643a0efb1d4d8ca7..5e3e7b5310966b7aa4528e81cae8adeb4152dad3 100644 (file)
--- a/lightning/src/routing/scoring.rs
+++ b/lightning/src/routing/scoring.rs
@@ -324,6 +324,9 @@ where L::Target: Logger {
 ///
 /// Used to configure base, liquidity, and amount penalties, the sum of which comprises the channel
 /// penalty (i.e., the amount in msats willing to be paid to avoid routing through the channel).
+///
+/// The penalty applied to any channel by the [`ProbabilisticScorer`] is the sum of each of the
+/// parameters here.
 #[derive(Clone)]
 pub struct ProbabilisticScoringParameters {
        /// A fixed penalty in msats to apply to each channel.
@@ -331,6 +334,20 @@ pub struct ProbabilisticScoringParameters {
        /// Default value: 500 msat
        pub base_penalty_msat: u64,
 
+       /// A multiplier used with the payment amount to calculate a fixed penalty applied to each
+       /// channel, in excess of the [`base_penalty_msat`].
+       ///
+       /// The purpose of the amount penalty is to avoid having fees dominate the channel cost (i.e.,
+       /// fees plus penalty) for large payments. The penalty is computed as the product of this
+       /// multiplier and `2^30`ths of the payment amount.
+       ///
+       /// ie `base_penalty_amount_multiplier_msat * amount_msat / 2^30`
+       ///
+       /// Default value: 8,192 msat
+       ///
+       /// [`base_penalty_msat`]: Self::base_penalty_msat
+       pub base_penalty_amount_multiplier_msat: u64,
+
        /// A multiplier used in conjunction with the negative `log10` of the channel's success
        /// probability for a payment to determine the liquidity penalty.
        ///
@@ -536,6 +553,7 @@ impl ProbabilisticScoringParameters {
        fn zero_penalty() -> Self {
                Self {
                        base_penalty_msat: 0,
+                       base_penalty_amount_multiplier_msat: 0,
                        liquidity_penalty_multiplier_msat: 0,
                        liquidity_offset_half_life: Duration::from_secs(3600),
                        amount_penalty_multiplier_msat: 0,
@@ -558,6 +576,7 @@ impl Default for ProbabilisticScoringParameters {
        fn default() -> Self {
                Self {
                        base_penalty_msat: 500,
+                       base_penalty_amount_multiplier_msat: 8192,
                        liquidity_penalty_multiplier_msat: 40_000,
                        liquidity_offset_half_life: Duration::from_secs(3600),
                        amount_penalty_multiplier_msat: 256,
@@ -631,10 +650,11 @@ 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;
+const BASE_AMOUNT_PENALTY_DIVISOR: u64 = 1 << 30;
 
 impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiquidity<L, T, U> {
-       /// Returns a penalty for routing the given HTLC `amount_msat` through the channel in this
-       /// direction.
+       /// Returns a liquidity penalty for routing the given HTLC `amount_msat` through the channel in
+       /// this direction.
        fn penalty_msat(&self, amount_msat: u64, params: &ProbabilisticScoringParameters) -> u64 {
                let max_liquidity_msat = self.max_liquidity_msat();
                let min_liquidity_msat = core::cmp::min(self.min_liquidity_msat(), max_liquidity_msat);
@@ -653,8 +673,8 @@ impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiqui
                        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
+                               // particularly helpful, instead just round down to 0.
+                               0
                        } else {
                                let negative_log10_times_2048 =
                                        approx::negative_log10_times_2048(numerator, denominator);
@@ -663,7 +683,7 @@ impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiqui
                }
        }
 
-       /// Computes the liquidity and amount penalties and adds them to the base penalty.
+       /// Computes the liquidity penalty from the penalty multipliers.
        #[inline(always)]
        fn combined_penalty_msat(
                &self, amount_msat: u64, negative_log10_times_2048: u64,
@@ -679,9 +699,7 @@ impl<L: Deref<Target = u64>, T: Time, U: Deref<Target = T>> DirectedChannelLiqui
                        .saturating_mul(params.amount_penalty_multiplier_msat)
                        .saturating_mul(amount_msat) / 2048 / AMOUNT_PENALTY_DIVISOR;
 
-               params.base_penalty_msat
-                       .saturating_add(liquidity_penalty_msat)
-                       .saturating_add(amount_penalty_msat)
+               liquidity_penalty_msat.saturating_add(amount_penalty_msat)
        }
 
        /// Returns the lower bound of the channel liquidity balance in this direction.
@@ -763,13 +781,17 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for Probabilis
                        return *penalty;
                }
 
+               let base_penalty_msat = self.params.base_penalty_msat.saturating_add(
+                       self.params.base_penalty_amount_multiplier_msat
+                               .saturating_mul(usage.amount_msat) / BASE_AMOUNT_PENALTY_DIVISOR);
+
                let mut anti_probing_penalty_msat = 0;
                match usage.effective_capacity {
                        EffectiveCapacity::ExactLiquidity { liquidity_msat } => {
                                if usage.amount_msat > liquidity_msat {
                                        return u64::max_value();
                                } else {
-                                       return self.params.base_penalty_msat;
+                                       return base_penalty_msat;
                                }
                        },
                        EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat: Some(htlc_maximum_msat) } => {
@@ -790,6 +812,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> Score for Probabilis
                        .as_directed(source, target, capacity_msat, liquidity_offset_half_life)
                        .penalty_msat(amount_msat, &self.params)
                        .saturating_add(anti_probing_penalty_msat)
+                       .saturating_add(base_penalty_msat)
        }
 
        fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) {
@@ -2069,47 +2092,47 @@ mod tests {
                        inflight_htlc_msat: 0,
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 950_000_000, htlc_maximum_msat: Some(1_000) },
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 3613);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 4375);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1977);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2739);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 2_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1474);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 2236);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 3_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1223);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1985);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 4_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 877);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1639);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 5_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 845);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1607);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 6_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1262);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_450_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1262);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 7_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1262);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 8_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1262);
                let usage = ChannelUsage {
                        effective_capacity: EffectiveCapacity::Total { capacity_msat: 9_950_000_000, htlc_maximum_msat: Some(1_000) }, ..usage
                };
-               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 500);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 1262);
        }
 
        #[test]
@@ -2137,6 +2160,15 @@ mod tests {
                };
                let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
                assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 558);
+
+               let params = ProbabilisticScoringParameters {
+                       base_penalty_msat: 500, liquidity_penalty_multiplier_msat: 1_000,
+                       base_penalty_amount_multiplier_msat: (1 << 30),
+                       anti_probing_penalty_msat: 0, ..Default::default()
+               };
+
+               let scorer = ProbabilisticScorer::new(params, &network_graph, &logger);
+               assert_eq!(scorer.channel_penalty_msat(42, &source, &target, usage), 558 + 128);
        }
 
        #[test]