From 59e24bd176de5ad4610c0a856336afb6ea92bf78 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Thu, 27 Oct 2022 16:58:30 -0400 Subject: [PATCH 1/4] Fix inaccurate comment in InvoicePayer --- lightning-invoice/src/payment.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 4b2a682b3..1b3177adf 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -606,9 +606,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. From dc7f65f703301f2125c1dd1e656272e5d0005b40 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Mon, 24 Oct 2022 20:17:03 -0400 Subject: [PATCH 2/4] Remove unused payment_hash param from Router::find_route This helps prepare for moving the Router trait into ChannelManager, which will help allow ChannelManager to retrieve routes for trampoline --- lightning-invoice/src/payment.rs | 20 +++++++++----------- lightning-invoice/src/utils.rs | 4 ++-- 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 1b3177adf..d46024c92 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -73,7 +73,7 @@ //! # 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 { unimplemented!() } //! # @@ -270,7 +270,7 @@ pub trait Payer { 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, + &self, payer: &PublicKey, route_params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs ) -> Result; /// Lets the router know that payment through a specific path has failed. @@ -447,8 +447,7 @@ where let first_hops = self.payer.first_hops(); let inflight_htlcs = self.create_inflight_map(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), - inflight_htlcs + &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs ).map_err(|e| PaymentError::Routing(e))?; match send_payment(&route) { @@ -552,8 +551,7 @@ where let inflight_htlcs = self.create_inflight_map(); let route = self.router.find_route( - &payer, ¶ms, &payment_hash, Some(&first_hops.iter().collect::>()), - inflight_htlcs + &payer, ¶ms, Some(&first_hops.iter().collect::>()), inflight_htlcs ); if route.is_err() { @@ -1812,7 +1810,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 { // Simulate calling the Scorer just as you would in find_route @@ -1865,8 +1863,8 @@ 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 { Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError }) } @@ -2127,8 +2125,8 @@ 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 { self.0.borrow_mut().pop_front().unwrap() } diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 8b45d5805..4d5d98f87 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -552,8 +552,8 @@ impl>, 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 { let random_seed_bytes = { let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap(); From 1840cae32150be8f18c11186995b76acc3172651 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Mon, 24 Oct 2022 20:38:48 -0400 Subject: [PATCH 3/4] Move InFlightHtlcs into ChannelManager This is part of moving the Router trait into ChannelManager, which will help allow ChannelManager to fetch routes on-the-fly as part of supporting trampoline payments. --- lightning-invoice/src/payment.rs | 39 +++++--------------------------- lightning-invoice/src/utils.rs | 4 ++-- lightning/src/routing/router.rs | 34 ++++++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 35 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index d46024c92..7d5aee052 100644 --- a/lightning-invoice/src/payment.rs +++ b/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}; //! # 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, Router}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; @@ -140,16 +140,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}; 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; @@ -641,7 +639,7 @@ where } } - InFlightHtlcs(total_inflight_map) + InFlightHtlcs::new(total_inflight_map) } } @@ -730,31 +728,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 { - self.0.get(&(channel_scid, source < target)).map(|v| *v) - } -} - -impl Writeable for InFlightHtlcs { - fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) } -} - -impl lightning::util::ser::Readable for InFlightHtlcs { - fn read(reader: &mut R) -> Result { - let infight_map: HashMap<(u64, bool), u64> = lightning::util::ser::Readable::read(reader)?; - Ok(Self(infight_map)) - } -} - #[cfg(test)] mod tests { use super::*; @@ -767,7 +740,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}; use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; use lightning::util::test_utils::TestLogger; use lightning::util::errors::APIError; @@ -1864,7 +1837,7 @@ mod tests { impl Router for FailingRouter { fn find_route( &self, _payer: &PublicKey, _params: &RouteParameters, _first_hops: Option<&[&ChannelDetails]>, - _inflight_htlcs: InFlightHtlcs + _inflight_htlcs: InFlightHtlcs, ) -> Result { Err(LightningError { err: String::new(), action: ErrorAction::IgnoreError }) } diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 4d5d98f87..52bfd31d8 100644 --- a/lightning-invoice/src/utils.rs +++ b/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, Router}; 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}; use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; use lightning::util::logger::Logger; use secp256k1::PublicKey; diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 0d37744db..fcb93c5f1 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -29,6 +29,40 @@ use alloc::collections::BinaryHeap; use core::cmp; use core::ops::Deref; +/// 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 { + self.0.get(&(channel_scid, source < target)).map(|v| *v) + } +} + +impl Writeable for InFlightHtlcs { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.0.write(writer) } +} + +impl Readable for InFlightHtlcs { + fn read(reader: &mut R) -> Result { + 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 { From 9d3324968c175661ae2d11c5c754688978f2fb7f Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Thu, 27 Oct 2022 18:00:23 -0400 Subject: [PATCH 4/4] Move InvoicePayer's Router into ChannelManager This helps prepare to parameterize ChannelManager with a Router, to eventually use in trampoline payments. --- lightning-invoice/src/payment.rs | 43 +++++++++++++++++++++----------- lightning-invoice/src/utils.rs | 9 +++++-- lightning/src/routing/router.rs | 9 +++++++ 3 files changed, 44 insertions(+), 17 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 7d5aee052..a64c84403 100644 --- a/lightning-invoice/src/payment.rs +++ b/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::{InFlightHtlcs, 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::{InvoicePayer, Payer, Retry, Router}; +//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; @@ -76,7 +76,8 @@ //! # &self, payer: &PublicKey, params: &RouteParameters, //! # first_hops: Option<&[&ChannelDetails]>, _inflight_htlcs: InFlightHtlcs //! # ) -> Result { 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!() } @@ -144,7 +145,7 @@ 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::{InFlightHtlcs, 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; @@ -175,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 +pub struct InvoicePayerUsingTime where P::Target: Payer, L::Target: Logger, @@ -264,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( +/// 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 - ) -> Result; + first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs, + _payment_hash: PaymentHash, _payment_id: PaymentId + ) -> Result { + 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. @@ -320,7 +328,7 @@ pub enum PaymentError { Sending(PaymentSendFailure), } -impl InvoicePayerUsingTime +impl InvoicePayerUsingTime where P::Target: Payer, L::Target: Logger, @@ -654,7 +662,7 @@ fn has_expired(route_params: &RouteParameters) -> bool { } else { false } } -impl EventHandler for InvoicePayerUsingTime +impl EventHandler for InvoicePayerUsingTime where P::Target: Payer, L::Target: Logger, @@ -740,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::{InFlightHtlcs, 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; @@ -1814,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); } @@ -1841,7 +1851,9 @@ mod tests { ) -> Result { 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]) {} @@ -2103,7 +2115,8 @@ mod tests { ) -> Result { 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]) {} diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 52bfd31d8..4c9c589b7 100644 --- a/lightning-invoice/src/utils.rs +++ b/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::{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::{InFlightHtlcs, 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; @@ -567,7 +567,12 @@ impl>, L: Deref, S: Deref> Router for DefaultR &random_seed_bytes ) } +} +impl>, L: Deref, S: Deref> ScoringRouter for DefaultRouter 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); } diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index fcb93c5f1..f102ad8da 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -29,6 +29,15 @@ 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; +} + /// 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