From 1840cae32150be8f18c11186995b76acc3172651 Mon Sep 17 00:00:00 2001 From: Valentine Wallace Date: Mon, 24 Oct 2022 20:38:48 -0400 Subject: [PATCH] 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 { -- 2.39.5