f dry up bounds checking

Author: TheBlueMatt

lightning/src/routing/scoring.rs

@@ -706,10 +706,17 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ProbabilisticScorerU
 						let amt = directed_info.effective_capacity().as_msat();
 						let dir_liq = liq.as_directed(source, target, 0, amt, self.decay_params);
 
-						let (min_buckets, max_buckets, _, _) = dir_liq.liquidity_history
+						let decayed_buckets = dir_liq.liquidity_history
 							.get_decayed_buckets(now, *dir_liq.last_updated,
 								self.decay_params.historical_no_updates_half_life);
 
+						let (min_buckets, max_buckets, _, _) =
+							if let Some(buckets) = decayed_buckets { buckets } else {
+								// If the buckets, once decayed, end up being zero, print them out
+								// as zeros.
+								([0; 32], [0; 32], 0, 0)
+							};
+
 						log_debug!(self.logger, core::concat!(
 							"Liquidity from {} to {} via {} is in the range ({}, {}).\n",
 							"\tHistorical min liquidity bucket relative probabilities:\n",
@@ -806,13 +813,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, T: Time> ProbabilisticScorerU
 						dir_liq.liquidity_history.get_decayed_buckets(
 							dir_liq.now, *dir_liq.last_updated,
 							self.decay_params.historical_no_updates_half_life
-						);
-
-					// If the total valid points is smaller than 1.0 (i.e. 32 in our fixed-point
-					// scheme), treat it as if we were fully decayed.
-					if valid_points.checked_shr(required_decays).unwrap_or(0) < 32*32 {
-						return None;
-					}
+						)?;
 
 					// Note that the liquidity buckets are an offset from the edge, so we inverse
 					// the max order to get the probabilities from zero.
@@ -1744,7 +1745,7 @@ mod bucketed_history {
 	impl<D: Deref<Target = HistoricalBucketRangeTracker>> HistoricalMinMaxBuckets<D> {
 		#[inline]
 		pub(super) fn get_decayed_buckets<T: Time>(&self, now: T, last_updated: T, half_life: Duration)
-		-> ([u16; 32], [u16; 32], u64, u32) {
+		-> Option<([u16; 32], [u16; 32], u64, u32)> {
 			let required_decays = now.duration_since(last_updated).as_secs()
 				.checked_div(half_life.as_secs())
 				.map_or(u32::max_value(), |decays| cmp::min(decays, u32::max_value() as u64) as u32);
@@ -1756,11 +1757,17 @@ mod bucketed_history {
 				}
 			}
 
+			// If the total valid points is smaller than 1.0 (i.e. 32 in our fixed-point scheme),
+			// treat it as if we were fully decayed.
+			if total_valid_points_tracked.checked_shr(required_decays).unwrap_or(0) < 32*32 {
+				return None;
+			}
+
 			let mut min_buckets = *self.min_liquidity_offset_history;
 			min_buckets.time_decay_data(required_decays);
 			let mut max_buckets = *self.max_liquidity_offset_history;
 			max_buckets.time_decay_data(required_decays);
-			(min_buckets.buckets, max_buckets.buckets, total_valid_points_tracked, required_decays)
+			Some((min_buckets.buckets, max_buckets.buckets, total_valid_points_tracked, required_decays))
 		}
 
 		#[inline]
@@ -1778,13 +1785,7 @@ mod bucketed_history {
 			// Check if all our buckets are zero, once decayed and treat it as if we had no data. We
 			// don't actually use the decayed buckets, though, as that would lose precision.
 			let (decayed_min_buckets, decayed_max_buckets, total_valid_points_tracked, required_decays)
-				= self.get_decayed_buckets(now, last_updated, half_life);
-
-			// If the total valid points is smaller than 1.0 (i.e. 32 in our fixed-point scheme), treat
-			// it as if we were fully decayed.
-			if total_valid_points_tracked.checked_shr(required_decays).unwrap_or(0) < 32*32 {
-				return None;
-			}
+				= self.get_decayed_buckets(now, last_updated, half_life)?;
 
 			let mut cumulative_success_prob_times_billion = 0;
 			// Special-case the 0th min bucket - it generally means we failed a payment, so only