X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=7abca061f3b480cfd9d011b9bd70cdbc53778b76;hb=b315856e686dd9e72a7ff93616f314ca6a037b56;hp=b33e021ab4fc30357a1124885c45b076419aed61;hpb=288fe0298ae0dd3550c4618e4f10d67d810aa997;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index b33e021a..7abca061 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -16,9 +16,9 @@ use bitcoin::hashes::sha256::Hash as Sha256; use crate::blinded_path::{BlindedHop, BlindedPath}; use crate::ln::PaymentHash; use crate::ln::channelmanager::{ChannelDetails, PaymentId}; -use crate::ln::features::{Bolt12InvoiceFeatures, ChannelFeatures, InvoiceFeatures, NodeFeatures}; +use crate::ln::features::{Bolt11InvoiceFeatures, Bolt12InvoiceFeatures, ChannelFeatures, NodeFeatures}; use crate::ln::msgs::{DecodeError, ErrorAction, LightningError, MAX_VALUE_MSAT}; -use crate::offers::invoice::BlindedPayInfo; +use crate::offers::invoice::{BlindedPayInfo, Bolt12Invoice}; use crate::routing::gossip::{DirectedChannelInfo, EffectiveCapacity, ReadOnlyNetworkGraph, NetworkGraph, NodeId, RoutingFees}; use crate::routing::scoring::{ChannelUsage, LockableScore, Score}; use crate::util::ser::{Writeable, Readable, ReadableArgs, Writer}; @@ -27,15 +27,15 @@ use crate::util::chacha20::ChaCha20; use crate::io; use crate::prelude::*; -use crate::sync::{Mutex, MutexGuard}; +use crate::sync::{Mutex}; use alloc::collections::BinaryHeap; use core::{cmp, fmt}; -use core::ops::Deref; +use core::ops::{Deref, DerefMut}; /// A [`Router`] implemented using [`find_route`]. pub struct DefaultRouter>, L: Deref, S: Deref, SP: Sized, Sc: Score> where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, Score = Sc>, { network_graph: G, logger: L, @@ -46,7 +46,7 @@ pub struct DefaultRouter>, L: Deref, S: Deref, impl>, L: Deref, S: Deref, SP: Sized, Sc: Score> DefaultRouter where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, Score = Sc>, { /// Creates a new router. pub fn new(network_graph: G, logger: L, random_seed_bytes: [u8; 32], scorer: S, score_params: SP) -> Self { @@ -55,16 +55,16 @@ impl>, L: Deref, S: Deref, SP: Sized, Sc: Scor } } -impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Score> Router for DefaultRouter where +impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Score> Router for DefaultRouter where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, Score = Sc>, { fn find_route( &self, payer: &PublicKey, params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, - inflight_htlcs: &InFlightHtlcs + inflight_htlcs: InFlightHtlcs ) -> Result { let random_seed_bytes = { let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap(); @@ -73,7 +73,7 @@ impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Sc }; find_route( payer, params, &self.network_graph, first_hops, &*self.logger, - &ScorerAccountingForInFlightHtlcs::new(self.scorer.lock(), inflight_htlcs), + &ScorerAccountingForInFlightHtlcs::new(self.scorer.lock().deref_mut(), &inflight_htlcs), &self.score_params, &random_seed_bytes ) @@ -82,16 +82,24 @@ impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Sc /// 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. + /// Finds a [`Route`] for a payment between the given `payer` and a payee. + /// + /// The `payee` and the payment's value are given in [`RouteParameters::payment_params`] + /// and [`RouteParameters::final_value_msat`], respectively. fn find_route( &self, payer: &PublicKey, route_params: &RouteParameters, - first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: &InFlightHtlcs + 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. + /// Finds a [`Route`] for a payment between the given `payer` and a payee. + /// + /// The `payee` and the payment's value are given in [`RouteParameters::payment_params`] + /// and [`RouteParameters::final_value_msat`], respectively. + /// + /// Includes a [`PaymentHash`] and a [`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, + first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs, _payment_hash: PaymentHash, _payment_id: PaymentId ) -> Result { self.find_route(payer, route_params, first_hops, inflight_htlcs) @@ -104,15 +112,15 @@ pub trait Router { /// [`find_route`]. /// /// [`Score`]: crate::routing::scoring::Score -pub struct ScorerAccountingForInFlightHtlcs<'a, S: Score> { - scorer: S, +pub struct ScorerAccountingForInFlightHtlcs<'a, S: Score, SP: Sized> { + scorer: &'a mut S, // Maps a channel's short channel id and its direction to the liquidity used up. inflight_htlcs: &'a InFlightHtlcs, } -impl<'a, S: Score> ScorerAccountingForInFlightHtlcs<'a, S> { +impl<'a, S: Score, SP: Sized> ScorerAccountingForInFlightHtlcs<'a, S, SP> { /// Initialize a new `ScorerAccountingForInFlightHtlcs`. - pub fn new(scorer: S, inflight_htlcs: &'a InFlightHtlcs) -> Self { + pub fn new(scorer: &'a mut S, inflight_htlcs: &'a InFlightHtlcs) -> Self { ScorerAccountingForInFlightHtlcs { scorer, inflight_htlcs @@ -121,11 +129,11 @@ impl<'a, S: Score> ScorerAccountingForInFlightHtlcs<'a, S> { } #[cfg(c_bindings)] -impl<'a, S: Score> Writeable for ScorerAccountingForInFlightHtlcs<'a, S> { +impl<'a, S: Score, SP: Sized> Writeable for ScorerAccountingForInFlightHtlcs<'a, S, SP> { fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.scorer.write(writer) } } -impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { +impl<'a, S: Score, SP: Sized> Score for ScorerAccountingForInFlightHtlcs<'a, S, SP> { type ScoreParams = S::ScoreParams; fn channel_penalty_msat(&self, short_channel_id: u64, source: &NodeId, target: &NodeId, usage: ChannelUsage, score_params: &Self::ScoreParams) -> u64 { if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat( @@ -204,6 +212,15 @@ impl InFlightHtlcs { } } + /// Adds a known HTLC given the public key of the HTLC source, target, and short channel + /// id. + pub fn add_inflight_htlc(&mut self, source: &NodeId, target: &NodeId, channel_scid: u64, used_msat: u64){ + self.0 + .entry((channel_scid, source < target)) + .and_modify(|used_liquidity_msat| *used_liquidity_msat += used_msat) + .or_insert(used_msat); + } + /// 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 { @@ -262,9 +279,9 @@ impl_writeable_tlv_based!(RouteHop, { }); /// The blinded portion of a [`Path`], if we're routing to a recipient who provided blinded paths in -/// their BOLT12 [`Invoice`]. +/// their [`Bolt12Invoice`]. /// -/// [`Invoice`]: crate::offers::invoice::Invoice +/// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice #[derive(Clone, Debug, Hash, PartialEq, Eq)] pub struct BlindedTail { /// The hops of the [`BlindedPath`] provided by the recipient. @@ -283,7 +300,7 @@ pub struct BlindedTail { } impl_writeable_tlv_based!(BlindedTail, { - (0, hops, vec_type), + (0, hops, required_vec), (2, blinding_point, required), (4, excess_final_cltv_expiry_delta, required), (6, final_value_msat, required), @@ -337,11 +354,9 @@ pub struct Route { /// [`BlindedTail`]s are present, then the pubkey of the last [`RouteHop`] in each path must be /// the same. pub paths: Vec, - /// The `payment_params` parameter passed to [`find_route`]. - /// This is used by `ChannelManager` to track information which may be required for retries, - /// provided back to you via [`Event::PaymentPathFailed`]. + /// The `payment_params` parameter passed via [`RouteParameters`] to [`find_route`]. /// - /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed + /// This is used by `ChannelManager` to track information which may be required for retries. pub payment_params: Option, } @@ -349,7 +364,7 @@ impl Route { /// Returns the total amount of fees paid on this [`Route`]. /// /// This doesn't include any extra payment made to the recipient, which can happen in excess of - /// the amount passed to [`find_route`]'s `params.final_value_msat`. + /// the amount passed to [`find_route`]'s `route_params.final_value_msat`. pub fn get_total_fees(&self) -> u64 { self.paths.iter().map(|path| path.fee_msat()).sum() } @@ -417,7 +432,7 @@ impl Readable for Route { let blinded_tails = blinded_tails.unwrap_or(Vec::new()); if blinded_tails.len() != 0 { if blinded_tails.len() != paths.len() { return Err(DecodeError::InvalidValue) } - for (mut path, blinded_tail_opt) in paths.iter_mut().zip(blinded_tails.into_iter()) { + for (path, blinded_tail_opt) in paths.iter_mut().zip(blinded_tails.into_iter()) { path.blinded_tail = blinded_tail_opt; } } @@ -427,10 +442,7 @@ impl Readable for Route { /// Parameters needed to find a [`Route`]. /// -/// Passed to [`find_route`] and [`build_route_from_hops`], but also provided in -/// [`Event::PaymentPathFailed`]. -/// -/// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed +/// Passed to [`find_route`] and [`build_route_from_hops`]. #[derive(Clone, Debug, PartialEq, Eq)] pub struct RouteParameters { /// The parameters of the failed payment path. @@ -481,6 +493,8 @@ pub const DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA: u32 = 1008; // limits, but for now more than 10 paths likely carries too much one-path failure. pub const DEFAULT_MAX_PATH_COUNT: u8 = 10; +const DEFAULT_MAX_CHANNEL_SATURATION_POW_HALF: u8 = 2; + // The median hop CLTV expiry delta currently seen in the network. const MEDIAN_HOP_CLTV_EXPIRY_DELTA: u32 = 40; @@ -548,10 +562,10 @@ impl Writeable for PaymentParameters { (1, self.max_total_cltv_expiry_delta, required), (2, self.payee.features(), option), (3, self.max_path_count, required), - (4, *clear_hints, vec_type), + (4, *clear_hints, required_vec), (5, self.max_channel_saturation_power_of_half, required), (6, self.expiry_time, option), - (7, self.previously_failed_channels, vec_type), + (7, self.previously_failed_channels, required_vec), (8, *blinded_hints, optional_vec), (9, self.payee.final_cltv_expiry_delta(), option), }); @@ -566,14 +580,13 @@ impl ReadableArgs for PaymentParameters { (1, max_total_cltv_expiry_delta, (default_value, DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA)), (2, features, (option: ReadableArgs, payee_pubkey.is_some())), (3, max_path_count, (default_value, DEFAULT_MAX_PATH_COUNT)), - (4, route_hints, vec_type), - (5, max_channel_saturation_power_of_half, (default_value, 2)), + (4, clear_route_hints, required_vec), + (5, max_channel_saturation_power_of_half, (default_value, DEFAULT_MAX_CHANNEL_SATURATION_POW_HALF)), (6, expiry_time, option), - (7, previously_failed_channels, vec_type), + (7, previously_failed_channels, optional_vec), (8, blinded_route_hints, optional_vec), (9, final_cltv_expiry_delta, (default_value, default_final_cltv_expiry_delta)), }); - let clear_route_hints = route_hints.unwrap_or(vec![]); let blinded_route_hints = blinded_route_hints.unwrap_or(vec![]); let payee = if blinded_route_hints.len() != 0 { if clear_route_hints.len() != 0 || payee_pubkey.is_some() { return Err(DecodeError::InvalidValue) } @@ -612,7 +625,7 @@ impl PaymentParameters { expiry_time: None, max_total_cltv_expiry_delta: DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, max_path_count: DEFAULT_MAX_PATH_COUNT, - max_channel_saturation_power_of_half: 2, + max_channel_saturation_power_of_half: DEFAULT_MAX_CHANNEL_SATURATION_POW_HALF, previously_failed_channels: Vec::new(), } } @@ -621,15 +634,56 @@ impl PaymentParameters { /// /// The `final_cltv_expiry_delta` should match the expected final CLTV delta the recipient has /// provided. - pub fn for_keysend(payee_pubkey: PublicKey, final_cltv_expiry_delta: u32) -> Self { - Self::from_node_id(payee_pubkey, final_cltv_expiry_delta).with_bolt11_features(InvoiceFeatures::for_keysend()).expect("PaymentParameters::from_node_id should always initialize the payee as unblinded") + /// + /// Note that MPP keysend is not widely supported yet. The `allow_mpp` lets you choose + /// whether your router will be allowed to find a multi-part route for this payment. If you + /// set `allow_mpp` to true, you should ensure a payment secret is set on send, likely via + /// [`RecipientOnionFields::secret_only`]. + /// + /// [`RecipientOnionFields::secret_only`]: crate::ln::channelmanager::RecipientOnionFields::secret_only + pub fn for_keysend(payee_pubkey: PublicKey, final_cltv_expiry_delta: u32, allow_mpp: bool) -> Self { + Self::from_node_id(payee_pubkey, final_cltv_expiry_delta) + .with_bolt11_features(Bolt11InvoiceFeatures::for_keysend(allow_mpp)) + .expect("PaymentParameters::from_node_id should always initialize the payee as unblinded") + } + + /// Creates parameters for paying to a blinded payee from the provided invoice. Sets + /// [`Payee::Blinded::route_hints`], [`Payee::Blinded::features`], and + /// [`PaymentParameters::expiry_time`]. + pub fn from_bolt12_invoice(invoice: &Bolt12Invoice) -> Self { + Self::blinded(invoice.payment_paths().to_vec()) + .with_bolt12_features(invoice.features().clone()).unwrap() + .with_expiry_time(invoice.created_at().as_secs().saturating_add(invoice.relative_expiry().as_secs())) } - /// Includes the payee's features. Errors if the parameters were initialized with blinded payment - /// paths. + fn blinded(blinded_route_hints: Vec<(BlindedPayInfo, BlindedPath)>) -> Self { + Self { + payee: Payee::Blinded { route_hints: blinded_route_hints, features: None }, + expiry_time: None, + max_total_cltv_expiry_delta: DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, + max_path_count: DEFAULT_MAX_PATH_COUNT, + max_channel_saturation_power_of_half: DEFAULT_MAX_CHANNEL_SATURATION_POW_HALF, + previously_failed_channels: Vec::new(), + } + } + + /// Includes the payee's features. Errors if the parameters were not initialized with + /// [`PaymentParameters::from_bolt12_invoice`]. /// /// This is not exported to bindings users since bindings don't support move semantics - pub fn with_bolt11_features(self, features: InvoiceFeatures) -> Result { + pub fn with_bolt12_features(self, features: Bolt12InvoiceFeatures) -> Result { + match self.payee { + Payee::Clear { .. } => Err(()), + Payee::Blinded { route_hints, .. } => + Ok(Self { payee: Payee::Blinded { route_hints, features: Some(features) }, ..self }) + } + } + + /// Includes the payee's features. Errors if the parameters were initialized with + /// [`PaymentParameters::from_bolt12_invoice`]. + /// + /// This is not exported to bindings users since bindings don't support move semantics + pub fn with_bolt11_features(self, features: Bolt11InvoiceFeatures) -> Result { match self.payee { Payee::Blinded { .. } => Err(()), Payee::Clear { route_hints, node_id, final_cltv_expiry_delta, .. } => @@ -642,7 +696,7 @@ impl PaymentParameters { } /// Includes hints for routing to the payee. Errors if the parameters were initialized with - /// blinded payment paths. + /// [`PaymentParameters::from_bolt12_invoice`]. /// /// This is not exported to bindings users since bindings don't support move semantics pub fn with_route_hints(self, route_hints: Vec) -> Result { @@ -678,7 +732,8 @@ impl PaymentParameters { Self { max_path_count, ..self } } - /// Includes a limit for the maximum number of payment paths that may be used. + /// Includes a limit for the maximum share of a channel's total capacity that can be sent over, as + /// a power of 1/2. See [`PaymentParameters::max_channel_saturation_power_of_half`]. /// /// This is not exported to bindings users since bindings don't support move semantics pub fn with_max_channel_saturation_power_of_half(self, max_channel_saturation_power_of_half: u8) -> Self { @@ -714,7 +769,7 @@ pub enum Payee { /// does not contain any features. /// /// [`for_keysend`]: PaymentParameters::for_keysend - features: Option, + features: Option, /// The minimum CLTV delta at the end of the route. This value must not be zero. final_cltv_expiry_delta: u32, }, @@ -751,14 +806,27 @@ impl Payee { _ => None, } } + fn blinded_route_hints(&self) -> &[(BlindedPayInfo, BlindedPath)] { + match self { + Self::Blinded { route_hints, .. } => &route_hints[..], + Self::Clear { .. } => &[] + } + } + + fn unblinded_route_hints(&self) -> &[RouteHint] { + match self { + Self::Blinded { .. } => &[], + Self::Clear { route_hints, .. } => &route_hints[..] + } + } } enum FeaturesRef<'a> { - Bolt11(&'a InvoiceFeatures), + Bolt11(&'a Bolt11InvoiceFeatures), Bolt12(&'a Bolt12InvoiceFeatures), } enum Features { - Bolt11(InvoiceFeatures), + Bolt11(Bolt11InvoiceFeatures), Bolt12(Bolt12InvoiceFeatures), } @@ -769,7 +837,7 @@ impl Features { _ => None, } } - fn bolt11(self) -> Option { + fn bolt11(self) -> Option { match self { Self::Bolt11(f) => Some(f), _ => None, @@ -895,18 +963,34 @@ enum CandidateRouteHop<'a> { info: DirectedChannelInfo<'a>, short_channel_id: u64, }, - /// A hop to the payee found in the payment invoice, though not necessarily a direct channel. + /// A hop to the payee found in the BOLT 11 payment invoice, though not necessarily a direct + /// channel. PrivateHop { hint: &'a RouteHintHop, - } + }, + /// The payee's identity is concealed behind blinded paths provided in a BOLT 12 invoice. + Blinded { + hint: &'a (BlindedPayInfo, BlindedPath), + hint_idx: usize, + }, + /// Similar to [`Self::Blinded`], but the path here has 1 blinded hop. `BlindedPayInfo` provided + /// for 1-hop blinded paths is ignored because it is meant to apply to the hops *between* the + /// introduction node and the destination. Useful for tracking that we need to include a blinded + /// path at the end of our [`Route`]. + OneHopBlinded { + hint: &'a (BlindedPayInfo, BlindedPath), + hint_idx: usize, + }, } impl<'a> CandidateRouteHop<'a> { - fn short_channel_id(&self) -> u64 { + fn short_channel_id(&self) -> Option { match self { - CandidateRouteHop::FirstHop { details } => details.get_outbound_payment_scid().unwrap(), - CandidateRouteHop::PublicHop { short_channel_id, .. } => *short_channel_id, - CandidateRouteHop::PrivateHop { hint } => hint.short_channel_id, + CandidateRouteHop::FirstHop { details } => Some(details.get_outbound_payment_scid().unwrap()), + CandidateRouteHop::PublicHop { short_channel_id, .. } => Some(*short_channel_id), + CandidateRouteHop::PrivateHop { hint } => Some(hint.short_channel_id), + CandidateRouteHop::Blinded { .. } => None, + CandidateRouteHop::OneHopBlinded { .. } => None, } } @@ -916,6 +1000,8 @@ impl<'a> CandidateRouteHop<'a> { CandidateRouteHop::FirstHop { details } => details.counterparty.features.to_context(), CandidateRouteHop::PublicHop { info, .. } => info.channel().features.clone(), CandidateRouteHop::PrivateHop { .. } => ChannelFeatures::empty(), + CandidateRouteHop::Blinded { .. } => ChannelFeatures::empty(), + CandidateRouteHop::OneHopBlinded { .. } => ChannelFeatures::empty(), } } @@ -924,14 +1010,18 @@ impl<'a> CandidateRouteHop<'a> { CandidateRouteHop::FirstHop { .. } => 0, CandidateRouteHop::PublicHop { info, .. } => info.direction().cltv_expiry_delta as u32, CandidateRouteHop::PrivateHop { hint } => hint.cltv_expiry_delta as u32, + CandidateRouteHop::Blinded { hint, .. } => hint.0.cltv_expiry_delta as u32, + CandidateRouteHop::OneHopBlinded { .. } => 0, } } fn htlc_minimum_msat(&self) -> u64 { match self { - CandidateRouteHop::FirstHop { .. } => 0, + CandidateRouteHop::FirstHop { details } => details.next_outbound_htlc_minimum_msat, CandidateRouteHop::PublicHop { info, .. } => info.direction().htlc_minimum_msat, CandidateRouteHop::PrivateHop { hint } => hint.htlc_minimum_msat.unwrap_or(0), + CandidateRouteHop::Blinded { hint, .. } => hint.0.htlc_minimum_msat, + CandidateRouteHop::OneHopBlinded { .. } => 0, } } @@ -942,6 +1032,14 @@ impl<'a> CandidateRouteHop<'a> { }, CandidateRouteHop::PublicHop { info, .. } => info.direction().fees, CandidateRouteHop::PrivateHop { hint } => hint.fees, + CandidateRouteHop::Blinded { hint, .. } => { + RoutingFees { + base_msat: hint.0.fee_base_msat, + proportional_millionths: hint.0.fee_proportional_millionths + } + }, + CandidateRouteHop::OneHopBlinded { .. } => + RoutingFees { base_msat: 0, proportional_millionths: 0 }, } } @@ -951,11 +1049,41 @@ impl<'a> CandidateRouteHop<'a> { liquidity_msat: details.next_outbound_htlc_limit_msat, }, CandidateRouteHop::PublicHop { info, .. } => info.effective_capacity(), - CandidateRouteHop::PrivateHop { .. } => EffectiveCapacity::Infinite, + CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: Some(max), .. }} => + EffectiveCapacity::HintMaxHTLC { amount_msat: *max }, + CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: None, .. }} => + EffectiveCapacity::Infinite, + CandidateRouteHop::Blinded { hint, .. } => + EffectiveCapacity::HintMaxHTLC { amount_msat: hint.0.htlc_maximum_msat }, + CandidateRouteHop::OneHopBlinded { .. } => EffectiveCapacity::Infinite, + } + } + + fn id(&self, channel_direction: bool /* src_node_id < target_node_id */) -> CandidateHopId { + match self { + CandidateRouteHop::Blinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx), + CandidateRouteHop::OneHopBlinded { hint_idx, .. } => CandidateHopId::Blinded(*hint_idx), + _ => CandidateHopId::Clear((self.short_channel_id().unwrap(), channel_direction)), + } + } + fn blinded_path(&self) -> Option<&'a BlindedPath> { + match self { + CandidateRouteHop::Blinded { hint, .. } | CandidateRouteHop::OneHopBlinded { hint, .. } => { + Some(&hint.1) + }, + _ => None, } } } +#[derive(Clone, Copy, Eq, Hash, Ord, PartialOrd, PartialEq)] +enum CandidateHopId { + /// Contains (scid, src_node_id < target_node_id) + Clear((u64, bool)), + /// Index of the blinded route hint in [`Payee::Blinded::route_hints`]. + Blinded(usize), +} + #[inline] fn max_htlc_from_capacity(capacity: EffectiveCapacity, max_channel_saturation_power_of_half: u8) -> u64 { let saturation_shift: u32 = max_channel_saturation_power_of_half as u32; @@ -963,8 +1091,11 @@ fn max_htlc_from_capacity(capacity: EffectiveCapacity, max_channel_saturation_po EffectiveCapacity::ExactLiquidity { liquidity_msat } => liquidity_msat, EffectiveCapacity::Infinite => u64::max_value(), EffectiveCapacity::Unknown => EffectiveCapacity::Unknown.as_msat(), - EffectiveCapacity::MaximumHTLC { amount_msat } => + EffectiveCapacity::AdvertisedMaxHTLC { amount_msat } => amount_msat.checked_shr(saturation_shift).unwrap_or(0), + // Treat htlc_maximum_msat from a route hint as an exact liquidity amount, since the invoice is + // expected to have been generated from up-to-date capacity information. + EffectiveCapacity::HintMaxHTLC { amount_msat } => amount_msat, EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat } => cmp::min(capacity_msat.checked_shr(saturation_shift).unwrap_or(0), htlc_maximum_msat), } @@ -1015,7 +1146,7 @@ struct PathBuildingHop<'a> { /// decrease as well. Thus, we have to explicitly track which nodes have been processed and /// avoid processing them again. was_processed: bool, - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] // In tests, we apply further sanity checks on cases where we skip nodes we already processed // to ensure it is specifically in cases where the fee has gone down because of a decrease in // value_contribution_msat, which requires tracking it here. See comments below where it is @@ -1036,7 +1167,7 @@ impl<'a> core::fmt::Debug for PathBuildingHop<'a> { .field("path_penalty_msat", &self.path_penalty_msat) .field("path_htlc_minimum_msat", &self.path_htlc_minimum_msat) .field("cltv_expiry_delta", &self.candidate.cltv_expiry_delta()); - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] let debug_struct = debug_struct .field("value_contribution_msat", &self.value_contribution_msat); debug_struct.finish() @@ -1101,7 +1232,7 @@ impl<'a> PaymentPath<'a> { cur_hop_fees_msat = self.hops.get(i + 1).unwrap().0.hop_use_fee_msat; } - let mut cur_hop = &mut self.hops.get_mut(i).unwrap().0; + let cur_hop = &mut self.hops.get_mut(i).unwrap().0; cur_hop.next_hops_fee_msat = total_fee_paid_msat; // Overpay in fees if we can't save these funds due to htlc_minimum_msat. // We try to account for htlc_minimum_msat in scoring (add_entry!), so that nodes don't @@ -1192,12 +1323,75 @@ impl fmt::Display for LoggedPayeePubkey { } } +struct LoggedCandidateHop<'a>(&'a CandidateRouteHop<'a>); +impl<'a> fmt::Display for LoggedCandidateHop<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.0 { + CandidateRouteHop::Blinded { hint, .. } | CandidateRouteHop::OneHopBlinded { hint, .. } => { + "blinded route hint with introduction node id ".fmt(f)?; + hint.1.introduction_node_id.fmt(f)?; + " and blinding point ".fmt(f)?; + hint.1.blinding_point.fmt(f) + }, + CandidateRouteHop::FirstHop { .. } => { + "first hop with SCID ".fmt(f)?; + self.0.short_channel_id().unwrap().fmt(f) + }, + CandidateRouteHop::PrivateHop { .. } => { + "route hint with SCID ".fmt(f)?; + self.0.short_channel_id().unwrap().fmt(f) + }, + _ => { + "SCID ".fmt(f)?; + self.0.short_channel_id().unwrap().fmt(f) + }, + } + } +} + +#[inline] +fn sort_first_hop_channels( + channels: &mut Vec<&ChannelDetails>, used_liquidities: &HashMap, + recommended_value_msat: u64, our_node_pubkey: &PublicKey +) { + // Sort the first_hops channels to the same node(s) in priority order of which channel we'd + // most like to use. + // + // First, if channels are below `recommended_value_msat`, sort them in descending order, + // preferring larger channels to avoid splitting the payment into more MPP parts than is + // required. + // + // Second, because simply always sorting in descending order would always use our largest + // available outbound capacity, needlessly fragmenting our available channel capacities, + // sort channels above `recommended_value_msat` in ascending order, preferring channels + // which have enough, but not too much, capacity for the payment. + // + // Available outbound balances factor in liquidity already reserved for previously found paths. + channels.sort_unstable_by(|chan_a, chan_b| { + let chan_a_outbound_limit_msat = chan_a.next_outbound_htlc_limit_msat + .saturating_sub(*used_liquidities.get(&CandidateHopId::Clear((chan_a.get_outbound_payment_scid().unwrap(), + our_node_pubkey < &chan_a.counterparty.node_id))).unwrap_or(&0)); + let chan_b_outbound_limit_msat = chan_b.next_outbound_htlc_limit_msat + .saturating_sub(*used_liquidities.get(&CandidateHopId::Clear((chan_b.get_outbound_payment_scid().unwrap(), + our_node_pubkey < &chan_b.counterparty.node_id))).unwrap_or(&0)); + if chan_b_outbound_limit_msat < recommended_value_msat || chan_a_outbound_limit_msat < recommended_value_msat { + // Sort in descending order + chan_b_outbound_limit_msat.cmp(&chan_a_outbound_limit_msat) + } else { + // Sort in ascending order + chan_a_outbound_limit_msat.cmp(&chan_b_outbound_limit_msat) + } + }); +} + /// Finds a route from us (payer) to the given target node (payee). /// -/// If the payee provided features in their invoice, they should be provided via `params.payee`. +/// If the payee provided features in their invoice, they should be provided via the `payee` field +/// in the given [`RouteParameters::payment_params`]. /// Without this, MPP will only be used if the payee's features are available in the network graph. /// -/// Private routing paths between a public node and the target may be included in `params.payee`. +/// Private routing paths between a public node and the target may be included in the `payee` field +/// of [`RouteParameters::payment_params`]. /// /// If some channels aren't announced, it may be useful to fill in `first_hops` with the results /// from [`ChannelManager::list_usable_channels`]. If it is filled in, the view of these channels @@ -1207,15 +1401,9 @@ impl fmt::Display for LoggedPayeePubkey { /// However, the enabled/disabled bit on such channels as well as the `htlc_minimum_msat` / /// `htlc_maximum_msat` *are* checked as they may change based on the receiving node. /// -/// # Note -/// -/// May be used to re-compute a [`Route`] when handling a [`Event::PaymentPathFailed`]. Any -/// adjustments to the [`NetworkGraph`] and channel scores should be made prior to calling this -/// function. -/// /// # Panics /// -/// Panics if first_hops contains channels without short_channel_ids; +/// Panics if first_hops contains channels without `short_channel_id`s; /// [`ChannelManager::list_usable_channels`] will never include such channels. /// /// [`ChannelManager::list_usable_channels`]: crate::ln::channelmanager::ChannelManager::list_usable_channels @@ -1245,7 +1433,7 @@ where L::Target: Logger { // unblinded payee id as an option. We also need a non-optional "payee id" for path construction, // so use a dummy id for this in the blinded case. let payee_node_id_opt = payment_params.payee.node_id().map(|pk| NodeId::from_pubkey(&pk)); - const DUMMY_BLINDED_PAYEE_ID: [u8; 33] = [42u8; 33]; + const DUMMY_BLINDED_PAYEE_ID: [u8; 33] = [2; 33]; let maybe_dummy_payee_pk = payment_params.payee.node_id().unwrap_or_else(|| PublicKey::from_slice(&DUMMY_BLINDED_PAYEE_ID).unwrap()); let maybe_dummy_payee_node_id = NodeId::from_pubkey(&maybe_dummy_payee_pk); let our_node_id = NodeId::from_pubkey(&our_node_pubkey); @@ -1272,8 +1460,23 @@ where L::Target: Logger { } } }, - _ => return Err(LightningError{err: "Routing to blinded paths isn't supported yet".to_owned(), action: ErrorAction::IgnoreError}), - + Payee::Blinded { route_hints, .. } => { + if route_hints.iter().all(|(_, path)| &path.introduction_node_id == our_node_pubkey) { + return Err(LightningError{err: "Cannot generate a route to blinded paths if we are the introduction node to all of them".to_owned(), action: ErrorAction::IgnoreError}); + } + for (_, blinded_path) in route_hints.iter() { + if blinded_path.blinded_hops.len() == 0 { + return Err(LightningError{err: "0-hop blinded path provided".to_owned(), action: ErrorAction::IgnoreError}); + } else if &blinded_path.introduction_node_id == our_node_pubkey { + log_info!(logger, "Got blinded path with ourselves as the introduction node, ignoring"); + } else if blinded_path.blinded_hops.len() == 1 && + route_hints.iter().any( |(_, p)| p.blinded_hops.len() == 1 + && p.introduction_node_id != blinded_path.introduction_node_id) + { + return Err(LightningError{err: format!("1-hop blinded paths must all have matching introduction node ids"), action: ErrorAction::IgnoreError}); + } + } + } } let final_cltv_expiry_delta = payment_params.payee.final_cltv_expiry_delta().unwrap_or(0); if payment_params.max_total_cltv_expiry_delta <= final_cltv_expiry_delta { @@ -1425,11 +1628,12 @@ where L::Target: Logger { // drop the requirement by setting this to 0. let mut channel_saturation_pow_half = payment_params.max_channel_saturation_power_of_half; - // Keep track of how much liquidity has been used in selected channels. Used to determine - // if the channel can be used by additional MPP paths or to inform path finding decisions. It is - // aware of direction *only* to ensure that the correct htlc_maximum_msat value is used. Hence, - // liquidity used in one direction will not offset any used in the opposite direction. - let mut used_channel_liquidities: HashMap<(u64, bool), u64> = + // Keep track of how much liquidity has been used in selected channels or blinded paths. Used to + // determine if the channel can be used by additional MPP paths or to inform path finding + // decisions. It is aware of direction *only* to ensure that the correct htlc_maximum_msat value + // is used. Hence, liquidity used in one direction will not offset any used in the opposite + // direction. + let mut used_liquidities: HashMap = HashMap::with_capacity(network_nodes.len()); // Keeping track of how much value we already collected across other paths. Helps to decide @@ -1437,31 +1641,19 @@ where L::Target: Logger { let mut already_collected_value_msat = 0; for (_, channels) in first_hop_targets.iter_mut() { - // Sort the first_hops channels to the same node(s) in priority order of which channel we'd - // most like to use. - // - // First, if channels are below `recommended_value_msat`, sort them in descending order, - // preferring larger channels to avoid splitting the payment into more MPP parts than is - // required. - // - // Second, because simply always sorting in descending order would always use our largest - // available outbound capacity, needlessly fragmenting our available channel capacities, - // sort channels above `recommended_value_msat` in ascending order, preferring channels - // which have enough, but not too much, capacity for the payment. - channels.sort_unstable_by(|chan_a, chan_b| { - if chan_b.next_outbound_htlc_limit_msat < recommended_value_msat || chan_a.next_outbound_htlc_limit_msat < recommended_value_msat { - // Sort in descending order - chan_b.next_outbound_htlc_limit_msat.cmp(&chan_a.next_outbound_htlc_limit_msat) - } else { - // Sort in ascending order - chan_a.next_outbound_htlc_limit_msat.cmp(&chan_b.next_outbound_htlc_limit_msat) - } - }); + sort_first_hop_channels(channels, &used_liquidities, recommended_value_msat, + our_node_pubkey); } log_trace!(logger, "Building path from {} to payer {} for value {} msat.", LoggedPayeePubkey(payment_params.payee.node_id()), our_node_pubkey, final_value_msat); + // Remember how many candidates we ignored to allow for some logging afterwards. + let mut num_ignored_value_contribution = 0; + let mut num_ignored_path_length_limit = 0; + let mut num_ignored_cltv_delta_limit = 0; + let mut num_ignored_previously_failed = 0; + macro_rules! add_entry { // Adds entry which goes from $src_node_id to $dest_node_id over the $candidate hop. // $next_hops_fee_msat represents the fees paid for using all the channels *after* this one, @@ -1470,14 +1662,15 @@ where L::Target: Logger { ( $candidate: expr, $src_node_id: expr, $dest_node_id: expr, $next_hops_fee_msat: expr, $next_hops_value_contribution: expr, $next_hops_path_htlc_minimum_msat: expr, $next_hops_path_penalty_msat: expr, $next_hops_cltv_delta: expr, $next_hops_path_length: expr ) => { { - // We "return" whether we updated the path at the end, via this: - let mut did_add_update_path_to_src_node = false; + // We "return" whether we updated the path at the end, and how much we can route via + // this channel, via this: + let mut did_add_update_path_to_src_node = None; // Channels to self should not be used. This is more of belt-and-suspenders, because in // practice these cases should be caught earlier: // - for regular channels at channel announcement (TODO) // - for first and last hops early in get_route if $src_node_id != $dest_node_id { - let short_channel_id = $candidate.short_channel_id(); + let scid_opt = $candidate.short_channel_id(); let effective_capacity = $candidate.effective_capacity(); let htlc_maximum_msat = max_htlc_from_capacity(effective_capacity, channel_saturation_pow_half); @@ -1489,8 +1682,8 @@ where L::Target: Logger { // if the amount being transferred over this path is lower. // We do this for now, but this is a subject for removal. if let Some(mut available_value_contribution_msat) = htlc_maximum_msat.checked_sub($next_hops_fee_msat) { - let used_liquidity_msat = used_channel_liquidities - .get(&(short_channel_id, $src_node_id < $dest_node_id)) + let used_liquidity_msat = used_liquidities + .get(&$candidate.id($src_node_id < $dest_node_id)) .map_or(0, |used_liquidity_msat| { available_value_contribution_msat = available_value_contribution_msat .saturating_sub(*used_liquidity_msat); @@ -1532,16 +1725,40 @@ where L::Target: Logger { (amount_to_transfer_over_msat < $next_hops_path_htlc_minimum_msat && recommended_value_msat > $next_hops_path_htlc_minimum_msat)); - let payment_failed_on_this_channel = - payment_params.previously_failed_channels.contains(&short_channel_id); + let payment_failed_on_this_channel = scid_opt.map_or(false, + |scid| payment_params.previously_failed_channels.contains(&scid)); + + let should_log_candidate = match $candidate { + CandidateRouteHop::FirstHop { .. } => true, + CandidateRouteHop::PrivateHop { .. } => true, + CandidateRouteHop::Blinded { .. } => true, + _ => false, + }; // If HTLC minimum is larger than the amount we're going to transfer, we shouldn't // bother considering this channel. If retrying with recommended_value_msat may // allow us to hit the HTLC minimum limit, set htlc_minimum_limit so that we go // around again with a higher amount. - if !contributes_sufficient_value || exceeds_max_path_length || - exceeds_cltv_delta_limit || payment_failed_on_this_channel { - // Path isn't useful, ignore it and move on. + if !contributes_sufficient_value { + if should_log_candidate { + log_trace!(logger, "Ignoring {} due to insufficient value contribution.", LoggedCandidateHop(&$candidate)); + } + num_ignored_value_contribution += 1; + } else if exceeds_max_path_length { + if should_log_candidate { + log_trace!(logger, "Ignoring {} due to exceeding maximum path length limit.", LoggedCandidateHop(&$candidate)); + } + num_ignored_path_length_limit += 1; + } else if exceeds_cltv_delta_limit { + if should_log_candidate { + log_trace!(logger, "Ignoring {} due to exceeding CLTV delta limit.", LoggedCandidateHop(&$candidate)); + } + num_ignored_cltv_delta_limit += 1; + } else if payment_failed_on_this_channel { + if should_log_candidate { + log_trace!(logger, "Ignoring {} due to a failed previous payment attempt.", LoggedCandidateHop(&$candidate)); + } + num_ignored_previously_failed += 1; } else if may_overpay_to_meet_path_minimum_msat { hit_minimum_limit = true; } else if over_path_minimum_msat { @@ -1570,14 +1787,14 @@ where L::Target: Logger { path_htlc_minimum_msat, path_penalty_msat: u64::max_value(), was_processed: false, - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] value_contribution_msat, } }); #[allow(unused_mut)] // We only use the mut in cfg(test) let mut should_process = !old_entry.was_processed; - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] { // In test/fuzzing builds, we do extra checks to make sure the skipping // of already-seen nodes only happens in cases we expect (see below). @@ -1602,9 +1819,9 @@ where L::Target: Logger { inflight_htlc_msat: used_liquidity_msat, effective_capacity, }; - let channel_penalty_msat = scorer.channel_penalty_msat( - short_channel_id, &$src_node_id, &$dest_node_id, channel_usage, score_params - ); + let channel_penalty_msat = scid_opt.map_or(0, + |scid| scorer.channel_penalty_msat(scid, &$src_node_id, &$dest_node_id, + channel_usage, score_params)); let path_penalty_msat = $next_hops_path_penalty_msat .saturating_add(channel_penalty_msat); let new_graph_node = RouteGraphNode { @@ -1648,13 +1865,13 @@ where L::Target: Logger { old_entry.fee_msat = 0; // This value will be later filled with hop_use_fee_msat of the following channel old_entry.path_htlc_minimum_msat = path_htlc_minimum_msat; old_entry.path_penalty_msat = path_penalty_msat; - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] { old_entry.value_contribution_msat = value_contribution_msat; } - did_add_update_path_to_src_node = true; + did_add_update_path_to_src_node = Some(value_contribution_msat); } else if old_entry.was_processed && new_cost < old_cost { - #[cfg(all(not(feature = "_bench_unstable"), any(test, fuzzing)))] + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] { // If we're skipping processing a node which was previously // processed even though we found another path to it with a @@ -1761,7 +1978,7 @@ where L::Target: Logger { // TODO: diversify by nodes (so that all paths aren't doomed if one node is offline). 'paths_collection: loop { - // For every new path, start from scratch, except for used_channel_liquidities, which + // For every new path, start from scratch, except for used_liquidities, which // helps to avoid reusing previously selected paths in future iterations. targets.clear(); dist.clear(); @@ -1773,9 +1990,9 @@ where L::Target: Logger { for details in first_channels { let candidate = CandidateRouteHop::FirstHop { details }; let added = add_entry!(candidate, our_node_id, payee, 0, path_value_msat, - 0, 0u64, 0, 0); - log_trace!(logger, "{} direct route to payee via SCID {}", - if added { "Added" } else { "Skipped" }, candidate.short_channel_id()); + 0, 0u64, 0, 0).is_some(); + log_trace!(logger, "{} direct route to payee via {}", + if added { "Added" } else { "Skipped" }, LoggedCandidateHop(&candidate)); } })); @@ -1796,11 +2013,37 @@ where L::Target: Logger { // If a caller provided us with last hops, add them to routing targets. Since this happens // earlier than general path finding, they will be somewhat prioritized, although currently // it matters only if the fees are exactly the same. - let route_hints = match &payment_params.payee { - Payee::Clear { route_hints, .. } => route_hints, - _ => return Err(LightningError{err: "Routing to blinded paths isn't supported yet".to_owned(), action: ErrorAction::IgnoreError}), - }; - for route in route_hints.iter().filter(|route| !route.0.is_empty()) { + for (hint_idx, hint) in payment_params.payee.blinded_route_hints().iter().enumerate() { + let intro_node_id = NodeId::from_pubkey(&hint.1.introduction_node_id); + let have_intro_node_in_graph = + // Only add the hops in this route to our candidate set if either + // we have a direct channel to the first hop or the first hop is + // in the regular network graph. + first_hop_targets.get(&intro_node_id).is_some() || + network_nodes.get(&intro_node_id).is_some(); + if !have_intro_node_in_graph { continue } + let candidate = if hint.1.blinded_hops.len() == 1 { + CandidateRouteHop::OneHopBlinded { hint, hint_idx } + } else { CandidateRouteHop::Blinded { hint, hint_idx } }; + let mut path_contribution_msat = path_value_msat; + if let Some(hop_used_msat) = add_entry!(candidate, intro_node_id, maybe_dummy_payee_node_id, + 0, path_contribution_msat, 0, 0_u64, 0, 0) + { + path_contribution_msat = hop_used_msat; + } else { continue } + if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hint.1.introduction_node_id)) { + sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, + our_node_pubkey); + for details in first_channels { + let first_hop_candidate = CandidateRouteHop::FirstHop { details }; + add_entry!(first_hop_candidate, our_node_id, intro_node_id, 0, path_contribution_msat, 0, + 0_u64, 0, 0); + } + } + } + for route in payment_params.payee.unblinded_route_hints().iter() + .filter(|route| !route.0.is_empty()) + { let first_hop_in_route = &(route.0)[0]; let have_hop_src_in_graph = // Only add the hops in this route to our candidate set if either @@ -1820,6 +2063,7 @@ where L::Target: Logger { let mut aggregate_next_hops_path_penalty_msat: u64 = 0; let mut aggregate_next_hops_cltv_delta: u32 = 0; let mut aggregate_next_hops_path_length: u8 = 0; + let mut aggregate_path_contribution_msat = path_value_msat; for (idx, (hop, prev_hop_id)) in hop_iter.zip(prev_hop_iter).enumerate() { let source = NodeId::from_pubkey(&hop.src_node_id); @@ -1833,18 +2077,22 @@ where L::Target: Logger { }) .unwrap_or_else(|| CandidateRouteHop::PrivateHop { hint: hop }); - if !add_entry!(candidate, source, target, aggregate_next_hops_fee_msat, - path_value_msat, aggregate_next_hops_path_htlc_minimum_msat, - aggregate_next_hops_path_penalty_msat, - aggregate_next_hops_cltv_delta, aggregate_next_hops_path_length) { + if let Some(hop_used_msat) = add_entry!(candidate, source, target, + aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, + aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat, + aggregate_next_hops_cltv_delta, aggregate_next_hops_path_length) + { + aggregate_path_contribution_msat = hop_used_msat; + } else { // If this hop was not used then there is no use checking the preceding // hops in the RouteHint. We can break by just searching for a direct // channel between last checked hop and first_hop_targets. hop_used = false; } - let used_liquidity_msat = used_channel_liquidities - .get(&(hop.short_channel_id, source < target)).copied().unwrap_or(0); + let used_liquidity_msat = used_liquidities + .get(&candidate.id(source < target)).copied() + .unwrap_or(0); let channel_usage = ChannelUsage { amount_msat: final_value_msat + aggregate_next_hops_fee_msat, inflight_htlc_msat: used_liquidity_msat, @@ -1863,14 +2111,15 @@ where L::Target: Logger { .saturating_add(1); // Searching for a direct channel between last checked hop and first_hop_targets - if let Some(first_channels) = first_hop_targets.get(&NodeId::from_pubkey(&prev_hop_id)) { + if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&prev_hop_id)) { + sort_first_hop_channels(first_channels, &used_liquidities, + recommended_value_msat, our_node_pubkey); for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { details }; - add_entry!(candidate, our_node_id, NodeId::from_pubkey(&prev_hop_id), - aggregate_next_hops_fee_msat, path_value_msat, - aggregate_next_hops_path_htlc_minimum_msat, - aggregate_next_hops_path_penalty_msat, aggregate_next_hops_cltv_delta, - aggregate_next_hops_path_length); + let first_hop_candidate = CandidateRouteHop::FirstHop { details }; + add_entry!(first_hop_candidate, our_node_id, NodeId::from_pubkey(&prev_hop_id), + aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, + aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat, + aggregate_next_hops_cltv_delta, aggregate_next_hops_path_length); } } @@ -1903,12 +2152,15 @@ where L::Target: Logger { // Note that we *must* check if the last hop was added as `add_entry` // always assumes that the third argument is a node to which we have a // path. - if let Some(first_channels) = first_hop_targets.get(&NodeId::from_pubkey(&hop.src_node_id)) { + if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hop.src_node_id)) { + sort_first_hop_channels(first_channels, &used_liquidities, + recommended_value_msat, our_node_pubkey); for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { details }; - add_entry!(candidate, our_node_id, + let first_hop_candidate = CandidateRouteHop::FirstHop { details }; + add_entry!(first_hop_candidate, our_node_id, NodeId::from_pubkey(&hop.src_node_id), - aggregate_next_hops_fee_msat, path_value_msat, + aggregate_next_hops_fee_msat, + aggregate_path_contribution_msat, aggregate_next_hops_path_htlc_minimum_msat, aggregate_next_hops_path_penalty_msat, aggregate_next_hops_cltv_delta, @@ -1947,10 +2199,12 @@ where L::Target: Logger { let mut features_set = false; if let Some(first_channels) = first_hop_targets.get(&ordered_hops.last().unwrap().0.node_id) { for details in first_channels { - if details.get_outbound_payment_scid().unwrap() == ordered_hops.last().unwrap().0.candidate.short_channel_id() { - ordered_hops.last_mut().unwrap().1 = details.counterparty.features.to_context(); - features_set = true; - break; + if let Some(scid) = ordered_hops.last().unwrap().0.candidate.short_channel_id() { + if details.get_outbound_payment_scid().unwrap() == scid { + ordered_hops.last_mut().unwrap().1 = details.counterparty.features.to_context(); + features_set = true; + break; + } } } } @@ -2019,8 +2273,8 @@ where L::Target: Logger { .chain(payment_path.hops.iter().map(|(hop, _)| &hop.node_id)); for (prev_hop, (hop, _)) in prev_hop_iter.zip(payment_path.hops.iter()) { let spent_on_hop_msat = value_contribution_msat + hop.next_hops_fee_msat; - let used_liquidity_msat = used_channel_liquidities - .entry((hop.candidate.short_channel_id(), *prev_hop < hop.node_id)) + let used_liquidity_msat = used_liquidities + .entry(hop.candidate.id(*prev_hop < hop.node_id)) .and_modify(|used_liquidity_msat| *used_liquidity_msat += spent_on_hop_msat) .or_insert(spent_on_hop_msat); let hop_capacity = hop.candidate.effective_capacity(); @@ -2036,11 +2290,12 @@ where L::Target: Logger { // If we weren't capped by hitting a liquidity limit on a channel in the path, // we'll probably end up picking the same path again on the next iteration. // Decrease the available liquidity of a hop in the middle of the path. - let victim_scid = payment_path.hops[(payment_path.hops.len()) / 2].0.candidate.short_channel_id(); + let victim_candidate = &payment_path.hops[(payment_path.hops.len()) / 2].0.candidate; let exhausted = u64::max_value(); - log_trace!(logger, "Disabling channel {} for future path building iterations to avoid duplicates.", victim_scid); - *used_channel_liquidities.entry((victim_scid, false)).or_default() = exhausted; - *used_channel_liquidities.entry((victim_scid, true)).or_default() = exhausted; + log_trace!(logger, "Disabling route candidate {} for future path building iterations to + avoid duplicates.", LoggedCandidateHop(victim_candidate)); + *used_liquidities.entry(victim_candidate.id(false)).or_default() = exhausted; + *used_liquidities.entry(victim_candidate.id(true)).or_default() = exhausted; } // Track the total amount all our collected paths allow to send so that we know @@ -2105,6 +2360,12 @@ where L::Target: Logger { } } + let num_ignored_total = num_ignored_value_contribution + num_ignored_path_length_limit + + num_ignored_cltv_delta_limit + num_ignored_previously_failed; + if num_ignored_total > 0 { + log_trace!(logger, "Ignored {} candidate hops due to insufficient value contribution, {} due to path length limit, {} due to CLTV delta limit, {} due to previous payment failure. Total: {} ignored candidates.", num_ignored_value_contribution, num_ignored_path_length_limit, num_ignored_cltv_delta_limit, num_ignored_previously_failed, num_ignored_total); + } + // Step (5). if payment_paths.len() == 0 { return Err(LightningError{err: "Failed to find a path to the given destination".to_owned(), action: ErrorAction::IgnoreError}); @@ -2168,63 +2429,68 @@ where L::Target: Logger { // compare both SCIDs and NodeIds as individual nodes may use random aliases causing collisions // across nodes. selected_route.sort_unstable_by_key(|path| { - let mut key = [0u64; MAX_PATH_LENGTH_ESTIMATE as usize]; + let mut key = [CandidateHopId::Clear((42, true)) ; MAX_PATH_LENGTH_ESTIMATE as usize]; debug_assert!(path.hops.len() <= key.len()); - for (scid, key) in path.hops.iter().map(|h| h.0.candidate.short_channel_id()).zip(key.iter_mut()) { + for (scid, key) in path.hops.iter() .map(|h| h.0.candidate.id(true)).zip(key.iter_mut()) { *key = scid; } key }); for idx in 0..(selected_route.len() - 1) { if idx + 1 >= selected_route.len() { break; } - if iter_equal(selected_route[idx ].hops.iter().map(|h| (h.0.candidate.short_channel_id(), h.0.node_id)), - selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.short_channel_id(), h.0.node_id))) { + if iter_equal(selected_route[idx ].hops.iter().map(|h| (h.0.candidate.id(true), h.0.node_id)), + selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.id(true), h.0.node_id))) { let new_value = selected_route[idx].get_value_msat() + selected_route[idx + 1].get_value_msat(); selected_route[idx].update_value_and_recompute_fees(new_value); selected_route.remove(idx + 1); } } - let mut selected_paths = Vec::>>::new(); + let mut paths = Vec::new(); for payment_path in selected_route { - let mut path = payment_path.hops.iter().map(|(payment_hop, node_features)| { - Ok(RouteHop { - pubkey: PublicKey::from_slice(payment_hop.node_id.as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &payment_hop.node_id), action: ErrorAction::IgnoreAndLog(Level::Trace)})?, + let mut hops = Vec::with_capacity(payment_path.hops.len()); + for (hop, node_features) in payment_path.hops.iter() + .filter(|(h, _)| h.candidate.short_channel_id().is_some()) + { + hops.push(RouteHop { + pubkey: PublicKey::from_slice(hop.node_id.as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &hop.node_id), action: ErrorAction::IgnoreAndLog(Level::Trace)})?, node_features: node_features.clone(), - short_channel_id: payment_hop.candidate.short_channel_id(), - channel_features: payment_hop.candidate.features(), - fee_msat: payment_hop.fee_msat, - cltv_expiry_delta: payment_hop.candidate.cltv_expiry_delta(), - }) - }).collect::>(); + short_channel_id: hop.candidate.short_channel_id().unwrap(), + channel_features: hop.candidate.features(), + fee_msat: hop.fee_msat, + cltv_expiry_delta: hop.candidate.cltv_expiry_delta(), + }); + } + let mut final_cltv_delta = final_cltv_expiry_delta; + let blinded_tail = payment_path.hops.last().and_then(|(h, _)| { + if let Some(blinded_path) = h.candidate.blinded_path() { + final_cltv_delta = h.candidate.cltv_expiry_delta(); + Some(BlindedTail { + hops: blinded_path.blinded_hops.clone(), + blinding_point: blinded_path.blinding_point, + excess_final_cltv_expiry_delta: 0, + final_value_msat: h.fee_msat, + }) + } else { None } + }); // Propagate the cltv_expiry_delta one hop backwards since the delta from the current hop is // applicable for the previous hop. - path.iter_mut().rev().fold(final_cltv_expiry_delta, |prev_cltv_expiry_delta, hop| { - core::mem::replace(&mut hop.as_mut().unwrap().cltv_expiry_delta, prev_cltv_expiry_delta) + hops.iter_mut().rev().fold(final_cltv_delta, |prev_cltv_expiry_delta, hop| { + core::mem::replace(&mut hop.cltv_expiry_delta, prev_cltv_expiry_delta) }); - selected_paths.push(path); + + paths.push(Path { hops, blinded_tail }); } // Make sure we would never create a route with more paths than we allow. - debug_assert!(selected_paths.len() <= payment_params.max_path_count.into()); + debug_assert!(paths.len() <= payment_params.max_path_count.into()); if let Some(node_features) = payment_params.payee.node_features() { - for path in selected_paths.iter_mut() { - if let Ok(route_hop) = path.last_mut().unwrap() { - route_hop.node_features = node_features.clone(); - } + for path in paths.iter_mut() { + path.hops.last_mut().unwrap().node_features = node_features.clone(); } } - let mut paths: Vec = Vec::new(); - for results_vec in selected_paths { - let mut hops = Vec::with_capacity(results_vec.len()); - for res in results_vec { hops.push(res?); } - paths.push(Path { hops, blinded_tail: None }); - } - let route = Route { - paths, - payment_params: Some(payment_params.clone()), - }; + let route = Route { paths, payment_params: Some(payment_params.clone()) }; log_info!(logger, "Got route: {}", log_route!(route)); Ok(route) } @@ -2410,9 +2676,10 @@ mod tests { use crate::routing::test_utils::{add_channel, add_or_update_node, build_graph, build_line_graph, id_to_feature_flags, get_nodes, update_channel}; use crate::chain::transaction::OutPoint; use crate::sign::EntropySource; - use crate::ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; + use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, ChannelFeatures, InitFeatures, NodeFeatures}; use crate::ln::msgs::{ErrorAction, LightningError, UnsignedChannelUpdate, MAX_VALUE_MSAT}; use crate::ln::channelmanager; + use crate::offers::invoice::BlindedPayInfo; use crate::util::config::UserConfig; use crate::util::test_utils as ln_test_utils; use crate::util::chacha20::ChaCha20; @@ -2460,6 +2727,7 @@ mod tests { balance_msat: 0, outbound_capacity_msat, next_outbound_htlc_limit_msat: outbound_capacity_msat, + next_outbound_htlc_minimum_msat: 0, inbound_capacity_msat: 42, unspendable_punishment_reserve: None, confirmations_required: None, @@ -2470,7 +2738,8 @@ mod tests { inbound_htlc_minimum_msat: None, inbound_htlc_maximum_msat: None, config: None, - feerate_sat_per_1000_weight: None + feerate_sat_per_1000_weight: None, + channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown), } } @@ -3628,7 +3897,7 @@ mod tests { fn available_amount_while_routing_test() { // Tests whether we choose the correct available channel amount while routing. - let (secp_ctx, network_graph, mut gossip_sync, chain_monitor, logger) = build_graph(); + let (secp_ctx, network_graph, gossip_sync, chain_monitor, logger) = build_graph(); let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx); let scorer = ln_test_utils::TestScorer::new(); let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); @@ -4078,14 +4347,66 @@ mod tests { #[test] fn simple_mpp_route_test() { + let (secp_ctx, _, _, _, _) = build_graph(); + let (_, _, _, nodes) = get_nodes(&secp_ctx); + let config = UserConfig::default(); + let clear_payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + do_simple_mpp_route_test(clear_payment_params); + + // MPP to a 1-hop blinded path for nodes[2] + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let blinded_path = BlindedPath { + introduction_node_id: nodes[2], + blinding_point: ln_test_utils::pubkey(42), + blinded_hops: vec![BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 as u8), encrypted_payload: Vec::new() }], + }; + let blinded_payinfo = BlindedPayInfo { // These fields are ignored for 1-hop blinded paths + fee_base_msat: 0, + fee_proportional_millionths: 0, + htlc_minimum_msat: 0, + htlc_maximum_msat: 0, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let one_hop_blinded_payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), blinded_path.clone())]) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + do_simple_mpp_route_test(one_hop_blinded_payment_params.clone()); + + // MPP to 3 2-hop blinded paths + let mut blinded_path_node_0 = blinded_path.clone(); + blinded_path_node_0.introduction_node_id = nodes[0]; + blinded_path_node_0.blinded_hops.push(blinded_path.blinded_hops[0].clone()); + let mut node_0_payinfo = blinded_payinfo.clone(); + node_0_payinfo.htlc_maximum_msat = 50_000; + + let mut blinded_path_node_7 = blinded_path_node_0.clone(); + blinded_path_node_7.introduction_node_id = nodes[7]; + let mut node_7_payinfo = blinded_payinfo.clone(); + node_7_payinfo.htlc_maximum_msat = 60_000; + + let mut blinded_path_node_1 = blinded_path_node_0.clone(); + blinded_path_node_1.introduction_node_id = nodes[1]; + let mut node_1_payinfo = blinded_payinfo.clone(); + node_1_payinfo.htlc_maximum_msat = 180_000; + + let two_hop_blinded_payment_params = PaymentParameters::blinded( + vec![ + (node_0_payinfo, blinded_path_node_0), + (node_7_payinfo, blinded_path_node_7), + (node_1_payinfo, blinded_path_node_1) + ]) + .with_bolt12_features(bolt12_features).unwrap(); + do_simple_mpp_route_test(two_hop_blinded_payment_params); + } + + + fn do_simple_mpp_route_test(payment_params: PaymentParameters) { let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph(); let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx); let scorer = ln_test_utils::TestScorer::new(); let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let config = UserConfig::default(); - let payment_params = PaymentParameters::from_node_id(nodes[2], 42) - .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); // We need a route consisting of 3 paths: // From our node to node2 via node0, node7, node1 (three paths one hop each). @@ -4214,8 +4535,12 @@ mod tests { assert_eq!(route.paths.len(), 3); let mut total_amount_paid_msat = 0; for path in &route.paths { - assert_eq!(path.hops.len(), 2); - assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + if let Some(bt) = &path.blinded_tail { + assert_eq!(path.hops.len() + if bt.hops.len() == 1 { 0 } else { 1 }, 2); + } else { + assert_eq!(path.hops.len(), 2); + assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + } total_amount_paid_msat += path.final_value_msat(); } assert_eq!(total_amount_paid_msat, 250_000); @@ -4228,8 +4553,22 @@ mod tests { assert_eq!(route.paths.len(), 3); let mut total_amount_paid_msat = 0; for path in &route.paths { - assert_eq!(path.hops.len(), 2); - assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + if payment_params.payee.blinded_route_hints().len() != 0 { + assert!(path.blinded_tail.is_some()) } else { assert!(path.blinded_tail.is_none()) } + if let Some(bt) = &path.blinded_tail { + assert_eq!(path.hops.len() + if bt.hops.len() == 1 { 0 } else { 1 }, 2); + if bt.hops.len() > 1 { + assert_eq!(path.hops.last().unwrap().pubkey, + payment_params.payee.blinded_route_hints().iter() + .find(|(p, _)| p.htlc_maximum_msat == path.final_value_msat()) + .map(|(_, p)| p.introduction_node_id).unwrap()); + } else { + assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + } + } else { + assert_eq!(path.hops.len(), 2); + assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + } total_amount_paid_msat += path.final_value_msat(); } assert_eq!(total_amount_paid_msat, 290_000); @@ -5791,44 +6130,26 @@ mod tests { println!("Using seed of {}", seed); seed } - #[cfg(not(feature = "no-std"))] - use crate::util::ser::ReadableArgs; #[test] #[cfg(not(feature = "no-std"))] fn generate_routes() { use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; - let mut d = match super::bench_utils::get_route_file() { + let logger = ln_test_utils::TestLogger::new(); + let graph = match super::bench_utils::read_network_graph(&logger) { Ok(f) => f, Err(e) => { eprintln!("{}", e); return; }, }; - let logger = ln_test_utils::TestLogger::new(); - let graph = NetworkGraph::read(&mut d, &logger).unwrap(); - let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); - let random_seed_bytes = keys_manager.get_secure_random_bytes(); - // First, get 100 (source, destination) pairs for which route-getting actually succeeds... - let mut seed = random_init_seed() as usize; - let nodes = graph.read_only().nodes().clone(); - 'load_endpoints: for _ in 0..10 { - loop { - seed = seed.overflowing_mul(0xdeadbeef).0; - let src = &PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - seed = seed.overflowing_mul(0xdeadbeef).0; - let dst = PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - let payment_params = PaymentParameters::from_node_id(dst, 42); - let amt = seed as u64 % 200_000_000; - let params = ProbabilisticScoringFeeParameters::default(); - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); - if get_route(src, &payment_params, &graph.read_only(), None, amt, &logger, &scorer, ¶ms, &random_seed_bytes).is_ok() { - continue 'load_endpoints; - } - } - } + let params = ProbabilisticScoringFeeParameters::default(); + let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); + let features = super::Bolt11InvoiceFeatures::empty(); + + super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); } #[test] @@ -5836,37 +6157,41 @@ mod tests { fn generate_routes_mpp() { use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; - let mut d = match super::bench_utils::get_route_file() { + let logger = ln_test_utils::TestLogger::new(); + let graph = match super::bench_utils::read_network_graph(&logger) { Ok(f) => f, Err(e) => { eprintln!("{}", e); return; }, }; + + let params = ProbabilisticScoringFeeParameters::default(); + let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); + let features = channelmanager::provided_invoice_features(&UserConfig::default()); + + super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); + } + + #[test] + #[cfg(not(feature = "no-std"))] + fn generate_large_mpp_routes() { + use crate::routing::scoring::{ProbabilisticScorer, ProbabilisticScoringFeeParameters}; + let logger = ln_test_utils::TestLogger::new(); - let graph = NetworkGraph::read(&mut d, &logger).unwrap(); - let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); - let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let config = UserConfig::default(); + let graph = match super::bench_utils::read_network_graph(&logger) { + Ok(f) => f, + Err(e) => { + eprintln!("{}", e); + return; + }, + }; - // First, get 100 (source, destination) pairs for which route-getting actually succeeds... - let mut seed = random_init_seed() as usize; - let nodes = graph.read_only().nodes().clone(); - 'load_endpoints: for _ in 0..10 { - loop { - seed = seed.overflowing_mul(0xdeadbeef).0; - let src = &PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - seed = seed.overflowing_mul(0xdeadbeef).0; - let dst = PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - let payment_params = PaymentParameters::from_node_id(dst, 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); - let amt = seed as u64 % 200_000_000; - let params = ProbabilisticScoringFeeParameters::default(); - let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); - if get_route(src, &payment_params, &graph.read_only(), None, amt, &logger, &scorer, ¶ms, &random_seed_bytes).is_ok() { - continue 'load_endpoints; - } - } - } + let params = ProbabilisticScoringFeeParameters::default(); + let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); + let features = channelmanager::provided_invoice_features(&UserConfig::default()); + + super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 1_000_000, 2); } #[test] @@ -5906,6 +6231,157 @@ mod tests { assert!(route.is_ok()); } + #[test] + fn abide_by_route_hint_max_htlc() { + // Check that we abide by any htlc_maximum_msat provided in the route hints of the payment + // params in the final route. + let (secp_ctx, network_graph, _, _, logger) = build_graph(); + let netgraph = network_graph.read_only(); + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let scorer = ln_test_utils::TestScorer::new(); + let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + let config = UserConfig::default(); + + let max_htlc_msat = 50_000; + let route_hint_1 = RouteHint(vec![RouteHintHop { + src_node_id: nodes[2], + short_channel_id: 42, + fees: RoutingFees { + base_msat: 100, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + htlc_maximum_msat: Some(max_htlc_msat), + }]); + let dest_node_id = ln_test_utils::pubkey(42); + let payment_params = PaymentParameters::from_node_id(dest_node_id, 42) + .with_route_hints(vec![route_hint_1.clone()]).unwrap() + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + + // Make sure we'll error if our route hints don't have enough liquidity according to their + // htlc_maximum_msat. + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &payment_params, &netgraph, None, max_htlc_msat + 1, Arc::clone(&logger), &scorer, &(), + &random_seed_bytes) + { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); + } else { panic!(); } + + // Make sure we'll split an MPP payment across route hints if their htlc_maximum_msat warrants. + let mut route_hint_2 = route_hint_1.clone(); + route_hint_2.0[0].short_channel_id = 43; + let payment_params = PaymentParameters::from_node_id(dest_node_id, 42) + .with_route_hints(vec![route_hint_1, route_hint_2]).unwrap() + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let route = get_route(&our_id, &payment_params, &netgraph, None, max_htlc_msat + 1, + Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 2); + assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat); + } + + #[test] + fn direct_channel_to_hints_with_max_htlc() { + // Check that if we have a first hop channel peer that's connected to multiple provided route + // hints, that we properly split the payment between the route hints if needed. + let logger = Arc::new(ln_test_utils::TestLogger::new()); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger))); + let scorer = ln_test_utils::TestScorer::new(); + let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + let config = UserConfig::default(); + + let our_node_id = ln_test_utils::pubkey(42); + let intermed_node_id = ln_test_utils::pubkey(43); + let first_hop = vec![get_channel_details(Some(42), intermed_node_id, InitFeatures::from_le_bytes(vec![0b11]), 10_000_000)]; + + let amt_msat = 900_000; + let max_htlc_msat = 500_000; + let route_hint_1 = RouteHint(vec![RouteHintHop { + src_node_id: intermed_node_id, + short_channel_id: 44, + fees: RoutingFees { + base_msat: 100, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + htlc_maximum_msat: Some(max_htlc_msat), + }, RouteHintHop { + src_node_id: intermed_node_id, + short_channel_id: 45, + fees: RoutingFees { + base_msat: 100, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + // Check that later route hint max htlcs don't override earlier ones + htlc_maximum_msat: Some(max_htlc_msat - 50), + }]); + let mut route_hint_2 = route_hint_1.clone(); + route_hint_2.0[0].short_channel_id = 46; + route_hint_2.0[1].short_channel_id = 47; + let dest_node_id = ln_test_utils::pubkey(44); + let payment_params = PaymentParameters::from_node_id(dest_node_id, 42) + .with_route_hints(vec![route_hint_1, route_hint_2]).unwrap() + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + + let route = get_route(&our_node_id, &payment_params, &network_graph.read_only(), + Some(&first_hop.iter().collect::>()), amt_msat, Arc::clone(&logger), &scorer, &(), + &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 2); + assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert_eq!(route.get_total_amount(), amt_msat); + + // Re-run but with two first hop channels connected to the same route hint peers that must be + // split between. + let first_hops = vec![ + get_channel_details(Some(42), intermed_node_id, InitFeatures::from_le_bytes(vec![0b11]), amt_msat - 10), + get_channel_details(Some(43), intermed_node_id, InitFeatures::from_le_bytes(vec![0b11]), amt_msat - 10), + ]; + let route = get_route(&our_node_id, &payment_params, &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), amt_msat, Arc::clone(&logger), &scorer, &(), + &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 2); + assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert_eq!(route.get_total_amount(), amt_msat); + + // Make sure this works for blinded route hints. + let blinded_path = BlindedPath { + introduction_node_id: intermed_node_id, + blinding_point: ln_test_utils::pubkey(42), + blinded_hops: vec![ + BlindedHop { blinded_node_id: ln_test_utils::pubkey(42), encrypted_payload: vec![] }, + BlindedHop { blinded_node_id: ln_test_utils::pubkey(43), encrypted_payload: vec![] }, + ], + }; + let blinded_payinfo = BlindedPayInfo { + fee_base_msat: 100, + fee_proportional_millionths: 0, + htlc_minimum_msat: 1, + htlc_maximum_msat: max_htlc_msat, + cltv_expiry_delta: 10, + features: BlindedHopFeatures::empty(), + }; + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let payment_params = PaymentParameters::blinded(vec![ + (blinded_payinfo.clone(), blinded_path.clone()), + (blinded_payinfo.clone(), blinded_path.clone())]) + .with_bolt12_features(bolt12_features).unwrap(); + let route = get_route(&our_node_id, &payment_params, &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), amt_msat, Arc::clone(&logger), &scorer, &(), + &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 2); + assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat); + assert_eq!(route.get_total_amount(), amt_msat); + } + #[test] fn blinded_route_ser() { let blinded_path_1 = BlindedPath { @@ -6050,11 +6526,209 @@ mod tests { assert_eq!(route.paths[0].blinded_tail.as_ref().unwrap().excess_final_cltv_expiry_delta, 40); assert_eq!(route.paths[0].hops.last().unwrap().cltv_expiry_delta, 40); } + + #[test] + fn simple_blinded_route_hints() { + do_simple_blinded_route_hints(1); + do_simple_blinded_route_hints(2); + do_simple_blinded_route_hints(3); + } + + fn do_simple_blinded_route_hints(num_blinded_hops: usize) { + // Check that we can generate a route to a blinded path with the expected hops. + let (secp_ctx, network, _, _, logger) = build_graph(); + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let network_graph = network.read_only(); + + let scorer = ln_test_utils::TestScorer::new(); + let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + + let mut blinded_path = BlindedPath { + introduction_node_id: nodes[2], + blinding_point: ln_test_utils::pubkey(42), + blinded_hops: Vec::with_capacity(num_blinded_hops), + }; + for i in 0..num_blinded_hops { + blinded_path.blinded_hops.push( + BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 + i as u8), encrypted_payload: Vec::new() }, + ); + } + let blinded_payinfo = BlindedPayInfo { + fee_base_msat: 100, + fee_proportional_millionths: 500, + htlc_minimum_msat: 1000, + htlc_maximum_msat: 100_000_000, + cltv_expiry_delta: 15, + features: BlindedHopFeatures::empty(), + }; + + let final_amt_msat = 1001; + let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), blinded_path.clone())]); + let route = get_route(&our_id, &payment_params, &network_graph, None, final_amt_msat , Arc::clone(&logger), + &scorer, &(), &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 1); + assert_eq!(route.paths[0].hops.len(), 2); + + let tail = route.paths[0].blinded_tail.as_ref().unwrap(); + assert_eq!(tail.hops, blinded_path.blinded_hops); + assert_eq!(tail.excess_final_cltv_expiry_delta, 0); + assert_eq!(tail.final_value_msat, 1001); + + let final_hop = route.paths[0].hops.last().unwrap(); + assert_eq!(final_hop.pubkey, blinded_path.introduction_node_id); + if tail.hops.len() > 1 { + assert_eq!(final_hop.fee_msat, + blinded_payinfo.fee_base_msat as u64 + blinded_payinfo.fee_proportional_millionths as u64 * tail.final_value_msat / 1000000); + assert_eq!(final_hop.cltv_expiry_delta, blinded_payinfo.cltv_expiry_delta as u32); + } else { + assert_eq!(final_hop.fee_msat, 0); + assert_eq!(final_hop.cltv_expiry_delta, 0); + } + } + + #[test] + fn blinded_path_routing_errors() { + // Check that we can generate a route to a blinded path with the expected hops. + let (secp_ctx, network, _, _, logger) = build_graph(); + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let network_graph = network.read_only(); + + let scorer = ln_test_utils::TestScorer::new(); + let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + + let mut invalid_blinded_path = BlindedPath { + introduction_node_id: nodes[2], + blinding_point: ln_test_utils::pubkey(42), + blinded_hops: vec![ + BlindedHop { blinded_node_id: ln_test_utils::pubkey(43), encrypted_payload: vec![0; 43] }, + ], + }; + let blinded_payinfo = BlindedPayInfo { + fee_base_msat: 100, + fee_proportional_millionths: 500, + htlc_minimum_msat: 1000, + htlc_maximum_msat: 100_000_000, + cltv_expiry_delta: 15, + features: BlindedHopFeatures::empty(), + }; + + let mut invalid_blinded_path_2 = invalid_blinded_path.clone(); + invalid_blinded_path_2.introduction_node_id = ln_test_utils::pubkey(45); + let payment_params = PaymentParameters::blinded(vec![ + (blinded_payinfo.clone(), invalid_blinded_path.clone()), + (blinded_payinfo.clone(), invalid_blinded_path_2)]); + match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger), + &scorer, &(), &random_seed_bytes) + { + Err(LightningError { err, .. }) => { + assert_eq!(err, "1-hop blinded paths must all have matching introduction node ids"); + }, + _ => panic!("Expected error") + } + + invalid_blinded_path.introduction_node_id = our_id; + let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), invalid_blinded_path.clone())]); + match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger), + &scorer, &(), &random_seed_bytes) + { + Err(LightningError { err, .. }) => { + assert_eq!(err, "Cannot generate a route to blinded paths if we are the introduction node to all of them"); + }, + _ => panic!("Expected error") + } + + invalid_blinded_path.introduction_node_id = ln_test_utils::pubkey(46); + invalid_blinded_path.blinded_hops.clear(); + let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo, invalid_blinded_path)]); + match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger), + &scorer, &(), &random_seed_bytes) + { + Err(LightningError { err, .. }) => { + assert_eq!(err, "0-hop blinded path provided"); + }, + _ => panic!("Expected error") + } + } + + #[test] + fn matching_intro_node_paths_provided() { + // Check that if multiple blinded paths with the same intro node are provided in payment + // parameters, we'll return the correct paths in the resulting MPP route. + let (secp_ctx, network, _, _, logger) = build_graph(); + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let network_graph = network.read_only(); + + let scorer = ln_test_utils::TestScorer::new(); + let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + let config = UserConfig::default(); + + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let blinded_path_1 = BlindedPath { + introduction_node_id: nodes[2], + blinding_point: ln_test_utils::pubkey(42), + blinded_hops: vec![ + BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 as u8), encrypted_payload: Vec::new() }, + BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 as u8), encrypted_payload: Vec::new() } + ], + }; + let blinded_payinfo_1 = BlindedPayInfo { + fee_base_msat: 0, + fee_proportional_millionths: 0, + htlc_minimum_msat: 0, + htlc_maximum_msat: 30_000, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + + let mut blinded_path_2 = blinded_path_1.clone(); + blinded_path_2.blinding_point = ln_test_utils::pubkey(43); + let mut blinded_payinfo_2 = blinded_payinfo_1.clone(); + blinded_payinfo_2.htlc_maximum_msat = 70_000; + + let blinded_hints = vec![ + (blinded_payinfo_1.clone(), blinded_path_1.clone()), + (blinded_payinfo_2.clone(), blinded_path_2.clone()), + ]; + let payment_params = PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + + let route = get_route(&our_id, &payment_params, &network_graph, None, + 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 2); + let mut total_amount_paid_msat = 0; + for path in route.paths.into_iter() { + assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]); + if let Some(bt) = &path.blinded_tail { + assert_eq!(bt.blinding_point, + blinded_hints.iter().find(|(p, _)| p.htlc_maximum_msat == path.final_value_msat()) + .map(|(_, bp)| bp.blinding_point).unwrap()); + } else { panic!(); } + total_amount_paid_msat += path.final_value_msat(); + } + assert_eq!(total_amount_paid_msat, 100_000); + } } -#[cfg(all(test, not(feature = "no-std")))] +#[cfg(all(any(test, ldk_bench), not(feature = "no-std")))] pub(crate) mod bench_utils { + use super::*; use std::fs::File; + + use bitcoin::hashes::Hash; + use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; + + use crate::chain::transaction::OutPoint; + use crate::sign::{EntropySource, KeysManager}; + use crate::ln::channelmanager::{self, ChannelCounterparty, ChannelDetails}; + use crate::ln::features::Bolt11InvoiceFeatures; + use crate::routing::gossip::NetworkGraph; + use crate::util::config::UserConfig; + use crate::util::ser::ReadableArgs; + use crate::util::test_utils::TestLogger; + /// Tries to open a network graph file, or panics with a URL to fetch it. pub(crate) fn get_route_file() -> Result { let res = File::open("net_graph-2023-01-18.bin") // By default we're run in RL/lightning @@ -6068,7 +6742,18 @@ pub(crate) mod bench_utils { path.pop(); // target path.push("lightning"); path.push("net_graph-2023-01-18.bin"); - eprintln!("{}", path.to_str().unwrap()); + File::open(path) + }) + .or_else(|_| { // Fall back to guessing based on the binary location for a subcrate + // path is likely something like .../rust-lightning/bench/target/debug/deps/bench.. + let mut path = std::env::current_exe().unwrap(); + path.pop(); // bench... + path.pop(); // deps + path.pop(); // debug + path.pop(); // target + path.pop(); // bench + path.push("lightning"); + path.push("net_graph-2023-01-18.bin"); File::open(path) }) .map_err(|_| "Please fetch https://bitcoin.ninja/ldk-net_graph-v0.0.113-2023-01-18.bin and place it at lightning/net_graph-2023-01-18.bin"); @@ -6077,42 +6762,18 @@ pub(crate) mod bench_utils { #[cfg(not(require_route_graph_test))] return res; } -} -#[cfg(all(test, feature = "_bench_unstable", not(feature = "no-std")))] -mod benches { - use super::*; - use bitcoin::hashes::Hash; - use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; - use crate::chain::transaction::OutPoint; - use crate::sign::{EntropySource, KeysManager}; - use crate::ln::channelmanager::{self, ChannelCounterparty, ChannelDetails}; - use crate::ln::features::InvoiceFeatures; - use crate::routing::gossip::NetworkGraph; - use crate::routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; - use crate::util::config::UserConfig; - use crate::util::logger::{Logger, Record}; - use crate::util::ser::ReadableArgs; - - use test::Bencher; - - struct DummyLogger {} - impl Logger for DummyLogger { - fn log(&self, _record: &Record) {} - } - - fn read_network_graph(logger: &DummyLogger) -> NetworkGraph<&DummyLogger> { - let mut d = bench_utils::get_route_file().unwrap(); - NetworkGraph::read(&mut d, logger).unwrap() + pub(crate) fn read_network_graph(logger: &TestLogger) -> Result, &'static str> { + get_route_file().map(|mut f| NetworkGraph::read(&mut f, logger).unwrap()) } - fn payer_pubkey() -> PublicKey { + pub(crate) fn payer_pubkey() -> PublicKey { let secp_ctx = Secp256k1::new(); PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()) } #[inline] - fn first_hop(node_id: PublicKey) -> ChannelDetails { + pub(crate) fn first_hop(node_id: PublicKey) -> ChannelDetails { ChannelDetails { channel_id: [0; 32], counterparty: ChannelCounterparty { @@ -6130,11 +6791,12 @@ mod benches { short_channel_id: Some(1), inbound_scid_alias: None, outbound_scid_alias: None, - channel_value_satoshis: 10_000_000, + channel_value_satoshis: 10_000_000_000, user_channel_id: 0, - balance_msat: 10_000_000, - outbound_capacity_msat: 10_000_000, - next_outbound_htlc_limit_msat: 10_000_000, + balance_msat: 10_000_000_000, + outbound_capacity_msat: 10_000_000_000, + next_outbound_htlc_minimum_msat: 0, + next_outbound_htlc_limit_msat: 10_000_000_000, inbound_capacity_msat: 0, unspendable_punishment_reserve: None, confirmations_required: None, @@ -6148,103 +6810,171 @@ mod benches { inbound_htlc_maximum_msat: None, config: None, feerate_sat_per_1000_weight: None, + channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown), } } - #[bench] - fn generate_routes_with_zero_penalty_scorer(bench: &mut Bencher) { - let logger = DummyLogger {}; - let network_graph = read_network_graph(&logger); + pub(crate) fn generate_test_routes(graph: &NetworkGraph<&TestLogger>, scorer: &mut S, + score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, mut seed: u64, + starting_amount: u64, route_count: usize, + ) -> Vec<(ChannelDetails, PaymentParameters, u64)> { + let payer = payer_pubkey(); + let keys_manager = KeysManager::new(&[0u8; 32], 42, 42); + let random_seed_bytes = keys_manager.get_secure_random_bytes(); + + let nodes = graph.read_only().nodes().clone(); + let mut route_endpoints = Vec::new(); + // Fetch 1.5x more routes than we need as after we do some scorer updates we may end up + // with some routes we picked being un-routable. + for _ in 0..route_count * 3 / 2 { + loop { + seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; + let src = PublicKey::from_slice(nodes.unordered_keys() + .skip((seed as usize) % nodes.len()).next().unwrap().as_slice()).unwrap(); + seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; + let dst = PublicKey::from_slice(nodes.unordered_keys() + .skip((seed as usize) % nodes.len()).next().unwrap().as_slice()).unwrap(); + let params = PaymentParameters::from_node_id(dst, 42) + .with_bolt11_features(features.clone()).unwrap(); + let first_hop = first_hop(src); + let amt = starting_amount + seed % 1_000_000; + let path_exists = + get_route(&payer, ¶ms, &graph.read_only(), Some(&[&first_hop]), + amt, &TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok(); + if path_exists { + // ...and seed the scorer with success and failure data... + seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; + let mut score_amt = seed % 1_000_000_000; + loop { + // Generate fail/success paths for a wider range of potential amounts with + // MPP enabled to give us a chance to apply penalties for more potential + // routes. + let mpp_features = channelmanager::provided_invoice_features(&UserConfig::default()); + let params = PaymentParameters::from_node_id(dst, 42) + .with_bolt11_features(mpp_features).unwrap(); + + let route_res = get_route(&payer, ¶ms, &graph.read_only(), + Some(&[&first_hop]), score_amt, &TestLogger::new(), &scorer, + score_params, &random_seed_bytes); + if let Ok(route) = route_res { + for path in route.paths { + if seed & 0x80 == 0 { + scorer.payment_path_successful(&path); + } else { + let short_channel_id = path.hops[path.hops.len() / 2].short_channel_id; + scorer.payment_path_failed(&path, short_channel_id); + } + seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0; + } + break; + } + // If we couldn't find a path with a higer amount, reduce and try again. + score_amt /= 100; + } + + route_endpoints.push((first_hop, params, amt)); + break; + } + } + } + + // Because we've changed channel scores, it's possible we'll take different routes to the + // selected destinations, possibly causing us to fail because, eg, the newly-selected path + // requires a too-high CLTV delta. + route_endpoints.retain(|(first_hop, params, amt)| { + get_route(&payer, params, &graph.read_only(), Some(&[first_hop]), *amt, + &TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok() + }); + route_endpoints.truncate(route_count); + assert_eq!(route_endpoints.len(), route_count); + route_endpoints + } +} + +#[cfg(ldk_bench)] +pub mod benches { + use super::*; + use crate::sign::{EntropySource, KeysManager}; + use crate::ln::channelmanager; + use crate::ln::features::Bolt11InvoiceFeatures; + use crate::routing::gossip::NetworkGraph; + use crate::routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; + use crate::util::config::UserConfig; + use crate::util::logger::{Logger, Record}; + use crate::util::test_utils::TestLogger; + + use criterion::Criterion; + + struct DummyLogger {} + impl Logger for DummyLogger { + fn log(&self, _record: &Record) {} + } + + pub fn generate_routes_with_zero_penalty_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); let scorer = FixedPenaltyScorer::with_penalty(0); - generate_routes(bench, &network_graph, scorer, &(), InvoiceFeatures::empty()); + generate_routes(bench, &network_graph, scorer, &(), Bolt11InvoiceFeatures::empty(), 0, + "generate_routes_with_zero_penalty_scorer"); } - #[bench] - fn generate_mpp_routes_with_zero_penalty_scorer(bench: &mut Bencher) { - let logger = DummyLogger {}; - let network_graph = read_network_graph(&logger); + pub fn generate_mpp_routes_with_zero_penalty_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); let scorer = FixedPenaltyScorer::with_penalty(0); - generate_routes(bench, &network_graph, scorer, &(), channelmanager::provided_invoice_features(&UserConfig::default())); + generate_routes(bench, &network_graph, scorer, &(), + channelmanager::provided_invoice_features(&UserConfig::default()), 0, + "generate_mpp_routes_with_zero_penalty_scorer"); } - #[bench] - fn generate_routes_with_probabilistic_scorer(bench: &mut Bencher) { - let logger = DummyLogger {}; - let network_graph = read_network_graph(&logger); + pub fn generate_routes_with_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); let params = ProbabilisticScoringFeeParameters::default(); let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); - generate_routes(bench, &network_graph, scorer, ¶ms, InvoiceFeatures::empty()); + generate_routes(bench, &network_graph, scorer, ¶ms, Bolt11InvoiceFeatures::empty(), 0, + "generate_routes_with_probabilistic_scorer"); } - #[bench] - fn generate_mpp_routes_with_probabilistic_scorer(bench: &mut Bencher) { - let logger = DummyLogger {}; - let network_graph = read_network_graph(&logger); + pub fn generate_mpp_routes_with_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); let params = ProbabilisticScoringFeeParameters::default(); let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); - generate_routes(bench, &network_graph, scorer, ¶ms, channelmanager::provided_invoice_features(&UserConfig::default())); + generate_routes(bench, &network_graph, scorer, ¶ms, + channelmanager::provided_invoice_features(&UserConfig::default()), 0, + "generate_mpp_routes_with_probabilistic_scorer"); + } + + pub fn generate_large_mpp_routes_with_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let params = ProbabilisticScoringFeeParameters::default(); + let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); + generate_routes(bench, &network_graph, scorer, ¶ms, + channelmanager::provided_invoice_features(&UserConfig::default()), 100_000_000, + "generate_large_mpp_routes_with_probabilistic_scorer"); } fn generate_routes( - bench: &mut Bencher, graph: &NetworkGraph<&DummyLogger>, mut scorer: S, score_params: &S::ScoreParams, - features: InvoiceFeatures + bench: &mut Criterion, graph: &NetworkGraph<&TestLogger>, mut scorer: S, + score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, starting_amount: u64, + bench_name: &'static str, ) { - let nodes = graph.read_only().nodes().clone(); - let payer = payer_pubkey(); + let payer = bench_utils::payer_pubkey(); let keys_manager = KeysManager::new(&[0u8; 32], 42, 42); let random_seed_bytes = keys_manager.get_secure_random_bytes(); // First, get 100 (source, destination) pairs for which route-getting actually succeeds... - let mut routes = Vec::new(); - let mut route_endpoints = Vec::new(); - let mut seed: usize = 0xdeadbeef; - 'load_endpoints: for _ in 0..150 { - loop { - seed *= 0xdeadbeef; - let src = PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - seed *= 0xdeadbeef; - let dst = PublicKey::from_slice(nodes.unordered_keys().skip(seed % nodes.len()).next().unwrap().as_slice()).unwrap(); - let params = PaymentParameters::from_node_id(dst, 42).with_bolt11_features(features.clone()).unwrap(); - let first_hop = first_hop(src); - let amt = seed as u64 % 1_000_000; - if let Ok(route) = get_route(&payer, ¶ms, &graph.read_only(), Some(&[&first_hop]), amt, &DummyLogger{}, &scorer, score_params, &random_seed_bytes) { - routes.push(route); - route_endpoints.push((first_hop, params, amt)); - continue 'load_endpoints; - } - } - } - - // ...and seed the scorer with success and failure data... - for route in routes { - let amount = route.get_total_amount(); - if amount < 250_000 { - for path in route.paths { - scorer.payment_path_successful(&path); - } - } else if amount > 750_000 { - for path in route.paths { - let short_channel_id = path.hops[path.hops.len() / 2].short_channel_id; - scorer.payment_path_failed(&path, short_channel_id); - } - } - } - - // Because we've changed channel scores, its possible we'll take different routes to the - // selected destinations, possibly causing us to fail because, eg, the newly-selected path - // requires a too-high CLTV delta. - route_endpoints.retain(|(first_hop, params, amt)| { - get_route(&payer, params, &graph.read_only(), Some(&[first_hop]), *amt, &DummyLogger{}, &scorer, score_params, &random_seed_bytes).is_ok() - }); - route_endpoints.truncate(100); - assert_eq!(route_endpoints.len(), 100); + let route_endpoints = bench_utils::generate_test_routes(graph, &mut scorer, score_params, features, 0xdeadbeef, starting_amount, 50); // ...then benchmark finding paths between the nodes we learned. let mut idx = 0; - bench.iter(|| { + bench.bench_function(bench_name, |b| b.iter(|| { let (first_hop, params, amt) = &route_endpoints[idx % route_endpoints.len()]; - assert!(get_route(&payer, params, &graph.read_only(), Some(&[first_hop]), *amt, &DummyLogger{}, &scorer, score_params, &random_seed_bytes).is_ok()); + assert!(get_route(&payer, params, &graph.read_only(), Some(&[first_hop]), *amt, + &DummyLogger{}, &scorer, score_params, &random_seed_bytes).is_ok()); idx += 1; - }); + })); } }