Consider channel balance certainty in blinded path

How certain a scorer is about a channel's liquidity balance is useful in
determining if the channel should be included in a blinded payment path.
Channels with uncertain balances should be avoided to facilitate
successful payments.

Expand ScoreLookUp with a channel_balance_certainty method and use it in
DefaultRouter::create_blinded_payment_paths.

Author: jkczyz

lightning/src/routing/router.rs

@@ -99,6 +99,9 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, S: Deref, SP: Sized,
 		// recipient's node_id.
 		const MIN_PEER_CHANNELS: usize = 3;
 
+		// The minimum channel balance certainty required for using a channel in a blinded path.
+		const MIN_CHANNEL_CERTAINTY: f64 = 0.5;
+
 		let network_graph = self.network_graph.deref().read_only();
 		let counterparty_channels = first_hops.into_iter()
 			.filter(|details| details.counterparty.features.supports_route_blinding())
@@ -144,6 +147,7 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, S: Deref, SP: Sized,
 				Some((forward_node, counterparty_channels))
 			});
 
+		let scorer = self.scorer.read_lock();
 		let three_hop_paths = counterparty_channels.clone()
 			// Pair counterparties with their other channels
 			.flat_map(|(forward_node, counterparty_channels)|
@@ -163,6 +167,9 @@ impl<G: Deref<Target = NetworkGraph<L>> + Clone, L: Deref, S: Deref, SP: Sized,
 					)
 					.filter(|(_, _, info)| amount_msats >= info.direction().htlc_minimum_msat)
 					.filter(|(_, _, info)| amount_msats <= info.direction().htlc_maximum_msat)
+					.filter(|(_, scid, info)| {
+						scorer.channel_balance_certainty(*scid, info) >= MIN_CHANNEL_CERTAINTY
+					})
 					.map(move |(source, scid, info)| (source, scid, info, forward_node.clone()))
 			)
 			// Construct blinded paths where the counterparty's counterparty is the introduction

lightning/src/routing/scoring.rs

@@ -57,7 +57,7 @@
 //! [`find_route`]: crate::routing::router::find_route
 
 use crate::ln::msgs::DecodeError;
-use crate::routing::gossip::{EffectiveCapacity, NetworkGraph, NodeId};
+use crate::routing::gossip::{DirectedChannelInfo, EffectiveCapacity, NetworkGraph, NodeId};
 use crate::routing::router::{Path, CandidateRouteHop, PublicHopCandidate};
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
 use crate::util::logger::Logger;
@@ -97,6 +97,7 @@ pub trait ScoreLookUp {
 	/// on a per-routefinding-call basis through to the scorer methods,
 	/// which are used to determine the parameters for the suitability of channels for use.
 	type ScoreParams;
+
 	/// Returns the fee in msats willing to be paid to avoid routing `send_amt_msat` through the
 	/// given channel in the direction from `source` to `target`.
 	///
@@ -108,6 +109,16 @@ pub trait ScoreLookUp {
 	fn channel_penalty_msat(
 		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams
 	) -> u64;
+
+	/// Returns how certain any knowledge gained about the channel's liquidity balance is.
+	///
+	/// Expected to return a value between `0.0` and `1.0`, inclusive, where `0.0` indicates
+	/// complete uncertainty and `1.0` complete certainty.
+	///
+	/// This is useful to determine whether a channel should be included in a blinded path.
+	fn channel_balance_certainty(
+		&self, _short_channel_id: u64, _info: &DirectedChannelInfo
+	) -> f64 { 0.5 }
 }
 
 /// `ScoreUpdate` is used to update the scorer's internal state after a payment attempt.