Allow combining of Prob Scorers

Author: benthecarman

lightning/src/routing/scoring.rs

@@ -650,6 +650,20 @@ struct HistoricalBucketRangeTracker {
 
 impl HistoricalBucketRangeTracker {
 	fn new() -> Self { Self { buckets: [0; 8] } }
+
+	/// Returns the average of the buckets between the two trackers.
+	pub(crate) fn combine(mut self, other: Self) -> Self {
+		let mut buckets: [u16; 8] = [0; 8];
+		for i in 0..8 {
+			let current = self.buckets[i];
+			let other = other.buckets[i];
+			buckets[i] = (current + other) / 2;
+		}
+
+		self.buckets = buckets;
+		self
+	}
+
 	fn track_datapoint(&mut self, liquidity_offset_msat: u64, capacity_msat: u64) {
 		// We have 8 leaky buckets for min and max liquidity. Each bucket tracks the amount of time
 		// we spend in each bucket as a 16-bit fixed-point number with a 5 bit fractional part.
@@ -787,6 +801,7 @@ impl HistoricalMinMaxBuckets<'_> {
 /// Direction is defined in terms of [`NodeId`] partial ordering, where the source node is the
 /// first node in the ordering of the channel's counterparties. Thus, swapping the two liquidity
 /// offset fields gives the opposite direction.
+#[derive(Clone)]
 struct ChannelLiquidity<T: Time> {
 	/// Lower channel liquidity bound in terms of an offset from zero.
 	min_liquidity_offset_msat: u64,
@@ -801,6 +816,21 @@ struct ChannelLiquidity<T: Time> {
 	max_liquidity_offset_history: HistoricalBucketRangeTracker,
 }
 
+impl<T: Time> ChannelLiquidity<T> {
+	pub(crate) fn combine(mut self, other: Self) -> Self {
+		self.min_liquidity_offset_msat = self.min_liquidity_offset_msat.max(other.min_liquidity_offset_msat);
+		self.max_liquidity_offset_msat = self.max_liquidity_offset_msat.min(other.max_liquidity_offset_msat);
+		self.min_liquidity_offset_history.combine(other.min_liquidity_offset_history);
+		self.max_liquidity_offset_history.combine(other.max_liquidity_offset_history);
+
+		if self.last_updated.duration_since(other.last_updated) < Duration::from_secs(0) {
+			self.last_updated = other.last_updated;
+		}
+
+		self
+	}
+}
+
 /// A snapshot of [`ChannelLiquidity`] in one direction assuming a certain channel capacity and
 /// decayed with a given half life.
 struct DirectedChannelLiquidity<L: Deref<Target = u64>, BRT: Deref<Target = HistoricalBucketRangeTracker>, T: Time, U: Deref<Target = T>> {
@@ -942,6 +972,27 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ProbabilisticScorerU
 		}
 		None
 	}
+
+	/// Combines two `ProbabilisticScorerUsingTime` into one.
+	///
+	/// This merges the channel liquidity information of both scorers.
+	pub fn combine(mut self, other: Self) -> Self {
+		let mut channel_liquidities = self.channel_liquidities;
+
+		for (id, item) in other.channel_liquidities {
+			match channel_liquidities.get(&id) {
+				None => { channel_liquidities.insert(id, item); },
+				Some(current) => {
+					let liquidity = current.clone();
+					channel_liquidities.insert(id, liquidity.combine(item));
+				}
+			}
+		}
+
+		self.channel_liquidities = channel_liquidities;
+
+		self
+	}
 }
 
 impl<T: Time> ChannelLiquidity<T> {