combined fixes

Author: joostjager

lightning/src/routing/scoring.rs

@@ -477,6 +477,7 @@ where L::Target: Logger {
 	channel_liquidities: ChannelLiquidities,
 }
 /// ChannelLiquidities contains live and historical liquidity bounds for each channel.
+#[derive(Clone)]
 pub struct ChannelLiquidities(HashMap<u64, ChannelLiquidity>);
 
 impl ChannelLiquidities {
@@ -522,6 +523,7 @@ impl DerefMut for ChannelLiquidities {
 	}
 }
 
+// TODO: Avoid extra level of tlv serialization
 impl Readable for ChannelLiquidities {
 	#[inline]
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
@@ -533,6 +535,7 @@ impl Readable for ChannelLiquidities {
 	}
 }
 
+
 /// Parameters for configuring [`ProbabilisticScorer`].
 ///
 /// Used to configure base, liquidity, and amount penalties, the sum of which comprises the channel
@@ -860,6 +863,7 @@ impl ProbabilisticScoringDecayParameters {
 /// first node in the ordering of the channel's counterparties. Thus, swapping the two liquidity
 /// offset fields gives the opposite direction.
 #[repr(C)] // Force the fields in memory to be in the order we specify
+#[derive(Clone)]
 pub struct ChannelLiquidity {
 	/// Lower channel liquidity bound in terms of an offset from zero.
 	min_liquidity_offset_msat: u64,
@@ -1672,16 +1676,34 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreUpdate for Probabilistic
 	}
 }
 
+/// A probabilistic scorer that combines local and external information to score channels.
 pub struct CombinedScorer<G: Deref<Target = NetworkGraph<L>>, L: Deref> where L::Target: Logger {
-    pub local_only_scorer: ProbabilisticScorer<G, L>,
-    pub scorer:  ProbabilisticScorer<G, L>,
+    local_only_scorer: ProbabilisticScorer<G, L>,
+    scorer:  ProbabilisticScorer<G, L>,
 }
 
-impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> CombinedScorer<G, L> where L::Target: Logger {
-    pub fn merge(&mut self, external_scores: HashMap<u64, ChannelLiquidity>) {
+impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref + Clone> CombinedScorer<G, L> where L::Target: Logger {
+	/// Create a new combined scorer with the given local scorer.
+	pub fn new(local_scorer: ProbabilisticScorer<G, L>) -> Self {
+		let decay_params = local_scorer.decay_params;
+		let network_graph = local_scorer.network_graph.clone();
+		let logger = local_scorer.logger.clone();
+		let mut scorer = ProbabilisticScorer::new(decay_params, network_graph, logger);
+
+		scorer.channel_liquidities = local_scorer.channel_liquidities.clone();
+
+		Self {
+			local_only_scorer: local_scorer,
+			scorer: scorer,
+		}
+	}
+
+	/// Merge external channel liquidity information into the scorer.
+    pub fn merge(&mut self, external_scores: ChannelLiquidities) {
         let local_scores = &self.local_only_scorer.channel_liquidities;
 
-		for (scid, mut liquidity) in external_scores {
+		// For each channel, merge the external liquidity information with the isolated local liquidity information.
+		for (scid, mut liquidity) in external_scores.0 {
 			if let Some(local_liquidity) = local_scores.get(&scid) {
 				liquidity.merge(local_liquidity);
 			}
@@ -1696,7 +1718,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreLookUp for CombinedScore
     fn channel_penalty_msat(
 		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &ProbabilisticScoringFeeParameters
 	) -> u64 {
-        self.local_only_scorer.channel_penalty_msat(candidate, usage, score_params)
+        self.scorer.channel_penalty_msat(candidate, usage, score_params)
 	}
 }
 
@@ -3785,6 +3807,36 @@ mod tests {
 		assert_eq!(scorer.historical_estimated_payment_success_probability(42, &target, amount_msat, &params, false),
 			Some(0.0));
 	}
+
+	#[test]
+	fn combined_scorer() {
+		let logger = TestLogger::new();
+		let network_graph = network_graph(&logger);
+		let params = ProbabilisticScoringFeeParameters::default();
+		let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger);
+
+		scorer.payment_path_failed(&payment_path_for_amount(500), 42, Duration::ZERO);
+
+		let source = source_node_id();
+
+		let base_penalty_msat = params.base_penalty_msat;
+		let usage = ChannelUsage {
+			amount_msat: 750,
+			inflight_htlc_msat: 0,
+			effective_capacity: EffectiveCapacity::Total { capacity_msat: 1_000, htlc_maximum_msat: 1_000 },
+		};
+		let network_graph = network_graph.read_only();
+		let channel = network_graph.channel(42).unwrap();
+		let (info, _) = channel.as_directed_from(&source).unwrap();
+		let candidate = CandidateRouteHop::PublicHop(PublicHopCandidate {
+			info,
+			short_channel_id: 42,
+		});
+		let penalty = scorer.channel_penalty_msat(&candidate, usage, &params);
+		assert_eq!(penalty, 100000021275);
+
+	}
+
 }
 
 #[cfg(ldk_bench)]