Move InflightHtlcs and Router trait into ChannelManager

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {

lightning-invoice/src/payment.rs

@@ -38,13 +38,13 @@
 //! # use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 //! # use lightning::ln::msgs::LightningError;
 //! # use lightning::routing::gossip::NodeId;
-//! # use lightning::routing::router::{Route, RouteHop, RouteParameters};
+//! # use lightning::routing::router::{InFlightHtlcs, Route, RouteHop, RouteParameters, Router};
 //! # use lightning::routing::scoring::{ChannelUsage, Score};
 //! # use lightning::util::events::{Event, EventHandler, EventsProvider};
 //! # use lightning::util::logger::{Logger, Record};
 //! # use lightning::util::ser::{Writeable, Writer};
 //! # use lightning_invoice::Invoice;
-//! # use lightning_invoice::payment::{InFlightHtlcs, InvoicePayer, Payer, Retry, Router};
+//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter};
 //! # use secp256k1::PublicKey;
 //! # use std::cell::RefCell;
 //! # use std::ops::Deref;
@@ -73,10 +73,11 @@
 //! # struct FakeRouter {}
 //! # impl Router for FakeRouter {
 //! # fn find_route(
-//! # &self, payer: &PublicKey, params: &RouteParameters, payment_hash: &PaymentHash,
+//! # &self, payer: &PublicKey, params: &RouteParameters,
 //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
 //! # ) -> Result<Route, LightningError> { unimplemented!() }
-//! #
+//! # }
+//! # impl ScoringRouter for FakeRouter {
 //! # fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { unimplemented!() }
 //! # fn notify_payment_path_successful(&self, path: &[&RouteHop]) { unimplemented!() }
 //! # fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { unimplemented!() }
@@ -140,16 +141,14 @@ use bitcoin_hashes::Hash;
 use bitcoin_hashes::sha256::Hash as Sha256;
 
 use crate::prelude::*;
-use lightning::io;
 use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
 use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::NodeId;
-use lightning::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters};
+use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
 use lightning::util::errors::APIError;
 use lightning::util::events::{Event, EventHandler};
 use lightning::util::logger::Logger;
-use lightning::util::ser::Writeable;
 use crate::time_utils::Time;
 use crate::sync::Mutex;
 
@@ -177,7 +176,7 @@ use crate::time_utils;
 type ConfiguredTime = time_utils::Eternity;
 
 /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias.
-pub struct InvoicePayerUsingTime<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time>
+pub struct InvoicePayerUsingTime<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -266,13 +265,20 @@ pub trait Payer {
 	fn abandon_payment(&self, payment_id: PaymentId);
 }
 
-/// A trait defining behavior for routing an [`Invoice`] payment.
-pub trait Router {
-	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
-	fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, payment_hash: &PaymentHash,
- first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
-	) -> Result<Route, LightningError>;
+/// A trait defining behavior for a [`Router`] implementation that also supports scoring channels
+/// based on payment and probe success/failure.
+///
+/// [`Router`]: lightning::routing::router::Router
+pub trait ScoringRouter: Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values. Includes
+	/// `PaymentHash` and `PaymentId` to be able to correlate the request with a specific payment.
+	fn find_route_with_id(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs,
+ _payment_hash: PaymentHash, _payment_id: PaymentId
+	) -> Result<Route, LightningError> {
+ self.find_route(payer, route_params, first_hops, inflight_htlcs)
+	}
 	/// Lets the router know that payment through a specific path has failed.
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64);
 	/// Lets the router know that payment through a specific path was successful.
