From 685b37069449ecdfe4522dfd67e8d2afdc742b08 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Wed, 16 Nov 2022 14:38:42 -0500 Subject: [PATCH 1/4] Move ScoringRouter methods to Router This helps us prepare to move all payment retries into ChannelManager, which is needed for trampoline payments. --- lightning-invoice/src/payment.rs | 47 ++++++-------------------------- lightning-invoice/src/utils.rs | 7 +---- lightning/src/routing/router.rs | 20 +++++++++++++- 3 files changed, 28 insertions(+), 46 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index eceaacf86c9..50a7cf3602c 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -44,7 +44,7 @@ //! # use lightning::util::logger::{Logger, Record}; //! # use lightning::util::ser::{Writeable, Writer}; //! # use lightning_invoice::Invoice; -//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry, ScoringRouter}; +//! # use lightning_invoice::payment::{InvoicePayer, Payer, Retry}; //! # use secp256k1::PublicKey; //! # use std::cell::RefCell; //! # use std::ops::Deref; @@ -78,8 +78,6 @@ //! # &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!() } @@ -146,7 +144,7 @@ use crate::prelude::*; use lightning::ln::{PaymentHash, PaymentPreimage, PaymentSecret}; use lightning::ln::channelmanager::{ChannelDetails, PaymentId, PaymentSendFailure}; use lightning::ln::msgs::LightningError; -use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router}; +use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteParameters, Router}; use lightning::util::events::{Event, EventHandler}; use lightning::util::logger::Logger; use crate::time_utils::Time; @@ -186,7 +184,7 @@ mod sealed { /// (C-not exported) generally all users should use the [`InvoicePayer`] type alias. pub struct InvoicePayerUsingTime< P: Deref, - R: ScoringRouter, + R: Router, L: Deref, E: sealed::BaseEventHandler, T: Time @@ -279,30 +277,6 @@ pub trait Payer { fn inflight_htlcs(&self) -> InFlightHtlcs; } -/// 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 { - 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. - fn notify_payment_path_successful(&self, path: &[&RouteHop]); - /// Lets the router know that a payment probe was successful. - fn notify_payment_probe_successful(&self, path: &[&RouteHop]); - /// Lets the router know that a payment probe failed. - fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64); -} - /// Strategies available to retry payment path failures for an [`Invoice`]. /// #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] @@ -342,7 +316,7 @@ pub enum PaymentError { Sending(PaymentSendFailure), } -impl +impl InvoicePayerUsingTime where P::Target: Payer, @@ -656,7 +630,7 @@ fn has_expired(route_params: &RouteParameters) -> bool { } else { false } } -impl +impl InvoicePayerUsingTime where P::Target: Payer, @@ -723,7 +697,7 @@ where } } -impl +impl EventHandler for InvoicePayerUsingTime where P::Target: Payer, @@ -737,7 +711,7 @@ where } } -impl F> +impl F> InvoicePayerUsingTime where P::Target: Payer, @@ -1726,9 +1700,7 @@ 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); } @@ -1755,9 +1727,7 @@ 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]) {} @@ -2045,8 +2015,7 @@ 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 5d54e376bed..4822fe32ace 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, ScoringRouter}; +use crate::payment::Payer; use crate::{prelude::*, Description, InvoiceDescription, Sha256}; use bech32::ToBase32; @@ -567,12 +567,7 @@ 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 2d3eed66145..aa265e53136 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -14,7 +14,8 @@ use bitcoin::secp256k1::PublicKey; -use crate::ln::channelmanager::ChannelDetails; +use crate::ln::PaymentHash; +use crate::ln::channelmanager::{ChannelDetails, PaymentId}; use crate::ln::features::{ChannelFeatures, InvoiceFeatures, NodeFeatures}; use crate::ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT}; use crate::routing::gossip::{DirectedChannelInfo, EffectiveCapacity, ReadOnlyNetworkGraph, NetworkGraph, NodeId, RoutingFees}; @@ -36,6 +37,23 @@ pub trait Router { &self, payer: &PublicKey, route_params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs ) -> Result; + /// 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 { + 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. + fn notify_payment_path_successful(&self, path: &[&RouteHop]); + /// Lets the router know that a payment probe was successful. + fn notify_payment_probe_successful(&self, path: &[&RouteHop]); + /// Lets the router know that a payment probe failed. + fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64); } /// A data structure for tracking in-flight HTLCs. May be used during pathfinding to account for From 5f49011c444fb80f2c68921d59c7cf5cb349e153 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Wed, 16 Nov 2022 21:29:10 -0500 Subject: [PATCH 2/4] Fix typo in ScorerAccountingForInFlightHtlcs --- lightning-invoice/src/utils.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 4822fe32ace..0d4c4b5fee5 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -651,11 +651,11 @@ impl<'a, S:Score> lightning::util::ser::Writeable for ScorerAccountingForInFligh impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 { - if let Some(used_liqudity) = self.inflight_htlcs.used_liquidity_msat( + if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat( source, target, short_channel_id ) { let usage = ChannelUsage { - inflight_htlc_msat: usage.inflight_htlc_msat + used_liqudity, + inflight_htlc_msat: usage.inflight_htlc_msat + used_liquidity, ..usage }; From 3f9868f2350db93e2f5256aee2112ccabf1b531a Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Mon, 21 Nov 2022 15:51:28 -0500 Subject: [PATCH 3/4] Move ScorerAccountingForInFlightHtlcs to router + make public We move it to router instead of scoring because it pairs with the InFlightHtlcs struct in router and is useful for custom Router trait implementations --- lightning-invoice/src/payment.rs | 4 +-- lightning-invoice/src/utils.rs | 54 ++-------------------------- lightning/src/routing/router.rs | 60 ++++++++++++++++++++++++++++++++ 3 files changed, 65 insertions(+), 53 deletions(-) diff --git a/lightning-invoice/src/payment.rs b/lightning-invoice/src/payment.rs index 50a7cf3602c..4fddedc0c07 100644 --- a/lightning-invoice/src/payment.rs +++ b/lightning-invoice/src/payment.rs @@ -731,7 +731,7 @@ where mod tests { use super::*; use crate::{InvoiceBuilder, Currency}; - use crate::utils::{ScorerAccountingForInFlightHtlcs, create_invoice_from_channelmanager_and_duration_since_epoch}; + use crate::utils::create_invoice_from_channelmanager_and_duration_since_epoch; use bitcoin_hashes::sha256::Hash as Sha256; use lightning::ln::PaymentPreimage; use lightning::ln::channelmanager; @@ -739,7 +739,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, Router}; + use lightning::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, Router, ScorerAccountingForInFlightHtlcs}; use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; use lightning::util::test_utils::TestLogger; use lightning::util::errors::APIError; diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 0d4c4b5fee5..15ff9d6f47f 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -15,9 +15,9 @@ use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, P 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, Router}; -use lightning::routing::scoring::{ChannelUsage, LockableScore, Score}; +use lightning::routing::gossip::{NetworkGraph, RoutingFees}; +use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router, ScorerAccountingForInFlightHtlcs}; +use lightning::routing::scoring::{LockableScore, Score}; use lightning::util::logger::Logger; use secp256k1::PublicKey; use core::ops::Deref; @@ -627,54 +627,6 @@ where fn inflight_htlcs(&self) -> InFlightHtlcs { self.compute_inflight_htlcs() } } - -/// Used to store information about all the HTLCs that are inflight across all payment attempts. -pub(crate) struct ScorerAccountingForInFlightHtlcs<'a, S: Score> { - scorer: &'a mut S, - /// Maps a channel's short channel id and its direction to the liquidity used up. - inflight_htlcs: InFlightHtlcs, -} - -impl<'a, S: Score> ScorerAccountingForInFlightHtlcs<'a, S> { - pub(crate) fn new(scorer: &'a mut S, inflight_htlcs: InFlightHtlcs) -> Self { - ScorerAccountingForInFlightHtlcs { - scorer, - inflight_htlcs - } - } -} - -#[cfg(c_bindings)] -impl<'a, S:Score> lightning::util::ser::Writeable for ScorerAccountingForInFlightHtlcs<'a, S> { - fn write(&self, writer: &mut W) -> Result<(), lightning::io::Error> { self.scorer.write(writer) } -} - -impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { - fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 { - if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat( - source, target, short_channel_id - ) { - let usage = ChannelUsage { - inflight_htlc_msat: usage.inflight_htlc_msat + used_liquidity, - ..usage - }; - - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) - } else { - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) - } - } - - fn payment_path_failed(&mut self, _path: &[&RouteHop], _short_channel_id: u64) { unreachable!() } - - fn payment_path_successful(&mut self, _path: &[&RouteHop]) { unreachable!() } - - fn probe_failed(&mut self, _path: &[&RouteHop], _short_channel_id: u64) { unreachable!() } - - fn probe_successful(&mut self, _path: &[&RouteHop]) { unreachable!() } -} - - #[cfg(test)] mod test { use core::time::Duration; diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index aa265e53136..fa841d89231 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -56,6 +56,66 @@ pub trait Router { fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64); } +/// [`Score`] implementation that factors in in-flight HTLC liquidity. +/// +/// Useful for custom [`Router`] implementations to wrap their [`Score`] on-the-fly when calling +/// [`find_route`]. +/// +/// [`Score`]: crate::routing::scoring::Score +pub struct ScorerAccountingForInFlightHtlcs<'a, S: Score> { + scorer: &'a mut S, + // Maps a channel's short channel id and its direction to the liquidity used up. + inflight_htlcs: InFlightHtlcs, +} + +impl<'a, S: Score> ScorerAccountingForInFlightHtlcs<'a, S> { + /// Initialize a new `ScorerAccountingForInFlightHtlcs`. + pub fn new(scorer: &'a mut S, inflight_htlcs: InFlightHtlcs) -> Self { + ScorerAccountingForInFlightHtlcs { + scorer, + inflight_htlcs + } + } +} + +#[cfg(c_bindings)] +impl<'a, S:Score> Writeable for ScorerAccountingForInFlightHtlcs<'a, S> { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.scorer.write(writer) } +} + +impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { + fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage) -> u64 { + if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat( + source, target, short_channel_id + ) { + let usage = ChannelUsage { + inflight_htlc_msat: usage.inflight_htlc_msat + used_liquidity, + ..usage + }; + + self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) + } else { + self.scorer.channel_penalty_msat(short_channel_id, source, target, usage) + } + } + + fn payment_path_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.payment_path_failed(path, short_channel_id) + } + + fn payment_path_successful(&mut self, path: &[&RouteHop]) { + self.scorer.payment_path_successful(path) + } + + fn probe_failed(&mut self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.probe_failed(path, short_channel_id) + } + + fn probe_successful(&mut self, path: &[&RouteHop]) { + self.scorer.probe_successful(path) + } +} + /// A data structure for tracking in-flight HTLCs. May be used during pathfinding to account for /// in-use channel liquidity. pub struct InFlightHtlcs( From 8a51a792aa0967503c317531aef5ad336dc07d41 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Mon, 21 Nov 2022 17:07:44 -0500 Subject: [PATCH 4/4] Move DefaultRouter to router module --- lightning-background-processor/src/lib.rs | 2 +- lightning-invoice/src/utils.rs | 70 +---------------------- lightning/src/routing/router.rs | 65 ++++++++++++++++++++- 3 files changed, 68 insertions(+), 69 deletions(-) diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs index ece82bcaa55..83f4aac1387 100644 --- a/lightning-background-processor/src/lib.rs +++ b/lightning-background-processor/src/lib.rs @@ -580,13 +580,13 @@ mod tests { use lightning::ln::msgs::{ChannelMessageHandler, Init}; use lightning::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler}; use lightning::routing::gossip::{NetworkGraph, P2PGossipSync}; + use lightning::routing::router::DefaultRouter; use lightning::util::config::UserConfig; use lightning::util::events::{Event, MessageSendEventsProvider, MessageSendEvent}; use lightning::util::ser::Writeable; use lightning::util::test_utils; use lightning::util::persist::KVStorePersister; use lightning_invoice::payment::{InvoicePayer, Retry}; - use lightning_invoice::utils::DefaultRouter; use lightning_persister::FilesystemPersister; use std::fs; use std::path::PathBuf; diff --git a/lightning-invoice/src/utils.rs b/lightning-invoice/src/utils.rs index 15ff9d6f47f..b5ab740de5f 100644 --- a/lightning-invoice/src/utils.rs +++ b/lightning-invoice/src/utils.rs @@ -5,7 +5,7 @@ use crate::payment::Payer; use crate::{prelude::*, Description, InvoiceDescription, Sha256}; use bech32::ToBase32; -use bitcoin_hashes::{Hash, sha256}; +use bitcoin_hashes::Hash; use lightning::chain; use lightning::chain::chaininterface::{BroadcasterInterface, FeeEstimator}; use lightning::chain::keysinterface::{Recipient, KeysInterface}; @@ -14,15 +14,12 @@ use lightning::ln::channelmanager::{ChannelDetails, ChannelManager, PaymentId, P #[cfg(feature = "std")] 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, RoutingFees}; -use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop, RouteParameters, find_route, RouteHop, Router, ScorerAccountingForInFlightHtlcs}; -use lightning::routing::scoring::{LockableScore, Score}; +use lightning::routing::gossip::RoutingFees; +use lightning::routing::router::{InFlightHtlcs, Route, RouteHint, RouteHintHop}; use lightning::util::logger::Logger; use secp256k1::PublicKey; use core::ops::Deref; use core::time::Duration; -use crate::sync::Mutex; #[cfg(feature = "std")] /// Utility to create an invoice that can be paid to one of multiple nodes, or a "phantom invoice." @@ -524,67 +521,6 @@ fn filter_channels( .collect::>() } -/// A [`Router`] implemented using [`find_route`]. -pub struct DefaultRouter>, L: Deref, S: Deref> where - L::Target: Logger, - S::Target: for <'a> LockableScore<'a>, -{ - network_graph: G, - logger: L, - random_seed_bytes: Mutex<[u8; 32]>, - scorer: S -} - -impl>, L: Deref, S: Deref> DefaultRouter where - L::Target: Logger, - S::Target: for <'a> LockableScore<'a>, -{ - /// Creates a new router using the given [`NetworkGraph`], a [`Logger`], and a randomness source - /// `random_seed_bytes`. - pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32], scorer: S) -> Self { - let random_seed_bytes = Mutex::new(random_seed_bytes); - Self { network_graph, logger, random_seed_bytes, scorer } - } -} - -impl>, L: Deref, S: Deref> Router for DefaultRouter where - L::Target: Logger, - S::Target: for <'a> LockableScore<'a>, -{ - fn find_route( - &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(); - *locked_random_seed_bytes = sha256::Hash::hash(&*locked_random_seed_bytes).into_inner(); - *locked_random_seed_bytes - }; - - find_route( - payer, params, &self.network_graph, first_hops, &*self.logger, - &ScorerAccountingForInFlightHtlcs::new(&mut self.scorer.lock(), inflight_htlcs), - &random_seed_bytes - ) - } - - fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { - self.scorer.lock().payment_path_failed(path, short_channel_id); - } - - fn notify_payment_path_successful(&self, path: &[&RouteHop]) { - self.scorer.lock().payment_path_successful(path); - } - - fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { - self.scorer.lock().probe_successful(path); - } - - fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64) { - self.scorer.lock().probe_failed(path, short_channel_id); - } -} - impl Payer for ChannelManager where M::Target: chain::Watch<::Signer>, diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index fa841d89231..570bef7f86d 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -13,23 +13,86 @@ //! interrogate it to get routes for your own payments. use bitcoin::secp256k1::PublicKey; +use bitcoin::hashes::Hash; +use bitcoin::hashes::sha256::Hash as Sha256; use crate::ln::PaymentHash; use crate::ln::channelmanager::{ChannelDetails, PaymentId}; use crate::ln::features::{ChannelFeatures, InvoiceFeatures, NodeFeatures}; use crate::ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT}; use crate::routing::gossip::{DirectedChannelInfo, EffectiveCapacity, ReadOnlyNetworkGraph, NetworkGraph, NodeId, RoutingFees}; -use crate::routing::scoring::{ChannelUsage, Score}; +use crate::routing::scoring::{ChannelUsage, LockableScore, Score}; use crate::util::ser::{Writeable, Readable, Writer}; use crate::util::logger::{Level, Logger}; use crate::util::chacha20::ChaCha20; use crate::io; use crate::prelude::*; +use crate::sync::Mutex; use alloc::collections::BinaryHeap; use core::cmp; use core::ops::Deref; +/// A [`Router`] implemented using [`find_route`]. +pub struct DefaultRouter>, L: Deref, S: Deref> where + L::Target: Logger, + S::Target: for <'a> LockableScore<'a>, +{ + network_graph: G, + logger: L, + random_seed_bytes: Mutex<[u8; 32]>, + scorer: S +} + +impl>, L: Deref, S: Deref> DefaultRouter where + L::Target: Logger, + S::Target: for <'a> LockableScore<'a>, +{ + /// Creates a new router. + pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32], scorer: S) -> Self { + let random_seed_bytes = Mutex::new(random_seed_bytes); + Self { network_graph, logger, random_seed_bytes, scorer } + } +} + +impl>, L: Deref, S: Deref> Router for DefaultRouter where + L::Target: Logger, + S::Target: for <'a> LockableScore<'a>, +{ + fn find_route( + &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(); + *locked_random_seed_bytes = Sha256::hash(&*locked_random_seed_bytes).into_inner(); + *locked_random_seed_bytes + }; + + find_route( + payer, params, &self.network_graph, first_hops, &*self.logger, + &ScorerAccountingForInFlightHtlcs::new(&mut self.scorer.lock(), inflight_htlcs), + &random_seed_bytes + ) + } + + fn notify_payment_path_failed(&self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.lock().payment_path_failed(path, short_channel_id); + } + + fn notify_payment_path_successful(&self, path: &[&RouteHop]) { + self.scorer.lock().payment_path_successful(path); + } + + fn notify_payment_probe_successful(&self, path: &[&RouteHop]) { + self.scorer.lock().probe_successful(path); + } + + fn notify_payment_probe_failed(&self, path: &[&RouteHop], short_channel_id: u64) { + self.scorer.lock().probe_failed(path, short_channel_id); + } +} + /// 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.