Hard-code scorer parameters to ProbabilisticScoringFeeParameters

The scorer currently relies on an associated type for the fee
parameters. This isn't supportable at all in bindings, and for
lack of a better option we simply hard-code the parameter for all
scorers  to `ProbabilisticScoringFeeParameters`.

Author: TheBlueMatt

lightning-background-processor/src/lib.rs

@@ -348,11 +348,6 @@ type DynRouter = lightning::routing::router::DefaultRouter<
 			&'static (dyn Logger + Send + Sync),
 		>,
 	>,
-	lightning::routing::scoring::ProbabilisticScoringFeeParameters,
-	lightning::routing::scoring::ProbabilisticScorer<
-		&'static NetworkGraph<&'static (dyn Logger + Send + Sync)>,
-		&'static (dyn Logger + Send + Sync),
-	>,
 >;
 
 #[cfg(not(c_bindings))]
@@ -1899,8 +1894,6 @@ mod tests {
 				Arc<test_utils::TestLogger>,
 				Arc<KeysManager>,
 				Arc<LockingWrapper<TestScorer>>,
-				(),
-				TestScorer,
 			>,
 		>,
 		Arc<
@@ -2187,10 +2180,11 @@ mod tests {
 	}
 
 	impl ScoreLookUp for TestScorer {
+		#[cfg(not(c_bindings))]
 		type ScoreParams = ();
 		fn channel_penalty_msat(
 			&self, _candidate: &CandidateRouteHop, _usage: ChannelUsage,
-			_score_params: &Self::ScoreParams,
+			_score_params: &lightning::routing::scoring::ProbabilisticScoringFeeParameters,
 		) -> u64 {
 			unimplemented!();
 		}

lightning/src/ln/channelmanager.rs

@@ -1743,8 +1743,6 @@ pub type SimpleArcChannelManager<M, T, F, L> = ChannelManager<
 			Arc<L>,
 			Arc<KeysManager>,
 			Arc<RwLock<ProbabilisticScorer<Arc<NetworkGraph<Arc<L>>>, Arc<L>>>>,
-			ProbabilisticScoringFeeParameters,
-			ProbabilisticScorer<Arc<NetworkGraph<Arc<L>>>, Arc<L>>,
 		>,
 	>,
 	Arc<DefaultMessageRouter<Arc<NetworkGraph<Arc<L>>>, Arc<L>, Arc<KeysManager>>>,
@@ -1775,8 +1773,6 @@ pub type SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, M, T, F, L>
 		&'g L,
 		&'c KeysManager,
 		&'h RwLock<ProbabilisticScorer<&'f NetworkGraph<&'g L>, &'g L>>,
-		ProbabilisticScoringFeeParameters,
-		ProbabilisticScorer<&'f NetworkGraph<&'g L>, &'g L>,
 	>,
 	&'i DefaultMessageRouter<&'f NetworkGraph<&'g L>, &'g L, &'c KeysManager>,
 	&'g L,
@@ -1961,7 +1957,7 @@ where
 /// #     fee_estimator: &dyn lightning::chain::chaininterface::FeeEstimator,
 /// #     chain_monitor: &dyn lightning::chain::Watch<lightning::sign::InMemorySigner>,
 /// #     tx_broadcaster: &dyn lightning::chain::chaininterface::BroadcasterInterface,
-/// #     router: &lightning::routing::router::DefaultRouter<&NetworkGraph<&'a L>, &'a L, &ES, &S, SP, SL>,
+/// #     router: &lightning::routing::router::DefaultRouter<&NetworkGraph<&'a L>, &'a L, &ES, &S>,
 /// #     message_router: &lightning::onion_message::messenger::DefaultMessageRouter<&NetworkGraph<&'a L>, &'a L, &ES>,
 /// #     logger: &L,
 /// #     entropy_source: &ES,

lightning/src/routing/router.rs

@@ -60,36 +60,32 @@ pub struct DefaultRouter<
 	L: Deref,
 	ES: Deref,
 	S: Deref,
-	SP: Sized,
-	Sc: ScoreLookUp<ScoreParams = SP>,
 > where
 	L::Target: Logger,
-	S::Target: for<'a> LockableScore<'a, ScoreLookUp = Sc>,
+	S::Target: for<'a> LockableScore<'a>,
 	ES::Target: EntropySource,
 {
 	network_graph: G,
 	logger: L,
 	entropy_source: ES,
 	scorer: S,
-	score_params: SP,
+	score_params: crate::routing::scoring::ProbabilisticScoringFeeParameters,
 }
 
 impl<
 		G: Deref<Target = NetworkGraph<L>>,
 		L: Deref,
 		ES: Deref,
 		S: Deref,
-		SP: Sized,
-		Sc: ScoreLookUp<ScoreParams = SP>,
-	> DefaultRouter<G, L, ES, S, SP, Sc>
+	> DefaultRouter<G, L, ES, S>
 where
 	L::Target: Logger,
-	S::Target: for<'a> LockableScore<'a, ScoreLookUp = Sc>,
+	S::Target: for<'a> LockableScore<'a>,
 	ES::Target: EntropySource,
 {
 	/// Creates a new router.
 	pub fn new(
-		network_graph: G, logger: L, entropy_source: ES, scorer: S, score_params: SP,
+		network_graph: G, logger: L, entropy_source: ES, scorer: S, score_params: crate::routing::scoring::ProbabilisticScoringFeeParameters,
 	) -> Self {
 		Self { network_graph, logger, entropy_source, scorer, score_params }
 	}
@@ -100,12 +96,10 @@ impl<
 		L: Deref,
 		ES: Deref,
 		S: Deref,
-		SP: Sized,
-		Sc: ScoreLookUp<ScoreParams = SP>,
-	> Router for DefaultRouter<G, L, ES, S, SP, Sc>
+	> Router for DefaultRouter<G, L, ES, S>
 where
 	L::Target: Logger,
-	S::Target: for<'a> LockableScore<'a, ScoreLookUp = Sc>,
+	S::Target: for<'a> LockableScore<'a>,
 	ES::Target: EntropySource,
 {
 	#[rustfmt::skip]
@@ -320,9 +314,10 @@ impl<'a, S: Deref> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, S>
 where
 	S::Target: ScoreLookUp,
 {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = <S::Target as ScoreLookUp>::ScoreParams;
 	#[rustfmt::skip]
-	fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams) -> u64 {
+	fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters) -> u64 {
 		let target = match candidate.target() {
 			Some(target) => target,
 			None => return self.scorer.channel_penalty_msat(candidate, usage, score_params),
@@ -2420,7 +2415,7 @@ fn sort_first_hop_channels(
 pub fn find_route<L: Deref, GL: Deref, S: ScoreLookUp>(
 	our_node_pubkey: &PublicKey, route_params: &RouteParameters,
 	network_graph: &NetworkGraph<GL>, first_hops: Option<&[&ChannelDetails]>, logger: L,
-	scorer: &S, score_params: &S::ScoreParams, random_seed_bytes: &[u8; 32]
+	scorer: &S, score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters, random_seed_bytes: &[u8; 32]
 ) -> Result<Route, &'static str>
 where L::Target: Logger, GL::Target: Logger {
 	let graph_lock = network_graph.read_only();
@@ -2433,7 +2428,7 @@ where L::Target: Logger, GL::Target: Logger {
 #[rustfmt::skip]
 pub(crate) fn get_route<L: Deref, S: ScoreLookUp>(
 	our_node_pubkey: &PublicKey, route_params: &RouteParameters, network_graph: &ReadOnlyNetworkGraph,
-	first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S, score_params: &S::ScoreParams,
+	first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S, score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters,
 	_random_seed_bytes: &[u8; 32]
 ) -> Result<Route, &'static str>
 where L::Target: Logger {
@@ -3845,9 +3840,10 @@ fn build_route_from_hops_internal<L: Deref>(
 	}
 
 	impl ScoreLookUp for HopScorer {
+		#[cfg(not(c_bindings))]
 		type ScoreParams = ();
 		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop,
-			_usage: ChannelUsage, _score_params: &Self::ScoreParams) -> u64
+			_usage: ChannelUsage, _score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters) -> u64
 		{
 			let mut cur_id = self.our_node_id;
 			for i in 0..self.hop_ids.len() {
@@ -7222,9 +7218,10 @@ mod tests {
 		fn write<W: Writer>(&self, _w: &mut W) -> Result<(), crate::io::Error> { unimplemented!() }
 	}
 	impl ScoreLookUp for BadChannelScorer {
+		#[cfg(not(c_bindings))]
 		type ScoreParams = ();
 		#[rustfmt::skip]
-		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 {
+		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&crate::routing::scoring::ProbabilisticScoringFeeParameters) -> u64 {
 			if candidate.short_channel_id() == Some(self.short_channel_id) { u64::max_value()  } else { 0  }
 		}
 	}
@@ -7240,9 +7237,10 @@ mod tests {
 	}
 
 	impl ScoreLookUp for BadNodeScorer {
+		#[cfg(not(c_bindings))]
 		type ScoreParams = ();
 		#[rustfmt::skip]
-		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 {
+		fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&crate::routing::scoring::ProbabilisticScoringFeeParameters) -> u64 {
 			if candidate.target() == Some(self.node_id) { u64::max_value() } else { 0 }
 		}
 	}
@@ -9385,7 +9383,7 @@ pub(crate) mod bench_utils {
 
 	#[rustfmt::skip]
 	pub(crate) fn generate_test_routes<S: ScoreLookUp + ScoreUpdate>(graph: &NetworkGraph<&TestLogger>, scorer: &mut S,
-		score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, mut seed: u64,
+		score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters, features: Bolt11InvoiceFeatures, mut seed: u64,
 		starting_amount: u64, route_count: usize,
 	) -> Vec<(ChannelDetails, PaymentParameters, u64)> {
 		let payer = payer_pubkey();
@@ -9528,7 +9526,7 @@ pub mod benches {
 	#[rustfmt::skip]
 	fn generate_routes<S: ScoreLookUp + ScoreUpdate>(
 		bench: &mut Criterion, graph: &NetworkGraph<&TestLogger>, mut scorer: S,
-		score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, starting_amount: u64,
+		score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters, features: Bolt11InvoiceFeatures, starting_amount: u64,
 		bench_name: &'static str,
 	) {
 		// First, get 100 (source, destination) pairs for which route-getting actually succeeds...

lightning/src/routing/scoring.rs

@@ -92,9 +92,13 @@ macro_rules! define_score { ($($supertrait: path)*) => {
 ///
 /// Scoring is in terms of fees willing to be paid in order to avoid routing through a channel.
 pub trait ScoreLookUp {
+	#[cfg(not(c_bindings))]
 	/// A configurable type which should contain various passed-in parameters for configuring the scorer,
 	/// 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.
+	///
+	/// Note that due to limitations in many other languages' generics features, language bindings
+	/// use [`ProbabilisticScoringFeeParameters`] for the parameters on all scorers.
 	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`.
@@ -105,7 +109,7 @@ pub trait ScoreLookUp {
 	/// [`u64::max_value`] is given to indicate sufficient capacity for the invoice's full amount.
 	/// Thus, implementations should be overflow-safe.
 	fn channel_penalty_msat(
-		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams
+		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &ProbabilisticScoringFeeParameters
 	) -> u64;
 }
 
@@ -143,9 +147,10 @@ impl<T: ScoreLookUp + ScoreUpdate $(+ $supertrait)*> Score for T {}
 
 #[cfg(not(c_bindings))]
 impl<S: ScoreLookUp, T: Deref<Target=S>> ScoreLookUp for T {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = S::ScoreParams;
 	fn channel_penalty_msat(
-		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams
+		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &ProbabilisticScoringFeeParameters
 	) -> u64 {
 		self.deref().channel_penalty_msat(candidate, usage, score_params)
 	}
@@ -326,9 +331,10 @@ impl<'a, T: 'a + Score> Deref for MultiThreadedScoreLockRead<'a, T> {
 
 #[cfg(c_bindings)]
 impl<'a, T: Score> ScoreLookUp for MultiThreadedScoreLockRead<'a, T> {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = T::ScoreParams;
 	fn channel_penalty_msat(
-		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams,
+		&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &ProbabilisticScoringFeeParameters,
 	) -> u64 {
 		self.0.channel_penalty_msat(candidate, usage, score_params)
 	}
@@ -410,9 +416,10 @@ impl FixedPenaltyScorer {
 }
 
 impl ScoreLookUp for FixedPenaltyScorer {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = ();
 	fn channel_penalty_msat(
-		&self, _: &CandidateRouteHop, _: ChannelUsage, _score_params: &Self::ScoreParams,
+		&self, _: &CandidateRouteHop, _: ChannelUsage, _score_params: &ProbabilisticScoringFeeParameters,
 	) -> u64 {
 		self.penalty_msat
 	}
@@ -1673,6 +1680,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreLookUp for Probabilistic
 where
 	L::Target: Logger,
 {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = ProbabilisticScoringFeeParameters;
 	#[rustfmt::skip]
 	fn channel_penalty_msat(
@@ -1882,6 +1890,7 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref> ScoreLookUp for CombinedScore
 where
 	L::Target: Logger,
 {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = ProbabilisticScoringFeeParameters;
 
 	fn channel_penalty_msat(

lightning/src/util/test_utils.rs

@@ -143,8 +143,6 @@ pub struct TestRouter<'a> {
 		&'a TestLogger,
 		Arc<RandomBytes>,
 		&'a RwLock<TestScorer>,
-		(),
-		TestScorer,
 	>,
 	pub network_graph: Arc<NetworkGraph<&'a TestLogger>>,
 	pub next_routes: Mutex<VecDeque<(RouteParameters, Option<Result<Route, &'static str>>)>>,
@@ -2119,10 +2117,11 @@ impl crate::util::ser::Writeable for TestScorer {
 }
 
 impl ScoreLookUp for TestScorer {
+	#[cfg(not(c_bindings))]
 	type ScoreParams = ();
 	fn channel_penalty_msat(
 		&self, candidate: &CandidateRouteHop, usage: ChannelUsage,
-		_score_params: &Self::ScoreParams,
+		_score_params: &crate::routing::scoring::ProbabilisticScoringFeeParameters,
 	) -> u64 {
 		let short_channel_id = match candidate.globally_unique_short_channel_id() {
 			Some(scid) => scid,