@@ -322,7 +328,7 @@ pub enum PaymentError {
 	Sending(PaymentSendFailure),
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -447,8 +453,7 @@ where
  let first_hops = self.payer.first_hops();
  let inflight_htlcs = self.create_inflight_map();
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  ).map_err(|e| PaymentError::Routing(e))?;
 
  match send_payment(&route) {
@@ -552,8 +557,7 @@ where
  let inflight_htlcs = self.create_inflight_map();
 
  let route = self.router.find_route(
- &payer, &params, &payment_hash, Some(&first_hops.iter().collect::<Vec<_>>()),
- inflight_htlcs
+ &payer, &params, Some(&first_hops.iter().collect::<Vec<_>>()), inflight_htlcs
  );
 
  if route.is_err() {
@@ -606,9 +610,8 @@ where
  self.payment_cache.lock().unwrap().remove(payment_hash);
 	}
 
-	/// Given a [`PaymentHash`], this function looks up inflight path attempts in the payment_cache.
-	/// Then, it uses the path information inside the cache to construct a HashMap mapping a channel's
-	/// short channel id and direction to the amount being sent through it.
+	/// Use path information in the payment_cache to construct a HashMap mapping a channel's short
+	/// channel id and direction to the amount being sent through it.
 	///
 	/// This function should be called whenever we need information about currently used up liquidity
 	/// across payments.
@@ -644,7 +647,7 @@ where
  }
  }
 
- InFlightHtlcs(total_inflight_map)
+ InFlightHtlcs::new(total_inflight_map)
 	}
 }
 
@@ -659,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool {
 	} else { false }
 }
 
-impl<P: Deref, R: Router, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
+impl<P: Deref, R: ScoringRouter, L: Deref, E: EventHandler, T: Time> EventHandler for InvoicePayerUsingTime<P, R, L, E, T>
 where
 	P::Target: Payer,
 	L::Target: Logger,
@@ -733,31 +736,6 @@ where
 	}
 }
 
-/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
-/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
-/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
-/// details.
-pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
-
-impl InFlightHtlcs {
-	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
-	/// id.
-	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
- self.0.get(&(channel_scid, source < target)).map(|v| *v)
-	}
-}
-
-impl Writeable for InFlightHtlcs {
-	fn write<W: lightning::util::ser::Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
-}
-
-impl lightning::util::ser::Readable for InFlightHtlcs {
-	fn read<R: io::Read>(reader: &mut R) -> Result<Self, lightning::ln::msgs::DecodeError> {
- let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?;
- Ok(Self(infight_map))
-	}
-}
-
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -770,7 +748,7 @@ mod tests {
 	use lightning::ln::functional_test_utils::*;
 	use lightning::ln::msgs::{ChannelMessageHandler, ErrorAction, LightningError};
 	use lightning::routing::gossip::{EffectiveCapacity, NodeId};
-	use lightning::routing::router::{PaymentParameters, Route, RouteHop};
+	use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router};
 	use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 	use lightning::util::test_utils::TestLogger;
 	use lightning::util::errors::APIError;
@@ -1813,7 +1791,7 @@ mod tests {
 
 	impl Router for TestRouter {
  fn find_route(
- &self, payer: &PublicKey, route_params: &RouteParameters, _payment_hash: &PaymentHash,
+ &self, payer: &PublicKey, route_params: &RouteParameters,
  _first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  // Simulate calling the Scorer just as you would in find_route
@@ -1844,7 +1822,9 @@ mod tests {
  payment_params: Some(route_params.payment_params.clone()), ..Self::route_for_value(route_params.final_value_msat)
  })
  }
+	}
 
+	impl ScoringRouter for TestRouter {
  fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
  }
@@ -1866,12 +1846,14 @@ mod tests {
 
 	impl Router for FailingRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs,
  ) -> Result<Route, LightningError> {
  Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError })
  }
+	}
 
+	impl ScoringRouter for FailingRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}
@@ -2128,12 +2110,13 @@ mod tests {
 
 	impl Router for ManualRouter {
  fn find_route(
- &self, _payer: &PublicKey, _params: &RouteParameters, _payment_hash: &PaymentHash,
-_first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs
+ &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>,
+ _inflight_htlcs: InFlightHtlcs
  ) -> Result<Route, LightningError> {
  self.0.borrow_mut().pop_front().unwrap()
  }
-
+	}
+	impl ScoringRouter for ManualRouter {
  fn notify_payment_path_failed(&self, _path: &[&RouteHop], _short_channel_id: u64) {}
 
  fn notify_payment_path_successful(&self, _path: &[&RouteHop]) {}

lightning-invoice/src/utils.rs

@@ -1,7 +1,7 @@
 //! Convenient utilities to create an invoice.
 
 use crate::{CreationError, Currency, Invoice, InvoiceBuilder, SignOrCreationError};
-use crate::payment::{InFlightHtlcs, Payer, Router};
+use crate::payment::{Payer, ScoringRouter};
 
 use crate::{prelude::*, Description, InvoiceDescription, Sha256};
 use bech32::ToBase32;
@@ -16,7 +16,7 @@ use lightning::ln::channelmanager::{PhantomRouteHints, MIN_CLTV_EXPIRY_DELTA};
 use lightning::ln::inbound_payment::{create, create_from_hash, ExpandedKey};
 use lightning::ln::msgs::LightningError;
 use lightning::routing::gossip::{NetworkGraph, NodeId, RoutingFees};
-use lightning::routing::router::{Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop};
+use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router};
 use lightning::routing::scoring::{ChannelUsage, LockableScore, Score};
 use lightning::util::logger::Logger;
 use secp256k1::PublicKey;
@@ -552,8 +552,8 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
 	S::Target: for <'a> LockableScore<'a>,
 {
 	fn find_route(
- &self, payer: &PublicKey, params: &RouteParameters, _payment_hash: &PaymentHash,
-first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+ &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>,
+ inflight_htlcs: InFlightHtlcs
 	) -> Result<Route, LightningError> {
  let random_seed_bytes = {
  let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
@@ -567,7 +567,12 @@ impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> Router for DefaultR
  &random_seed_bytes
  )
 	}
+}
 
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref> ScoringRouter for DefaultRouter<G, L, S> where
+	L::Target: Logger,
+	S::Target: for <'a> LockableScore<'a>,
+{
 	fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) {
  self.scorer.lock().payment_path_failed(path, short_channel_id);
 	}

lightning/src/routing/router.rs

@@ -29,6 +29,49 @@ use alloc::collections::BinaryHeap;
 use core::cmp;
 use core::ops::Deref;
 
+/// A trait defining behavior for routing a payment.
+pub trait Router {
+	/// Finds a [`Route`] between `payer` and `payee` for a payment with the given values.
+	fn find_route(
+ &self, payer: &PublicKey, route_params: &RouteParameters,
+ first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs
+	) -> Result<Route, LightningError>;
+}
+
+/// A map with liquidity value (in msat) keyed by a short channel id and the direction the HTLC
+/// is traveling in. The direction boolean is determined by checking if the HTLC source's public
+/// key is less than its destination. See [`InFlightHtlcs::used_liquidity_msat`] for more
+/// details.
+#[cfg(not(any(test, feature = "_test_utils")))]
+pub struct InFlightHtlcs(HashMap<(u64, bool), u64>);
+#[cfg(any(test, feature = "_test_utils"))]
+pub struct InFlightHtlcs(pub HashMap<(u64, bool), u64>);
+
+impl InFlightHtlcs {
+	/// Create a new `InFlightHtlcs` via a mapping from:
+	/// (short_channel_id, source_pubkey < target_pubkey) -> used_liquidity_msat
+	pub fn new(inflight_map: HashMap<(u64, bool), u64>) -> Self {
+ InFlightHtlcs(inflight_map)
+	}
+
+	/// Returns liquidity in msat given the public key of the HTLC source, target, and short channel
+	/// id.
+	pub fn used_liquidity_msat(&self, source: &NodeId, target: &NodeId, channel_scid: u64) -> Option<u64> {
+ self.0.get(&(channel_scid, source < target)).map(|v| *v)
+	}
+}
+
+impl Writeable for InFlightHtlcs {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) }
+}
+
+impl Readable for InFlightHtlcs {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let infight_map: HashMap<(u64, bool), u64> = Readable::read(reader)?;
+ Ok(Self(infight_map))
+	}
+}
+
 /// A hop in a route
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct RouteHop {