X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=f82ddc80a11abaecf334c04a8110c9c485f696e7;hb=a8eef297fceacc0ca984c28cd5114b1ec08d8b7e;hp=ef6fef0a7eb42ea87b8d0876f0b11f99112d83cb;hpb=32eb89474cdc1e400ef89eab76d590d19da4746a;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index ef6fef0a..8db682eb 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -16,26 +16,26 @@ 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::routing::scoring::{ChannelUsage, LockableScore, ScoreLookUp}; use crate::util::ser::{Writeable, Readable, ReadableArgs, Writer}; use crate::util::logger::{Level, Logger}; 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; /// A [`Router`] implemented using [`find_route`]. -pub struct DefaultRouter>, L: Deref, S: Deref, SP: Sized, Sc: Score> where +pub struct DefaultRouter>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, ScoreLookUp = Sc>, { network_graph: G, logger: L, @@ -44,9 +44,9 @@ pub struct DefaultRouter>, L: Deref, S: Deref, score_params: SP } -impl>, L: Deref, S: Deref, SP: Sized, Sc: Score> DefaultRouter where +impl>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp> DefaultRouter where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, ScoreLookUp = 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: ScoreLookUp> Router for DefaultRouter where L::Target: Logger, - S::Target: for <'a> LockableScore<'a, Locked = MutexGuard<'a, Sc>>, + S::Target: for <'a> LockableScore<'a, ScoreLookUp = 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.read_lock(), &inflight_htlcs), &self.score_params, &random_seed_bytes ) @@ -82,35 +82,42 @@ 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) } } -/// [`Score`] implementation that factors in in-flight HTLC liquidity. +/// [`ScoreLookUp`] implementation that factors in in-flight HTLC liquidity. /// -/// Useful for custom [`Router`] implementations to wrap their [`Score`] on-the-fly when calling +/// Useful for custom [`Router`] implementations to wrap their [`ScoreLookUp`] on-the-fly when calling /// [`find_route`]. /// -/// [`Score`]: crate::routing::scoring::Score -pub struct ScorerAccountingForInFlightHtlcs<'a, S: Score> { +/// [`ScoreLookUp`]: crate::routing::scoring::ScoreLookUp +pub struct ScorerAccountingForInFlightHtlcs<'a, SP: Sized, Sc: 'a + ScoreLookUp, S: Deref> { scorer: 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, SP: Sized, Sc: ScoreLookUp, S: Deref> ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> { /// Initialize a new `ScorerAccountingForInFlightHtlcs`. pub fn new(scorer: S, inflight_htlcs: &'a InFlightHtlcs) -> Self { ScorerAccountingForInFlightHtlcs { @@ -121,18 +128,18 @@ impl<'a, S: Score> ScorerAccountingForInFlightHtlcs<'a, S> { } #[cfg(c_bindings)] -impl<'a, S: Score> Writeable for ScorerAccountingForInFlightHtlcs<'a, S> { +impl<'a, SP: Sized, Sc: ScoreLookUp, S: Deref> Writeable for ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> { fn write(&self, writer: &mut W) -> Result<(), io::Error> { self.scorer.write(writer) } } -impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { - type ScoreParams = S::ScoreParams; +impl<'a, SP: Sized, Sc: 'a + ScoreLookUp, S: Deref> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> { + type ScoreParams = Sc::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( source, target, short_channel_id ) { let usage = ChannelUsage { - inflight_htlc_msat: usage.inflight_htlc_msat + used_liquidity, + inflight_htlc_msat: usage.inflight_htlc_msat.saturating_add(used_liquidity), ..usage }; @@ -141,22 +148,6 @@ impl<'a, S: Score> Score for ScorerAccountingForInFlightHtlcs<'a, S> { self.scorer.channel_penalty_msat(short_channel_id, source, target, usage, score_params) } } - - fn payment_path_failed(&mut self, path: &Path, short_channel_id: u64) { - self.scorer.payment_path_failed(path, short_channel_id) - } - - fn payment_path_successful(&mut self, path: &Path) { - self.scorer.payment_path_successful(path) - } - - fn probe_failed(&mut self, path: &Path, short_channel_id: u64) { - self.scorer.probe_failed(path, short_channel_id) - } - - fn probe_successful(&mut self, path: &Path) { - self.scorer.probe_successful(path) - } } /// A data structure for tracking in-flight HTLCs. May be used during pathfinding to account for @@ -204,6 +195,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 { @@ -250,10 +250,20 @@ pub struct RouteHop { /// /// [`BlindedPath`]: crate::blinded_path::BlindedPath pub cltv_expiry_delta: u32, + /// Indicates whether this hop is possibly announced in the public network graph. + /// + /// Will be `true` if there is a possibility that the channel is publicly known, i.e., if we + /// either know for sure it's announced in the public graph, or if any public channels exist + /// for which the given `short_channel_id` could be an alias for. Will be `false` if we believe + /// the channel to be unannounced. + /// + /// Will be `true` for objects serialized with LDK version 0.0.116 and before. + pub maybe_announced_channel: bool, } impl_writeable_tlv_based!(RouteHop, { (0, pubkey, required), + (1, maybe_announced_channel, (default_value, true)), (2, node_features, required), (4, short_channel_id, required), (6, channel_features, required), @@ -262,9 +272,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 +293,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), @@ -331,36 +341,51 @@ impl Path { /// A route directs a payment from the sender (us) to the recipient. If the recipient supports MPP, /// it can take multiple paths. Each path is composed of one or more hops through the network. -#[derive(Clone, Hash, PartialEq, Eq)] +#[derive(Clone, Debug, Hash, PartialEq, Eq)] pub struct Route { /// The list of [`Path`]s taken for a single (potentially-)multi-part payment. If no /// [`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 `route_params` parameter passed to [`find_route`]. /// - /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed - pub payment_params: Option, + /// This is used by `ChannelManager` to track information which may be required for retries. + /// + /// Will be `None` for objects serialized with LDK versions prior to 0.0.117. + pub route_params: Option, } 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`. + /// For objects serialized with LDK 0.0.117 and after, this includes any extra payment made to + /// the recipient, which can happen in excess of the amount passed to [`find_route`] via + /// [`RouteParameters::final_value_msat`], if we had to reach the [`htlc_minimum_msat`] limits. + /// + /// [`htlc_minimum_msat`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message pub fn get_total_fees(&self) -> u64 { - self.paths.iter().map(|path| path.fee_msat()).sum() + let overpaid_value_msat = self.route_params.as_ref() + .map_or(0, |p| self.get_total_amount().saturating_sub(p.final_value_msat)); + overpaid_value_msat + self.paths.iter().map(|path| path.fee_msat()).sum::() } - /// Returns the total amount paid on this [`Route`], excluding the fees. Might be more than - /// requested if we had to reach htlc_minimum_msat. + /// Returns the total amount paid on this [`Route`], excluding the fees. + /// + /// Might be more than requested as part of the given [`RouteParameters::final_value_msat`] if + /// we had to reach the [`htlc_minimum_msat`] limits. + /// + /// [`htlc_minimum_msat`]: https://github.com/lightning/bolts/blob/master/07-routing-gossip.md#the-channel_update-message pub fn get_total_amount(&self) -> u64 { self.paths.iter().map(|path| path.final_value_msat()).sum() } } +impl fmt::Display for Route { + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + log_route!(self).fmt(f) + } +} + const SERIALIZATION_VERSION: u8 = 1; const MIN_SERIALIZATION_VERSION: u8 = 1; @@ -385,8 +410,12 @@ impl Writeable for Route { } } write_tlv_fields!(writer, { - (1, self.payment_params, option), + // For compatibility with LDK versions prior to 0.0.117, we take the individual + // RouteParameters' fields and reconstruct them on read. + (1, self.route_params.as_ref().map(|p| &p.payment_params), option), (2, blinded_tails, optional_vec), + (3, self.route_params.as_ref().map(|p| p.final_value_msat), option), + (5, self.route_params.as_ref().map(|p| p.max_total_routing_fee_msat), option), }); Ok(()) } @@ -410,40 +439,66 @@ impl Readable for Route { cmp::min(min_final_cltv_expiry_delta, hops.last().unwrap().cltv_expiry_delta); paths.push(Path { hops, blinded_tail: None }); } - _init_and_read_tlv_fields!(reader, { + _init_and_read_len_prefixed_tlv_fields!(reader, { (1, payment_params, (option: ReadableArgs, min_final_cltv_expiry_delta)), (2, blinded_tails, optional_vec), + (3, final_value_msat, option), + (5, max_total_routing_fee_msat, option) }); 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; } } - Ok(Route { paths, payment_params }) + + // If we previously wrote the corresponding fields, reconstruct RouteParameters. + let route_params = match (payment_params, final_value_msat) { + (Some(payment_params), Some(final_value_msat)) => { + Some(RouteParameters { payment_params, final_value_msat, max_total_routing_fee_msat }) + } + _ => None, + }; + + Ok(Route { paths, route_params }) } } /// 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 -#[derive(Clone, Debug, PartialEq, Eq)] +/// Passed to [`find_route`] and [`build_route_from_hops`]. +#[derive(Clone, Debug, Hash, PartialEq, Eq)] pub struct RouteParameters { /// The parameters of the failed payment path. pub payment_params: PaymentParameters, /// The amount in msats sent on the failed payment path. pub final_value_msat: u64, + + /// The maximum total fees, in millisatoshi, that may accrue during route finding. + /// + /// This limit also applies to the total fees that may arise while retrying failed payment + /// paths. + /// + /// Note that values below a few sats may result in some paths being spuriously ignored. + pub max_total_routing_fee_msat: Option, +} + +impl RouteParameters { + /// Constructs [`RouteParameters`] from the given [`PaymentParameters`] and a payment amount. + /// + /// [`Self::max_total_routing_fee_msat`] defaults to 1% of the payment amount + 50 sats + pub fn from_payment_params_and_value(payment_params: PaymentParameters, final_value_msat: u64) -> Self { + Self { payment_params, final_value_msat, max_total_routing_fee_msat: Some(final_value_msat / 100 + 50_000) } + } } impl Writeable for RouteParameters { fn write(&self, writer: &mut W) -> Result<(), io::Error> { write_tlv_fields!(writer, { (0, self.payment_params, required), + (1, self.max_total_routing_fee_msat, option), (2, self.final_value_msat, required), // LDK versions prior to 0.0.114 had the `final_cltv_expiry_delta` parameter in // `RouteParameters` directly. For compatibility, we write it here. @@ -455,8 +510,9 @@ impl Writeable for RouteParameters { impl Readable for RouteParameters { fn read(reader: &mut R) -> Result { - _init_and_read_tlv_fields!(reader, { + _init_and_read_len_prefixed_tlv_fields!(reader, { (0, payment_params, (required: ReadableArgs, 0)), + (1, max_total_routing_fee_msat, option), (2, final_value_msat, required), (4, final_cltv_delta, option), }); @@ -469,6 +525,7 @@ impl Readable for RouteParameters { Ok(Self { payment_params, final_value_msat: final_value_msat.0.unwrap(), + max_total_routing_fee_msat, }) } } @@ -481,6 +538,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 +607,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), }); @@ -561,19 +620,18 @@ impl Writeable for PaymentParameters { impl ReadableArgs for PaymentParameters { fn read(reader: &mut R, default_final_cltv_expiry_delta: u32) -> Result { - _init_and_read_tlv_fields!(reader, { + _init_and_read_len_prefixed_tlv_fields!(reader, { (0, payee_pubkey, option), (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 +670,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 +679,57 @@ 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") } - /// Includes the payee's features. Errors if the parameters were initialized with blinded payment - /// paths. + /// 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.invoice_features().clone()).unwrap() + .with_expiry_time(invoice.created_at().as_secs().saturating_add(invoice.relative_expiry().as_secs())) + } + + /// Creates parameters for paying to a blinded payee from the provided blinded route hints. + pub 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_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: InvoiceFeatures) -> Result { + 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 +742,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 +778,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 +815,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 +852,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 +883,7 @@ impl Features { _ => None, } } - fn bolt11(self) -> Option { + fn bolt11(self) -> Option { match self { Self::Bolt11(f) => Some(f), _ => None, @@ -895,18 +1009,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 +1046,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 +1056,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 +1078,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 +1095,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 +1137,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), } @@ -1088,7 +1265,11 @@ impl<'a> PaymentPath<'a> { // Note that this function is not aware of the available_liquidity limit, and thus does not // support increasing the value being transferred beyond what was selected during the initial // routing passes. - fn update_value_and_recompute_fees(&mut self, value_msat: u64) { + // + // Returns the amount that this path contributes to the total payment value, which may be greater + // than `value_msat` if we had to overpay to meet the final node's `htlc_minimum_msat`. + fn update_value_and_recompute_fees(&mut self, value_msat: u64) -> u64 { + let mut extra_contribution_msat = 0; let mut total_fee_paid_msat = 0 as u64; for i in (0..self.hops.len()).rev() { let last_hop = i == self.hops.len() - 1; @@ -1101,8 +1282,9 @@ 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; + cur_hop.path_penalty_msat += extra_contribution_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 // set it too high just to maliciously take more fees by exploiting this @@ -1118,8 +1300,15 @@ impl<'a> PaymentPath<'a> { // Also, this can't be exploited more heavily than *announce a free path and fail // all payments*. cur_hop_transferred_amount_msat += extra_fees_msat; - total_fee_paid_msat += extra_fees_msat; - cur_hop_fees_msat += extra_fees_msat; + + // We remember and return the extra fees on the final hop to allow accounting for + // them in the path's value contribution. + if last_hop { + extra_contribution_msat = extra_fees_msat; + } else { + total_fee_paid_msat += extra_fees_msat; + cur_hop_fees_msat += extra_fees_msat; + } } if last_hop { @@ -1147,6 +1336,7 @@ impl<'a> PaymentPath<'a> { } } } + value_msat + extra_contribution_msat } } @@ -1192,12 +1382,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,45 +1460,41 @@ 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 /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed /// [`NetworkGraph`]: crate::routing::gossip::NetworkGraph -pub fn find_route( +pub fn find_route( our_node_pubkey: &PublicKey, route_params: &RouteParameters, network_graph: &NetworkGraph, first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S, score_params: &S::ScoreParams, random_seed_bytes: &[u8; 32] ) -> Result where L::Target: Logger, GL::Target: Logger { let graph_lock = network_graph.read_only(); - let mut route = get_route(our_node_pubkey, &route_params.payment_params, &graph_lock, first_hops, - route_params.final_value_msat, logger, scorer, score_params, - random_seed_bytes)?; + let mut route = get_route(our_node_pubkey, &route_params, &graph_lock, first_hops, logger, + scorer, score_params, random_seed_bytes)?; add_random_cltv_offset(&mut route, &route_params.payment_params, &graph_lock, random_seed_bytes); Ok(route) } -pub(crate) fn get_route( - our_node_pubkey: &PublicKey, payment_params: &PaymentParameters, network_graph: &ReadOnlyNetworkGraph, - first_hops: Option<&[&ChannelDetails]>, final_value_msat: u64, logger: L, scorer: &S, score_params: &S::ScoreParams, +pub(crate) fn get_route( + our_node_pubkey: &PublicKey, route_params: &RouteParameters, network_graph: &ReadOnlyNetworkGraph, + first_hops: Option<&[&ChannelDetails]>, logger: L, scorer: &S, score_params: &S::ScoreParams, _random_seed_bytes: &[u8; 32] ) -> Result where L::Target: Logger { + + let payment_params = &route_params.payment_params; + let final_value_msat = route_params.final_value_msat; // If we're routing to a blinded recipient, we won't have their node id. Therefore, keep the // 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); @@ -1253,6 +1502,9 @@ where L::Target: Logger { if payee_node_id_opt.map_or(false, |payee| payee == our_node_id) { return Err(LightningError{err: "Cannot generate a route to ourselves".to_owned(), action: ErrorAction::IgnoreError}); } + if our_node_id == maybe_dummy_payee_node_id { + return Err(LightningError{err: "Invalid origin node id provided, use a different one".to_owned(), action: ErrorAction::IgnoreError}); + } if final_value_msat > MAX_VALUE_MSAT { return Err(LightningError{err: "Cannot generate a route of more value than all existing satoshis".to_owned(), action: ErrorAction::IgnoreError}); @@ -1272,8 +1524,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 +1692,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,47 +1705,39 @@ 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; + let mut num_ignored_total_fee_limit = 0; + let mut num_ignored_avoid_overpayment = 0; + let mut num_ignored_htlc_minimum_msat_limit = 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, // since that value has to be transferred over this channel. - // Returns whether this channel caused an update to `targets`. + // Returns the contribution amount of $candidate if the channel caused an update to `targets`. ( $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 hop_contribution_amt_msat = 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 +1749,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,27 +1792,59 @@ 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, + CandidateRouteHop::OneHopBlinded { .. } => 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 { + if should_log_candidate { + log_trace!(logger, + "Ignoring {} to avoid overpaying to meet htlc_minimum_msat limit.", + LoggedCandidateHop(&$candidate)); + } + num_ignored_avoid_overpayment += 1; hit_minimum_limit = true; } else if over_path_minimum_msat { // Note that low contribution here (limited by available_liquidity_msat) // might violate htlc_minimum_msat on the hops which are next along the // payment path (upstream to the payee). To avoid that, we recompute // path fees knowing the final path contribution after constructing it. - let path_htlc_minimum_msat = cmp::max( - compute_fees_saturating($next_hops_path_htlc_minimum_msat, $candidate.fees()) - .saturating_add($next_hops_path_htlc_minimum_msat), - $candidate.htlc_minimum_msat()); + let curr_min = cmp::max( + $next_hops_path_htlc_minimum_msat, $candidate.htlc_minimum_msat() + ); + let path_htlc_minimum_msat = compute_fees_saturating(curr_min, $candidate.fees()) + .saturating_add(curr_min); let hm_entry = dist.entry($src_node_id); let old_entry = hm_entry.or_insert_with(|| { // If there was previously no known way to access the source node @@ -1597,96 +1889,112 @@ where L::Target: Logger { total_fee_msat = total_fee_msat.saturating_add(hop_use_fee_msat); } - let channel_usage = ChannelUsage { - amount_msat: amount_to_transfer_over_msat, - 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 path_penalty_msat = $next_hops_path_penalty_msat - .saturating_add(channel_penalty_msat); - let new_graph_node = RouteGraphNode { - node_id: $src_node_id, - lowest_fee_to_node: total_fee_msat, - total_cltv_delta: hop_total_cltv_delta, - value_contribution_msat, - path_htlc_minimum_msat, - path_penalty_msat, - path_length_to_node, - }; - - // Update the way of reaching $src_node_id with the given short_channel_id (from $dest_node_id), - // if this way is cheaper than the already known - // (considering the cost to "reach" this channel from the route destination, - // the cost of using this channel, - // and the cost of routing to the source node of this channel). - // Also, consider that htlc_minimum_msat_difference, because we might end up - // paying it. Consider the following exploit: - // we use 2 paths to transfer 1.5 BTC. One of them is 0-fee normal 1 BTC path, - // and for the other one we picked a 1sat-fee path with htlc_minimum_msat of - // 1 BTC. Now, since the latter is more expensive, we gonna try to cut it - // by 0.5 BTC, but then match htlc_minimum_msat by paying a fee of 0.5 BTC - // to this channel. - // Ideally the scoring could be smarter (e.g. 0.5*htlc_minimum_msat here), - // but it may require additional tracking - we don't want to double-count - // the fees included in $next_hops_path_htlc_minimum_msat, but also - // can't use something that may decrease on future hops. - let old_cost = cmp::max(old_entry.total_fee_msat, old_entry.path_htlc_minimum_msat) - .saturating_add(old_entry.path_penalty_msat); - let new_cost = cmp::max(total_fee_msat, path_htlc_minimum_msat) - .saturating_add(path_penalty_msat); - - if !old_entry.was_processed && new_cost < old_cost { - targets.push(new_graph_node); - old_entry.next_hops_fee_msat = $next_hops_fee_msat; - old_entry.hop_use_fee_msat = hop_use_fee_msat; - old_entry.total_fee_msat = total_fee_msat; - old_entry.node_id = $dest_node_id.clone(); - old_entry.candidate = $candidate.clone(); - 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(ldk_bench), any(test, fuzzing)))] - { - old_entry.value_contribution_msat = value_contribution_msat; + // Ignore hops if augmenting the current path to them would put us over `max_total_routing_fee_msat` + let max_total_routing_fee_msat = route_params.max_total_routing_fee_msat.unwrap_or(u64::max_value()); + if total_fee_msat > max_total_routing_fee_msat { + if should_log_candidate { + log_trace!(logger, "Ignoring {} due to exceeding max total routing fee limit.", LoggedCandidateHop(&$candidate)); } - did_add_update_path_to_src_node = true; - } else if old_entry.was_processed && new_cost < old_cost { - #[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 - // cheaper fee, check that it was because the second path we - // found (which we are processing now) has a lower value - // contribution due to an HTLC minimum limit. - // - // e.g. take a graph with two paths from node 1 to node 2, one - // through channel A, and one through channel B. Channel A and - // B are both in the to-process heap, with their scores set by - // a higher htlc_minimum than fee. - // Channel A is processed first, and the channels onwards from - // node 1 are added to the to-process heap. Thereafter, we pop - // Channel B off of the heap, note that it has a much more - // restrictive htlc_maximum_msat, and recalculate the fees for - // all of node 1's channels using the new, reduced, amount. - // - // This would be bogus - we'd be selecting a higher-fee path - // with a lower htlc_maximum_msat instead of the one we'd - // already decided to use. - debug_assert!(path_htlc_minimum_msat < old_entry.path_htlc_minimum_msat); - debug_assert!( - value_contribution_msat + path_penalty_msat < - old_entry.value_contribution_msat + old_entry.path_penalty_msat - ); + num_ignored_total_fee_limit += 1; + } else { + let channel_usage = ChannelUsage { + amount_msat: amount_to_transfer_over_msat, + inflight_htlc_msat: used_liquidity_msat, + effective_capacity, + }; + 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 { + node_id: $src_node_id, + lowest_fee_to_node: total_fee_msat, + total_cltv_delta: hop_total_cltv_delta, + value_contribution_msat, + path_htlc_minimum_msat, + path_penalty_msat, + path_length_to_node, + }; + + // Update the way of reaching $src_node_id with the given short_channel_id (from $dest_node_id), + // if this way is cheaper than the already known + // (considering the cost to "reach" this channel from the route destination, + // the cost of using this channel, + // and the cost of routing to the source node of this channel). + // Also, consider that htlc_minimum_msat_difference, because we might end up + // paying it. Consider the following exploit: + // we use 2 paths to transfer 1.5 BTC. One of them is 0-fee normal 1 BTC path, + // and for the other one we picked a 1sat-fee path with htlc_minimum_msat of + // 1 BTC. Now, since the latter is more expensive, we gonna try to cut it + // by 0.5 BTC, but then match htlc_minimum_msat by paying a fee of 0.5 BTC + // to this channel. + // Ideally the scoring could be smarter (e.g. 0.5*htlc_minimum_msat here), + // but it may require additional tracking - we don't want to double-count + // the fees included in $next_hops_path_htlc_minimum_msat, but also + // can't use something that may decrease on future hops. + let old_cost = cmp::max(old_entry.total_fee_msat, old_entry.path_htlc_minimum_msat) + .saturating_add(old_entry.path_penalty_msat); + let new_cost = cmp::max(total_fee_msat, path_htlc_minimum_msat) + .saturating_add(path_penalty_msat); + + if !old_entry.was_processed && new_cost < old_cost { + targets.push(new_graph_node); + old_entry.next_hops_fee_msat = $next_hops_fee_msat; + old_entry.hop_use_fee_msat = hop_use_fee_msat; + old_entry.total_fee_msat = total_fee_msat; + old_entry.node_id = $dest_node_id.clone(); + old_entry.candidate = $candidate.clone(); + 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(ldk_bench), any(test, fuzzing)))] + { + old_entry.value_contribution_msat = value_contribution_msat; + } + hop_contribution_amt_msat = Some(value_contribution_msat); + } else if old_entry.was_processed && new_cost < old_cost { + #[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 + // cheaper fee, check that it was because the second path we + // found (which we are processing now) has a lower value + // contribution due to an HTLC minimum limit. + // + // e.g. take a graph with two paths from node 1 to node 2, one + // through channel A, and one through channel B. Channel A and + // B are both in the to-process heap, with their scores set by + // a higher htlc_minimum than fee. + // Channel A is processed first, and the channels onwards from + // node 1 are added to the to-process heap. Thereafter, we pop + // Channel B off of the heap, note that it has a much more + // restrictive htlc_maximum_msat, and recalculate the fees for + // all of node 1's channels using the new, reduced, amount. + // + // This would be bogus - we'd be selecting a higher-fee path + // with a lower htlc_maximum_msat instead of the one we'd + // already decided to use. + debug_assert!(path_htlc_minimum_msat < old_entry.path_htlc_minimum_msat); + debug_assert!( + value_contribution_msat + path_penalty_msat < + old_entry.value_contribution_msat + old_entry.path_penalty_msat + ); + } } } } + } else { + if should_log_candidate { + log_trace!(logger, + "Ignoring {} due to its htlc_minimum_msat limit.", + LoggedCandidateHop(&$candidate)); + } + num_ignored_htlc_minimum_msat_limit += 1; } } } - did_add_update_path_to_src_node + hop_contribution_amt_msat } } } @@ -1761,7 +2069,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 +2081,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 +2104,44 @@ 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 || our_node_id == intro_node_id { 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 }; + let blinded_path_fee = match compute_fees(path_contribution_msat, candidate.fees()) { + Some(fee) => fee, + None => continue + }; + let path_min = candidate.htlc_minimum_msat().saturating_add( + compute_fees_saturating(candidate.htlc_minimum_msat(), candidate.fees())); + add_entry!(first_hop_candidate, our_node_id, intro_node_id, blinded_path_fee, + path_contribution_msat, path_min, 0_u64, candidate.cltv_expiry_delta(), + candidate.blinded_path().map_or(1, |bp| bp.blinded_hops.len() as u8)); + } + } + } + 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 +2161,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 +2175,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 +2209,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); } } @@ -1887,11 +2234,15 @@ where L::Target: Logger { .map_or(None, |inc| inc.checked_add(aggregate_next_hops_fee_msat)); aggregate_next_hops_fee_msat = if let Some(val) = hops_fee { val } else { break; }; - let hop_htlc_minimum_msat = candidate.htlc_minimum_msat(); - let hop_htlc_minimum_msat_inc = if let Some(val) = compute_fees(aggregate_next_hops_path_htlc_minimum_msat, hop.fees) { val } else { break; }; - let hops_path_htlc_minimum = aggregate_next_hops_path_htlc_minimum_msat - .checked_add(hop_htlc_minimum_msat_inc); - aggregate_next_hops_path_htlc_minimum_msat = if let Some(val) = hops_path_htlc_minimum { cmp::max(hop_htlc_minimum_msat, val) } else { break; }; + // The next channel will need to relay this channel's min_htlc *plus* the fees taken by + // this route hint's source node to forward said min over this channel. + aggregate_next_hops_path_htlc_minimum_msat = { + let curr_htlc_min = cmp::max( + candidate.htlc_minimum_msat(), aggregate_next_hops_path_htlc_minimum_msat + ); + let curr_htlc_min_fee = if let Some(val) = compute_fees(curr_htlc_min, hop.fees) { val } else { break }; + if let Some(min) = curr_htlc_min.checked_add(curr_htlc_min_fee) { min } else { break } + }; if idx == route.0.len() - 1 { // The last hop in this iterator is the first hop in @@ -1903,12 +2254,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 +2301,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; + } } } } @@ -2002,8 +2358,8 @@ where L::Target: Logger { // recompute the fees again, so that if that's the case, we match the currently // underpaid htlc_minimum_msat with fees. debug_assert_eq!(payment_path.get_value_msat(), value_contribution_msat); - value_contribution_msat = cmp::min(value_contribution_msat, final_value_msat); - payment_path.update_value_and_recompute_fees(value_contribution_msat); + let desired_value_contribution = cmp::min(value_contribution_msat, final_value_msat); + value_contribution_msat = payment_path.update_value_and_recompute_fees(desired_value_contribution); // Since a path allows to transfer as much value as // the smallest channel it has ("bottleneck"), we should recompute @@ -2019,8 +2375,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 +2392,13 @@ 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 @@ -2100,11 +2458,24 @@ where L::Target: Logger { log_trace!(logger, "Collected exactly our payment amount on the first pass, without hitting an htlc_minimum_msat limit, exiting."); break 'paths_collection; } - log_trace!(logger, "Collected our payment amount on the first pass, but running again to collect extra paths with a potentially higher limit."); + log_trace!(logger, "Collected our payment amount on the first pass, but running again to collect extra paths with a potentially higher value to meet htlc_minimum_msat limit."); path_value_msat = recommended_value_msat; } } + let num_ignored_total = num_ignored_value_contribution + num_ignored_path_length_limit + + num_ignored_cltv_delta_limit + num_ignored_previously_failed + + num_ignored_avoid_overpayment + num_ignored_htlc_minimum_msat_limit + + num_ignored_total_fee_limit; + 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, {} due to htlc_minimum_msat limit, {} to avoid overpaying, {} due to maximum total fee limit. Total: {} ignored candidates.", + num_ignored_value_contribution, num_ignored_path_length_limit, + num_ignored_cltv_delta_limit, num_ignored_previously_failed, + num_ignored_htlc_minimum_msat_limit, num_ignored_avoid_overpayment, + num_ignored_total_fee_limit, 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 +2539,97 @@ 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()); + let mut prev_hop_node_id = our_node_id; + for (hop, node_features) in payment_path.hops.iter() + .filter(|(h, _)| h.candidate.short_channel_id().is_some()) + { + let maybe_announced_channel = if let CandidateRouteHop::PublicHop { .. } = hop.candidate { + // If we sourced the hop from the graph we're sure the target node is announced. + true + } else if let CandidateRouteHop::FirstHop { details } = hop.candidate { + // If this is a first hop we also know if it's announced. + details.is_public + } else { + // If we sourced it any other way, we double-check the network graph to see if + // there are announced channels between the endpoints. If so, the hop might be + // referring to any of the announced channels, as its `short_channel_id` might be + // an alias, in which case we don't take any chances here. + network_graph.node(&hop.node_id).map_or(false, |hop_node| + hop_node.channels.iter().any(|scid| network_graph.channel(*scid) + .map_or(false, |c| c.as_directed_from(&prev_hop_node_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(), + maybe_announced_channel, + }); + + prev_hop_node_id = hop.node_id; + } + 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(); - } + // Make sure we would never create a route whose total fees exceed max_total_routing_fee_msat. + if let Some(max_total_routing_fee_msat) = route_params.max_total_routing_fee_msat { + if paths.iter().map(|p| p.fee_msat()).sum::() > max_total_routing_fee_msat { + return Err(LightningError{err: format!("Failed to find route that adheres to the maximum total fee limit of {}msat", + max_total_routing_fee_msat), action: ErrorAction::IgnoreError}); } } - 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 }); + if let Some(node_features) = payment_params.payee.node_features() { + for path in paths.iter_mut() { + path.hops.last_mut().unwrap().node_features = node_features.clone(); + } } - let route = Route { - paths, - payment_params: Some(payment_params.clone()), - }; + + let route = Route { paths, route_params: Some(route_params.clone()) }; log_info!(logger, "Got route: {}", log_route!(route)); Ok(route) } @@ -2329,17 +2734,15 @@ pub fn build_route_from_hops( ) -> Result where L::Target: Logger, GL::Target: Logger { let graph_lock = network_graph.read_only(); - let mut route = build_route_from_hops_internal( - our_node_pubkey, hops, &route_params.payment_params, &graph_lock, - route_params.final_value_msat, logger, random_seed_bytes)?; + let mut route = build_route_from_hops_internal(our_node_pubkey, hops, &route_params, + &graph_lock, logger, random_seed_bytes)?; add_random_cltv_offset(&mut route, &route_params.payment_params, &graph_lock, random_seed_bytes); Ok(route) } fn build_route_from_hops_internal( - our_node_pubkey: &PublicKey, hops: &[PublicKey], payment_params: &PaymentParameters, - network_graph: &ReadOnlyNetworkGraph, final_value_msat: u64, logger: L, - random_seed_bytes: &[u8; 32] + our_node_pubkey: &PublicKey, hops: &[PublicKey], route_params: &RouteParameters, + network_graph: &ReadOnlyNetworkGraph, logger: L, random_seed_bytes: &[u8; 32], ) -> Result where L::Target: Logger { struct HopScorer { @@ -2347,7 +2750,7 @@ fn build_route_from_hops_internal( hop_ids: [Option; MAX_PATH_LENGTH_ESTIMATE as usize], } - impl Score for HopScorer { + impl ScoreLookUp for HopScorer { type ScoreParams = (); fn channel_penalty_msat(&self, _short_channel_id: u64, source: &NodeId, target: &NodeId, _usage: ChannelUsage, _score_params: &Self::ScoreParams) -> u64 @@ -2365,14 +2768,6 @@ fn build_route_from_hops_internal( } u64::max_value() } - - fn payment_path_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - - fn payment_path_successful(&mut self, _path: &Path) {} - - fn probe_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - - fn probe_successful(&mut self, _path: &Path) {} } impl<'a> Writeable for HopScorer { @@ -2394,8 +2789,7 @@ fn build_route_from_hops_internal( let scorer = HopScorer { our_node_id, hop_ids }; - get_route(our_node_pubkey, payment_params, network_graph, None, final_value_msat, - logger, &scorer, &(), random_seed_bytes) + get_route(our_node_pubkey, route_params, network_graph, None, logger, &scorer, &Default::default(), random_seed_bytes) } #[cfg(test)] @@ -2405,14 +2799,16 @@ mod tests { use crate::routing::utxo::UtxoResult; use crate::routing::router::{get_route, build_route_from_hops_internal, add_random_cltv_offset, default_node_features, BlindedTail, InFlightHtlcs, Path, PaymentParameters, Route, RouteHint, RouteHintHop, RouteHop, RoutingFees, - DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE}; - use crate::routing::scoring::{ChannelUsage, FixedPenaltyScorer, Score, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE, RouteParameters}; + use crate::routing::scoring::{ChannelUsage, FixedPenaltyScorer, ScoreLookUp, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; 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::ChannelId; + 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; @@ -2441,7 +2837,7 @@ mod tests { fn get_channel_details(short_channel_id: Option, node_id: PublicKey, features: InitFeatures, outbound_capacity_msat: u64) -> channelmanager::ChannelDetails { channelmanager::ChannelDetails { - channel_id: [0; 32], + channel_id: ChannelId::new_zero(), counterparty: channelmanager::ChannelCounterparty { features, node_id, @@ -2457,9 +2853,9 @@ mod tests { inbound_scid_alias: None, channel_value_satoshis: 0, user_channel_id: 0, - 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 +2866,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), } } @@ -2485,11 +2882,17 @@ mod tests { // Simple route to 2 via 1 - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 0, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Cannot send a payment of 0 msat"); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 0); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Cannot send a payment of 0 msat"); } else { panic!(); } - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -2520,12 +2923,15 @@ mod tests { let our_chans = vec![get_channel_details(Some(2), our_id, InitFeatures::from_le_bytes(vec![0b11]), 100000)]; - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = - get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "First hop cannot have our_node_pubkey as a destination."); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "First hop cannot have our_node_pubkey as a destination."); } else { panic!(); } - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); } @@ -2633,8 +3039,12 @@ mod tests { }); // Not possible to send 199_999_999, because the minimum on channel=2 is 200_000_000. - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 199_999_999, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a path to the given destination"); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 199_999_999); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!(); } // Lift the restriction on the first hop. @@ -2652,7 +3062,8 @@ mod tests { }); // A payment above the minimum should pass - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 199_999_999, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); } @@ -2734,7 +3145,11 @@ mod tests { excess_data: Vec::new() }); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 60_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 60_000); + route_params.max_total_routing_fee_msat = Some(15_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); // Overpay fees to hit htlc_minimum_msat. let overpaid_fees = route.paths[0].hops[0].fee_msat + route.paths[1].hops[0].fee_msat; // TODO: this could be better balanced to overpay 10k and not 15k. @@ -2779,14 +3194,17 @@ mod tests { excess_data: Vec::new() }); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 60_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); // Fine to overpay for htlc_minimum_msat if it allows us to save fee. assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops[0].short_channel_id, 12); let fees = route.paths[0].hops[0].fee_msat; assert_eq!(fees, 5_000); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 50_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 50_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); // Not fine to overpay for htlc_minimum_msat if it requires paying more than fee on // the other channel. assert_eq!(route.paths.len(), 1); @@ -2831,13 +3249,19 @@ mod tests { }); // If all the channels require some features we don't understand, route should fail - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a path to the given destination"); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!(); } // If we specify a channel to node7, that overrides our local channel view and that gets used - let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), + InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; + let route = get_route(&our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, nodes[7]); @@ -2872,13 +3296,19 @@ mod tests { add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[7], unknown_features.clone(), 1); // If all nodes require some features we don't understand, route should fail - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a path to the given destination"); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!(); } // If we specify a channel to node7, that overrides our local channel view and that gets used - let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), + InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; + let route = get_route(&our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, nodes[7]); @@ -2910,7 +3340,9 @@ mod tests { // Route to 1 via 2 and 3 because our channel to 1 is disabled let payment_params = PaymentParameters::from_node_id(nodes[0], 42); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 3); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -2936,8 +3368,12 @@ mod tests { // If we specify a channel to node7, that overrides our local channel view and that gets used let payment_params = PaymentParameters::from_node_id(nodes[2], 42); - let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let our_chans = vec![get_channel_details(Some(42), nodes[7].clone(), + InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; + let route = get_route(&our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, nodes[7]); @@ -3059,14 +3495,21 @@ mod tests { let mut invalid_last_hops = last_hops_multi_private_channels(&nodes); invalid_last_hops.push(invalid_last_hop); { - let payment_params = PaymentParameters::from_node_id(nodes[6], 42).with_route_hints(invalid_last_hops).unwrap(); - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Route hint cannot have the payee as the source."); + let payment_params = PaymentParameters::from_node_id(nodes[6], 42) + .with_route_hints(invalid_last_hops).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &network_graph.read_only(), None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Route hint cannot have the payee as the source."); } else { panic!(); } } - let payment_params = PaymentParameters::from_node_id(nodes[6], 42).with_route_hints(last_hops_multi_private_channels(&nodes)).unwrap(); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[6], 42) + .with_route_hints(last_hops_multi_private_channels(&nodes)).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 5); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3141,8 +3584,9 @@ mod tests { let random_seed_bytes = keys_manager.get_secure_random_bytes(); // Test handling of an empty RouteHint passed in Invoice. - - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 5); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3248,7 +3692,9 @@ mod tests { excess_data: Vec::new() }); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 4); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3320,7 +3766,9 @@ mod tests { excess_data: Vec::new() }); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &[42u8; 32]).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &[42u8; 32]).unwrap(); assert_eq!(route.paths[0].hops.len(), 4); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3402,7 +3850,9 @@ mod tests { // This test shows that public routes can be present in the invoice // which would be handled in the same manner. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 5); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3454,8 +3904,12 @@ mod tests { // Simple test with outbound channel to 4 to test that last_hops and first_hops connect let our_chans = vec![get_channel_details(Some(42), nodes[3].clone(), InitFeatures::from_le_bytes(vec![0b11]), 250_000_000)]; let mut last_hops = last_hops(&nodes); - let payment_params = PaymentParameters::from_node_id(nodes[6], 42).with_route_hints(last_hops.clone()).unwrap(); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[6], 42) + .with_route_hints(last_hops.clone()).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, nodes[3]); @@ -3475,8 +3929,12 @@ mod tests { last_hops[0].0[0].fees.base_msat = 1000; // Revert to via 6 as the fee on 8 goes up - let payment_params = PaymentParameters::from_node_id(nodes[6], 42).with_route_hints(last_hops).unwrap(); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[6], 42) + .with_route_hints(last_hops).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 4); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3510,7 +3968,9 @@ mod tests { assert_eq!(route.paths[0].hops[3].channel_features.le_flags(), &Vec::::new()); // We can't learn any flags from invoices, sadly // ...but still use 8 for larger payments as 6 has a variable feerate - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 2000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 2000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths[0].hops.len(), 5); assert_eq!(route.paths[0].hops[0].pubkey, nodes[1]); @@ -3575,8 +4035,10 @@ mod tests { let random_seed_bytes = keys_manager.get_secure_random_bytes(); let logger = ln_test_utils::TestLogger::new(); let network_graph = NetworkGraph::new(Network::Testnet, &logger); - let route = get_route(&source_node_id, &payment_params, &network_graph.read_only(), - Some(&our_chans.iter().collect::>()), route_val, &logger, &scorer, &(), &random_seed_bytes); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, route_val); + let route = get_route(&source_node_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), &logger, &scorer, &Default::default(), + &random_seed_bytes); route } @@ -3628,7 +4090,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); @@ -3697,15 +4159,21 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 250_000_001); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 250_000_001, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route an exact amount we have should be fine. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 250_000_000, Arc::clone(&logger), &scorer, &(),&random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 250_000_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let path = route.paths.last().unwrap(); assert_eq!(path.hops.len(), 2); @@ -3733,15 +4201,23 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 200_000_001); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 200_000_001, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route an exact amount we have should be fine. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&our_chans.iter().collect::>()), 200_000_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 200_000_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), + Some(&our_chans.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let path = route.paths.last().unwrap(); assert_eq!(path.hops.len(), 2); @@ -3780,15 +4256,21 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 15_001); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 15_001, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route an exact amount we have should be fine. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 15_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 15_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let path = route.paths.last().unwrap(); assert_eq!(path.hops.len(), 2); @@ -3851,15 +4333,21 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 15_001); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 15_001, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route an exact amount we have should be fine. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 15_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 15_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let path = route.paths.last().unwrap(); assert_eq!(path.hops.len(), 2); @@ -3883,15 +4371,21 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 10_001); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 10_001, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route an exact amount we have should be fine. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 10_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 10_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let path = route.paths.last().unwrap(); assert_eq!(path.hops.len(), 2); @@ -3995,15 +4489,21 @@ mod tests { }); { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 60_000); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 60_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route 49 sats (just a bit below the capacity). - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 49_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 49_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let mut total_amount_paid_msat = 0; for path in &route.paths { @@ -4016,7 +4516,10 @@ mod tests { { // Attempt to route an exact amount is also fine - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 50_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 50_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let mut total_amount_paid_msat = 0; for path in &route.paths { @@ -4064,7 +4567,10 @@ mod tests { }); { - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 50_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 50_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let mut total_amount_paid_msat = 0; for path in &route.paths { @@ -4078,14 +4584,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). @@ -4177,9 +4735,11 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 300_000); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 300_000, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { + &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) { assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } @@ -4187,9 +4747,11 @@ mod tests { { // Attempt to route while setting max_path_count to 0 results in a failure. let zero_payment_params = payment_params.clone().with_max_path_count(0); + let route_params = RouteParameters::from_payment_params_and_value( + zero_payment_params, 100); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &zero_payment_params, &network_graph.read_only(), None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { + &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) { assert_eq!(err, "Can't find a route with no paths allowed."); } else { panic!(); } } @@ -4199,9 +4761,11 @@ mod tests { // This is the case because the minimal_value_contribution_msat would require each path // to account for 1/3 of the total value, which is violated by 2 out of 3 paths. let fail_payment_params = payment_params.clone().with_max_path_count(3); + let route_params = RouteParameters::from_payment_params_and_value( + fail_payment_params, 250_000); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &fail_payment_params, &network_graph.read_only(), None, 250_000, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { + &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) { assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } @@ -4209,13 +4773,19 @@ mod tests { { // Now, attempt to route 250 sats (just a bit below the capacity). // Our algorithm should provide us with these 3 paths. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, - 250_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 250_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); 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); @@ -4223,13 +4793,29 @@ mod tests { { // Attempt to route an exact amount is also fine - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, - 290_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 290_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); 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); @@ -4244,7 +4830,8 @@ mod tests { 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[3], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[3], 42) + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); // We need a route consisting of 3 paths: // From our node to node3 via {node0, node2}, {node7, node2, node4} and {node7, node2}. @@ -4379,16 +4966,22 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 350_000); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 350_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route 300 sats (exact amount we can route). // Our algorithm should provide us with these 3 paths, 100 sats each. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 300_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 300_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 3); let mut total_amount_paid_msat = 0; @@ -4549,7 +5142,10 @@ mod tests { { // Now, attempt to route 180 sats. // Our algorithm should provide us with these 2 paths. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 180_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 180_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); let mut total_value_transferred_msat = 0; @@ -4719,15 +5315,32 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 210_000); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); + } else { panic!(); } + } + + { + // Attempt to route while setting max_total_routing_fee_msat to 149_999 results in a failure. + let route_params = RouteParameters { payment_params: payment_params.clone(), final_value_msat: 200_000, + max_total_routing_fee_msat: Some(149_999) }; if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 210_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route 200 sats (exact amount we can route). - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 200_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters { payment_params: payment_params.clone(), final_value_msat: 200_000, + max_total_routing_fee_msat: Some(150_000) }; + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); let mut total_amount_paid_msat = 0; @@ -4827,7 +5440,10 @@ mod tests { // Get a route for 100 sats and check that we found the MPP route no problem and didn't // overpay at all. - let mut route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100_000); + let mut route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); route.paths.sort_by_key(|path| path.hops[0].short_channel_id); // Paths are manually ordered ordered by SCID, so: @@ -4945,16 +5561,22 @@ mod tests { { // Attempt to route more than available results in a failure. + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 150_000); if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 150_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { - assert_eq!(err, "Failed to find a sufficient route to the given destination"); + &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } { // Now, attempt to route 125 sats (just a bit below the capacity of 3 channels). // Our algorithm should provide us with these 3 paths. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 125_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 125_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 3); let mut total_amount_paid_msat = 0; for path in &route.paths { @@ -4967,7 +5589,10 @@ mod tests { { // Attempt to route without the last small cheap channel - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 90_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 90_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); let mut total_amount_paid_msat = 0; for path in &route.paths { @@ -5106,7 +5731,10 @@ mod tests { { // Now ensure the route flows simply over nodes 1 and 4 to 6. - let route = get_route(&our_id, &payment_params, &network.read_only(), None, 10_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 10_000); + let route = get_route(&our_id, &route_params, &network.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops.len(), 3); @@ -5177,7 +5805,11 @@ mod tests { { // Now, attempt to route 90 sats, which is exactly 90 sats at the last hop, plus the // 200% fee charged channel 13 in the 1-to-2 direction. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 90_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params, 90_000); + route_params.max_total_routing_fee_msat = Some(90_000*2); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops.len(), 2); @@ -5243,7 +5875,11 @@ mod tests { // Now, attempt to route 90 sats, hitting the htlc_minimum on channel 4, but // overshooting the htlc_maximum on channel 2. Thus, we should pick the (absurdly // expensive) channels 12-13 path. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 90_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params, 90_000); + route_params.max_total_routing_fee_msat = Some(90_000*2); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops.len(), 2); @@ -5282,10 +5918,12 @@ mod tests { let random_seed_bytes = keys_manager.get_secure_random_bytes(); { - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[ + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), Some(&[ &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(&config), 200_000), &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(&config), 10_000), - ]), 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + ]), Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops.len(), 1); @@ -5294,10 +5932,12 @@ mod tests { assert_eq!(route.paths[0].hops[0].fee_msat, 100_000); } { - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[ + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), Some(&[ &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(&config), 50_000), &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(&config), 50_000), - ]), 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + ]), Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); assert_eq!(route.paths[0].hops.len(), 1); assert_eq!(route.paths[1].hops.len(), 1); @@ -5320,7 +5960,9 @@ mod tests { // If we have several options above the 3xpayment value threshold, we should pick the // smallest of them, avoiding further fragmenting our available outbound balance to // this node. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), Some(&[ + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), Some(&[ &get_channel_details(Some(2), nodes[0], channelmanager::provided_init_features(&config), 50_000), &get_channel_details(Some(3), nodes[0], channelmanager::provided_init_features(&config), 50_000), &get_channel_details(Some(5), nodes[0], channelmanager::provided_init_features(&config), 50_000), @@ -5329,7 +5971,7 @@ mod tests { &get_channel_details(Some(8), nodes[0], channelmanager::provided_init_features(&config), 50_000), &get_channel_details(Some(9), nodes[0], channelmanager::provided_init_features(&config), 50_000), &get_channel_details(Some(4), nodes[0], channelmanager::provided_init_features(&config), 1_000_000), - ]), 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + ]), Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].hops.len(), 1); @@ -5349,10 +5991,10 @@ mod tests { 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 route = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes - ).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + let route = get_route( &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert_eq!(route.get_total_fees(), 100); @@ -5362,10 +6004,10 @@ mod tests { // Applying a 100 msat penalty to each hop results in taking channels 7 and 10 to nodes[6] // from nodes[2] rather than channel 6, 11, and 8, even though the longer path is cheaper. let scorer = FixedPenaltyScorer::with_penalty(100); - let route = get_route( - &our_id, &payment_params, &network_graph.read_only(), None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes - ).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100); + let route = get_route( &our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert_eq!(route.get_total_fees(), 300); @@ -5381,16 +6023,11 @@ mod tests { impl Writeable for BadChannelScorer { fn write(&self, _w: &mut W) -> Result<(), crate::io::Error> { unimplemented!() } } - impl Score for BadChannelScorer { + impl ScoreLookUp for BadChannelScorer { type ScoreParams = (); fn channel_penalty_msat(&self, short_channel_id: u64, _: &NodeId, _: &NodeId, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { if short_channel_id == self.short_channel_id { u64::max_value() } else { 0 } } - - fn payment_path_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - fn payment_path_successful(&mut self, _path: &Path) {} - fn probe_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - fn probe_successful(&mut self, _path: &Path) {} } struct BadNodeScorer { @@ -5402,16 +6039,11 @@ mod tests { fn write(&self, _w: &mut W) -> Result<(), crate::io::Error> { unimplemented!() } } - impl Score for BadNodeScorer { + impl ScoreLookUp for BadNodeScorer { type ScoreParams = (); fn channel_penalty_msat(&self, _: u64, _: &NodeId, target: &NodeId, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { if *target == self.node_id { u64::max_value() } else { 0 } } - - fn payment_path_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - fn payment_path_successful(&mut self, _path: &Path) {} - fn probe_failed(&mut self, _path: &Path, _short_channel_id: u64) {} - fn probe_successful(&mut self, _path: &Path) {} } #[test] @@ -5425,10 +6057,10 @@ mod tests { 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 route = get_route( - &our_id, &payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes - ).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100); + let route = get_route( &our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert_eq!(route.get_total_fees(), 100); @@ -5437,10 +6069,8 @@ mod tests { // A different path to nodes[6] exists if channel 6 cannot be routed over. let scorer = BadChannelScorer { short_channel_id: 6 }; - let route = get_route( - &our_id, &payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes - ).unwrap(); + let route = get_route( &our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert_eq!(route.get_total_fees(), 300); @@ -5449,14 +6079,12 @@ mod tests { // A path to nodes[6] does not exist if nodes[2] cannot be routed through. let scorer = BadNodeScorer { node_id: NodeId::from_pubkey(&nodes[2]) }; - match get_route( - &our_id, &payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes - ) { - Err(LightningError { err, .. } ) => { - assert_eq!(err, "Failed to find a path to the given destination"); - }, - Ok(_) => panic!("Expected error"), + match get_route( &our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes) { + Err(LightningError { err, .. } ) => { + assert_eq!(err, "Failed to find a path to the given destination"); + }, + Ok(_) => panic!("Expected error"), } } @@ -5467,20 +6095,20 @@ mod tests { RouteHop { pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0, maybe_announced_channel: true, }, RouteHop { pubkey: PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0, maybe_announced_channel: true, }, RouteHop { pubkey: PublicKey::from_slice(&hex::decode("027f31ebc5462c1fdce1b737ecff52d37d75dea43ce11c74d25aa297165faa2007").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 225, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 225, cltv_expiry_delta: 0, maybe_announced_channel: true, }, ], blinded_tail: None }], - payment_params: None, + route_params: None, }; assert_eq!(route.get_total_fees(), 250); @@ -5494,26 +6122,26 @@ mod tests { RouteHop { pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0, maybe_announced_channel: true, }, RouteHop { pubkey: PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0, maybe_announced_channel: true, }, ], blinded_tail: None }, Path { hops: vec![ RouteHop { pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 100, cltv_expiry_delta: 0, maybe_announced_channel: true, }, RouteHop { pubkey: PublicKey::from_slice(&hex::decode("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), - short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0 + short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0, maybe_announced_channel: true, }, ], blinded_tail: None }], - payment_params: None, + route_params: None, }; assert_eq!(route.get_total_fees(), 200); @@ -5525,7 +6153,7 @@ mod tests { // In an earlier version of `Route::get_total_fees` and `Route::get_total_amount`, they // would both panic if the route was completely empty. We test to ensure they return 0 // here, even though its somewhat nonsensical as a route. - let route = Route { paths: Vec::new(), payment_params: None }; + let route = Route { paths: Vec::new(), route_params: None }; assert_eq!(route.get_total_fees(), 0); assert_eq!(route.get_total_amount(), 0); @@ -5545,7 +6173,10 @@ mod tests { .with_max_total_cltv_expiry_delta(feasible_max_total_cltv_delta); let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let route = get_route(&our_id, &feasible_payment_params, &network_graph, None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + feasible_payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert_ne!(path.len(), 0); @@ -5553,7 +6184,10 @@ mod tests { let fail_max_total_cltv_delta = 23; let fail_payment_params = PaymentParameters::from_node_id(nodes[6], 0).with_route_hints(last_hops(&nodes)).unwrap() .with_max_total_cltv_expiry_delta(fail_max_total_cltv_delta); - match get_route(&our_id, &fail_payment_params, &network_graph, None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) + let route_params = RouteParameters::from_payment_params_and_value( + fail_payment_params, 100); + match get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { Err(LightningError { err, .. } ) => { assert_eq!(err, "Failed to find a path to the given destination"); @@ -5578,9 +6212,16 @@ mod tests { // We should be able to find a route initially, and then after we fail a few random // channels eventually we won't be able to any longer. - assert!(get_route(&our_id, &payment_params, &network_graph, None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).is_ok()); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + assert!(get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes).is_ok()); loop { - if let Ok(route) = get_route(&our_id, &payment_params, &network_graph, None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes) { + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + if let Ok(route) = get_route(&our_id, &route_params, &network_graph, None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes) + { for chan in route.paths[0].hops.iter() { assert!(!payment_params.previously_failed_channels.contains(&chan.short_channel_id)); } @@ -5603,15 +6244,19 @@ mod tests { // First check we can actually create a long route on this graph. let feasible_payment_params = PaymentParameters::from_node_id(nodes[18], 0); - let route = get_route(&our_id, &feasible_payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + feasible_payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &random_seed_bytes).unwrap(); let path = route.paths[0].hops.iter().map(|hop| hop.short_channel_id).collect::>(); assert!(path.len() == MAX_PATH_LENGTH_ESTIMATE.into()); // But we can't create a path surpassing the MAX_PATH_LENGTH_ESTIMATE limit. let fail_payment_params = PaymentParameters::from_node_id(nodes[19], 0); - match get_route(&our_id, &fail_payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes) + let route_params = RouteParameters::from_payment_params_and_value( + fail_payment_params, 100); + match get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { Err(LightningError { err, .. } ) => { assert_eq!(err, "Failed to find a path to the given destination"); @@ -5630,7 +6275,10 @@ mod tests { let payment_params = PaymentParameters::from_node_id(nodes[6], 42).with_route_hints(last_hops(&nodes)).unwrap(); let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 1); let cltv_expiry_deltas_before = route.paths[0].hops.iter().map(|h| h.cltv_expiry_delta).collect::>(); @@ -5664,8 +6312,10 @@ mod tests { let keys_manager = ln_test_utils::TestKeysInterface::new(&[4u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); - let mut route = get_route(&our_id, &payment_params, &network_graph, None, 100, - Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 100); + let mut route = get_route(&our_id, &route_params, &network_graph, None, + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes).unwrap(); add_random_cltv_offset(&mut route, &payment_params, &network_graph, &random_seed_bytes); let mut path_plausibility = vec![]; @@ -5729,8 +6379,9 @@ mod tests { let payment_params = PaymentParameters::from_node_id(nodes[3], 0); let hops = [nodes[1], nodes[2], nodes[4], nodes[3]]; - let route = build_route_from_hops_internal(&our_id, &hops, &payment_params, - &network_graph, 100, Arc::clone(&logger), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 100); + let route = build_route_from_hops_internal(&our_id, &hops, &route_params, &network_graph, + Arc::clone(&logger), &random_seed_bytes).unwrap(); let route_hop_pubkeys = route.paths[0].hops.iter().map(|hop| hop.pubkey).collect::>(); assert_eq!(hops.len(), route.paths[0].hops.len()); for (idx, hop_pubkey) in hops.iter().enumerate() { @@ -5777,7 +6428,10 @@ mod tests { let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); // 100,000 sats is less than the available liquidity on each channel, set above. - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100_000_000, Arc::clone(&logger), &scorer, &ProbabilisticScoringFeeParameters::default(), &random_seed_bytes).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100_000_000); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &ProbabilisticScoringFeeParameters::default(), &random_seed_bytes).unwrap(); assert_eq!(route.paths.len(), 2); assert!((route.paths[0].hops[1].short_channel_id == 4 && route.paths[1].hops[1].short_channel_id == 13) || (route.paths[1].hops[1].short_channel_id == 4 && route.paths[0].hops[1].short_channel_id == 13)); @@ -5808,7 +6462,7 @@ mod tests { let params = ProbabilisticScoringFeeParameters::default(); let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); - let features = super::InvoiceFeatures::empty(); + let features = super::Bolt11InvoiceFeatures::empty(); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); } @@ -5878,47 +6532,214 @@ mod tests { // Then check we can get a normal route let payment_params = PaymentParameters::from_node_id(nodes[10], 42); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &scorer_params,&random_seed_bytes); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 100); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &scorer_params, &random_seed_bytes); assert!(route.is_ok()); // Then check that we can't get a route if we ban an intermediate node. scorer_params.add_banned(&NodeId::from_pubkey(&nodes[3])); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &scorer_params,&random_seed_bytes); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &scorer_params, &random_seed_bytes); assert!(route.is_err()); // Finally make sure we can route again, when we remove the ban. scorer_params.remove_banned(&NodeId::from_pubkey(&nodes[3])); - let route = get_route(&our_id, &payment_params, &network_graph.read_only(), None, 100, Arc::clone(&logger), &scorer, &scorer_params,&random_seed_bytes); + let route = get_route(&our_id, &route_params, &network_graph.read_only(), None, + Arc::clone(&logger), &scorer, &scorer_params, &random_seed_bytes); assert!(route.is_ok()); } #[test] - fn blinded_route_ser() { - let blinded_path_1 = BlindedPath { - introduction_node_id: ln_test_utils::pubkey(42), - blinding_point: ln_test_utils::pubkey(43), - blinded_hops: vec![ - BlindedHop { blinded_node_id: ln_test_utils::pubkey(44), encrypted_payload: Vec::new() }, - BlindedHop { blinded_node_id: ln_test_utils::pubkey(45), encrypted_payload: Vec::new() } - ], - }; - let blinded_path_2 = BlindedPath { - introduction_node_id: ln_test_utils::pubkey(46), - blinding_point: ln_test_utils::pubkey(47), - blinded_hops: vec![ - BlindedHop { blinded_node_id: ln_test_utils::pubkey(48), encrypted_payload: Vec::new() }, - BlindedHop { blinded_node_id: ln_test_utils::pubkey(49), encrypted_payload: Vec::new() } - ], - }; - // (De)serialize a Route with 1 blinded path out of two total paths. - let mut route = Route { paths: vec![Path { - hops: vec![RouteHop { - pubkey: ln_test_utils::pubkey(50), - node_features: NodeFeatures::empty(), + 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. + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params, max_htlc_msat + 1); + route_params.max_total_routing_fee_msat = None; + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, + &route_params, &netgraph, None, Arc::clone(&logger), &scorer, &Default::default(), + &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 mut route_params = RouteParameters::from_payment_params_and_value( + payment_params, max_htlc_msat + 1); + route_params.max_total_routing_fee_msat = Some(max_htlc_msat * 2); + let route = get_route(&our_id, &route_params, &netgraph, None, Arc::clone(&logger), + &scorer, &Default::default(), &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_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + let route = get_route(&our_node_id, &route_params, &network_graph.read_only(), + Some(&first_hop.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &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, &route_params, &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &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_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + let route = get_route(&our_node_id, &route_params, &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &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 { + introduction_node_id: ln_test_utils::pubkey(42), + blinding_point: ln_test_utils::pubkey(43), + blinded_hops: vec![ + BlindedHop { blinded_node_id: ln_test_utils::pubkey(44), encrypted_payload: Vec::new() }, + BlindedHop { blinded_node_id: ln_test_utils::pubkey(45), encrypted_payload: Vec::new() } + ], + }; + let blinded_path_2 = BlindedPath { + introduction_node_id: ln_test_utils::pubkey(46), + blinding_point: ln_test_utils::pubkey(47), + blinded_hops: vec![ + BlindedHop { blinded_node_id: ln_test_utils::pubkey(48), encrypted_payload: Vec::new() }, + BlindedHop { blinded_node_id: ln_test_utils::pubkey(49), encrypted_payload: Vec::new() } + ], + }; + // (De)serialize a Route with 1 blinded path out of two total paths. + let mut route = Route { paths: vec![Path { + hops: vec![RouteHop { + pubkey: ln_test_utils::pubkey(50), + node_features: NodeFeatures::empty(), short_channel_id: 42, channel_features: ChannelFeatures::empty(), fee_msat: 100, cltv_expiry_delta: 0, + maybe_announced_channel: true, }], blinded_tail: Some(BlindedTail { hops: blinded_path_1.blinded_hops, @@ -5933,8 +6754,9 @@ mod tests { channel_features: ChannelFeatures::empty(), fee_msat: 100, cltv_expiry_delta: 0, + maybe_announced_channel: true, }], blinded_tail: None }], - payment_params: None, + route_params: None, }; let encoded_route = route.encode(); let decoded_route: Route = Readable::read(&mut Cursor::new(&encoded_route[..])).unwrap(); @@ -5972,6 +6794,7 @@ mod tests { channel_features: ChannelFeatures::empty(), fee_msat: 100, cltv_expiry_delta: 0, + maybe_announced_channel: false, }, RouteHop { pubkey: blinded_path.introduction_node_id, @@ -5980,6 +6803,7 @@ mod tests { channel_features: ChannelFeatures::empty(), fee_msat: 1, cltv_expiry_delta: 0, + maybe_announced_channel: false, }], blinded_tail: Some(BlindedTail { hops: blinded_path.blinded_hops, @@ -6012,6 +6836,7 @@ mod tests { channel_features: ChannelFeatures::empty(), fee_msat: 100, cltv_expiry_delta: 0, + maybe_announced_channel: false, }, RouteHop { pubkey: blinded_path.introduction_node_id, @@ -6020,6 +6845,7 @@ mod tests { channel_features: ChannelFeatures::empty(), fee_msat: 1, cltv_expiry_delta: 0, + maybe_announced_channel: false, } ], blinded_tail: Some(BlindedTail { @@ -6028,7 +6854,7 @@ mod tests { excess_final_cltv_expiry_delta: 0, final_value_msat: 200, }), - }], payment_params: None}; + }], route_params: None}; let payment_params = PaymentParameters::from_node_id(ln_test_utils::pubkey(47), 18); let (_, network_graph, _, _, _) = build_line_graph(); @@ -6036,6 +6862,761 @@ 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 payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), blinded_path.clone())]); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, 1001); + let route = get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &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)]); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 1001); + match get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &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())]); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 1001); + match get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), &scorer, + &Default::default(), &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)]); + let route_params = RouteParameters::from_payment_params_and_value(payment_params, 1001); + match get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), &scorer, + &Default::default(), &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 mut route_params = RouteParameters::from_payment_params_and_value(payment_params, 100_000); + route_params.max_total_routing_fee_msat = Some(100_000); + let route = get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), + &scorer, &Default::default(), &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); + } + + #[test] + fn direct_to_intro_node() { + // This previously caused a debug panic in the router when asserting + // `used_liquidity_msat <= hop_max_msat`, because when adding first_hop<>blinded_route_hint + // direct channels we failed to account for the fee charged for use of the blinded path. + + // Build a graph: + // node0 -1(1)2 - node1 + // such that there isn't enough liquidity to reach node1, but the router thinks there is if it + // doesn't account for the blinded path fee. + + let secp_ctx = Secp256k1::new(); + let logger = Arc::new(ln_test_utils::TestLogger::new()); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger))); + let gossip_sync = P2PGossipSync::new(Arc::clone(&network_graph), None, 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 amt_msat = 10_000_000; + let (_, _, privkeys, nodes) = get_nodes(&secp_ctx); + add_channel(&gossip_sync, &secp_ctx, &privkeys[0], &privkeys[1], + ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 1); + update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { + chain_hash: genesis_block(Network::Testnet).header.block_hash(), + short_channel_id: 1, + timestamp: 1, + flags: 0, + cltv_expiry_delta: 42, + htlc_minimum_msat: 1_000, + htlc_maximum_msat: 10_000_000, + fee_base_msat: 800, + fee_proportional_millionths: 0, + excess_data: Vec::new() + }); + update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { + chain_hash: genesis_block(Network::Testnet).header.block_hash(), + short_channel_id: 1, + timestamp: 1, + flags: 1, + cltv_expiry_delta: 42, + htlc_minimum_msat: 1_000, + htlc_maximum_msat: 10_000_000, + fee_base_msat: 800, + fee_proportional_millionths: 0, + excess_data: Vec::new() + }); + let first_hops = vec![ + get_channel_details(Some(1), nodes[1], InitFeatures::from_le_bytes(vec![0b11]), 10_000_000)]; + + let blinded_path = BlindedPath { + introduction_node_id: nodes[1], + 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 = BlindedPayInfo { + fee_base_msat: 1000, + fee_proportional_millionths: 0, + htlc_minimum_msat: 1000, + htlc_maximum_msat: MAX_VALUE_MSAT, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let blinded_hints = vec![(blinded_payinfo.clone(), blinded_path)]; + + let payment_params = PaymentParameters::blinded(blinded_hints.clone()); + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), amt_msat); + if let Err(LightningError { err, .. }) = get_route(&nodes[0], &route_params, &netgraph, + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes) { + assert_eq!(err, "Failed to find a path to the given destination"); + } else { panic!("Expected error") } + + // Sending an exact amount accounting for the blinded path fee works. + let amt_minus_blinded_path_fee = amt_msat - blinded_payinfo.fee_base_msat as u64; + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_minus_blinded_path_fee); + let route = get_route(&nodes[0], &route_params, &netgraph, + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); + assert_eq!(route.get_total_fees(), blinded_payinfo.fee_base_msat as u64); + assert_eq!(route.get_total_amount(), amt_minus_blinded_path_fee); + } + + #[test] + fn direct_to_matching_intro_nodes() { + // This previously caused us to enter `unreachable` code in the following situation: + // 1. We add a route candidate for intro_node contributing a high amount + // 2. We add a first_hop<>intro_node route candidate for the same high amount + // 3. We see a cheaper blinded route hint for the same intro node but a much lower contribution + // amount, and update our route candidate for intro_node for the lower amount + // 4. We then attempt to update the aforementioned first_hop<>intro_node route candidate for the + // lower contribution amount, but fail (this was previously caused by failure to account for + // blinded path fees when adding first_hop<>intro_node candidates) + // 5. We go to construct the path from these route candidates and our first_hop<>intro_node + // candidate still thinks its path is contributing the original higher amount. This caused us + // to hit an `unreachable` overflow when calculating the cheaper intro_node fees over the + // larger amount + let secp_ctx = Secp256k1::new(); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 21_7020_5185_1403_2640; + let (_, _, _, nodes) = get_nodes(&secp_ctx); + let first_hops = vec![ + get_channel_details(Some(1), nodes[1], channelmanager::provided_init_features(&config), + 18446744073709551615)]; + + let blinded_path = BlindedPath { + introduction_node_id: nodes[1], + 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 = BlindedPayInfo { + fee_base_msat: 5046_2720, + fee_proportional_millionths: 0, + htlc_minimum_msat: 4503_5996_2737_0496, + htlc_maximum_msat: 45_0359_9627_3704_9600, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let mut blinded_hints = vec![ + (blinded_payinfo.clone(), blinded_path.clone()), + (blinded_payinfo.clone(), blinded_path.clone()), + ]; + blinded_hints[1].0.fee_base_msat = 419_4304; + blinded_hints[1].0.fee_proportional_millionths = 257; + blinded_hints[1].0.htlc_minimum_msat = 280_8908_6115_8400; + blinded_hints[1].0.htlc_maximum_msat = 2_8089_0861_1584_0000; + blinded_hints[1].0.cltv_expiry_delta = 0; + + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let payment_params = PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + let route = get_route(&nodes[0], &route_params, &netgraph, + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); + assert_eq!(route.get_total_fees(), blinded_payinfo.fee_base_msat as u64); + assert_eq!(route.get_total_amount(), amt_msat); + } + + #[test] + fn we_are_intro_node_candidate_hops() { + // This previously led to a panic in the router because we'd generate a Path with only a + // BlindedTail and 0 unblinded hops, due to the only candidate hops being blinded route hints + // where the origin node is the intro node. We now fully disallow considering candidate hops + // where the origin node is the intro node. + let (secp_ctx, network_graph, _, _, logger) = build_graph(); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 21_7020_5185_1423_0019; + + let blinded_path = BlindedPath { + introduction_node_id: our_id, + 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 = BlindedPayInfo { + fee_base_msat: 5052_9027, + fee_proportional_millionths: 0, + htlc_minimum_msat: 21_7020_5185_1423_0019, + htlc_maximum_msat: 1844_6744_0737_0955_1615, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let mut blinded_hints = vec![ + (blinded_payinfo.clone(), blinded_path.clone()), + (blinded_payinfo.clone(), blinded_path.clone()), + ]; + blinded_hints[1].1.introduction_node_id = nodes[6]; + + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let payment_params = PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + if let Err(LightningError { err, .. }) = get_route( + &our_id, &route_params, &netgraph, None, Arc::clone(&logger), &scorer, &(), &random_seed_bytes + ) { + assert_eq!(err, "Failed to find a path to the given destination"); + } else { panic!() } + } + + #[test] + fn we_are_intro_node_bp_in_final_path_fee_calc() { + // This previously led to a debug panic in the router because we'd find an invalid Path with + // 0 unblinded hops and a blinded tail, leading to the generation of a final + // PaymentPathHop::fee_msat that included both the blinded path fees and the final value of + // the payment, when it was intended to only include the final value of the payment. + let (secp_ctx, network_graph, _, _, logger) = build_graph(); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 21_7020_5185_1423_0019; + + let blinded_path = BlindedPath { + introduction_node_id: our_id, + 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 = BlindedPayInfo { + fee_base_msat: 10_4425_1395, + fee_proportional_millionths: 0, + htlc_minimum_msat: 21_7301_9934_9094_0931, + htlc_maximum_msat: 1844_6744_0737_0955_1615, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let mut blinded_hints = vec![ + (blinded_payinfo.clone(), blinded_path.clone()), + (blinded_payinfo.clone(), blinded_path.clone()), + (blinded_payinfo.clone(), blinded_path.clone()), + ]; + blinded_hints[1].0.fee_base_msat = 5052_9027; + blinded_hints[1].0.htlc_minimum_msat = 21_7020_5185_1423_0019; + blinded_hints[1].0.htlc_maximum_msat = 1844_6744_0737_0955_1615; + + blinded_hints[2].1.introduction_node_id = nodes[6]; + + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let payment_params = PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + if let Err(LightningError { err, .. }) = get_route( + &our_id, &route_params, &netgraph, None, Arc::clone(&logger), &scorer, &(), &random_seed_bytes + ) { + assert_eq!(err, "Failed to find a path to the given destination"); + } else { panic!() } + } + + #[test] + fn min_htlc_overpay_violates_max_htlc() { + do_min_htlc_overpay_violates_max_htlc(true); + do_min_htlc_overpay_violates_max_htlc(false); + } + fn do_min_htlc_overpay_violates_max_htlc(blinded_payee: bool) { + // Test that if overpaying to meet a later hop's min_htlc and causes us to violate an earlier + // hop's max_htlc, we don't consider that candidate hop valid. Previously we would add this hop + // to `targets` and build an invalid path with it, and subsquently hit a debug panic asserting + // that the used liquidity for a hop was less than its available liquidity limit. + let secp_ctx = Secp256k1::new(); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 7_4009_8048; + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let first_hop_outbound_capacity = 2_7345_2000; + let first_hops = vec![get_channel_details( + Some(200), nodes[0], channelmanager::provided_init_features(&config), + first_hop_outbound_capacity + )]; + + let base_fee = 1_6778_3453; + let htlc_min = 2_5165_8240; + let payment_params = if blinded_payee { + let blinded_path = BlindedPath { + introduction_node_id: nodes[0], + 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 = BlindedPayInfo { + fee_base_msat: base_fee, + fee_proportional_millionths: 0, + htlc_minimum_msat: htlc_min, + htlc_maximum_msat: htlc_min * 1000, + cltv_expiry_delta: 0, + features: BlindedHopFeatures::empty(), + }; + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + PaymentParameters::blinded(vec![(blinded_payinfo, blinded_path)]) + .with_bolt12_features(bolt12_features.clone()).unwrap() + } else { + let route_hint = RouteHint(vec![RouteHintHop { + src_node_id: nodes[0], + short_channel_id: 42, + fees: RoutingFees { + base_msat: base_fee, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: Some(htlc_min), + htlc_maximum_msat: None, + }]); + + PaymentParameters::from_node_id(nodes[1], 42) + .with_route_hints(vec![route_hint]).unwrap() + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + }; + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + if let Err(LightningError { err, .. }) = get_route( + &our_id, &route_params, &netgraph, Some(&first_hops.iter().collect::>()), + Arc::clone(&logger), &scorer, &(), &random_seed_bytes + ) { + assert_eq!(err, "Failed to find a path to the given destination"); + } else { panic!() } + } + + #[test] + fn previously_used_liquidity_violates_max_htlc() { + do_previously_used_liquidity_violates_max_htlc(true); + do_previously_used_liquidity_violates_max_htlc(false); + + } + fn do_previously_used_liquidity_violates_max_htlc(blinded_payee: bool) { + // Test that if a candidate first_hop<>route_hint_src_node channel does not have enough + // contribution amount to cover the next hop's min_htlc plus fees, we will not consider that + // candidate. In this case, the candidate does not have enough due to a previous path taking up + // some of its liquidity. Previously we would construct an invalid path and hit a debug panic + // asserting that the used liquidity for a hop was less than its available liquidity limit. + let secp_ctx = Secp256k1::new(); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 52_4288; + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let first_hops = vec![get_channel_details( + Some(161), nodes[0], channelmanager::provided_init_features(&config), 486_4000 + ), get_channel_details( + Some(122), nodes[0], channelmanager::provided_init_features(&config), 179_5000 + )]; + + let base_fees = [0, 425_9840, 0, 0]; + let htlc_mins = [1_4392, 19_7401, 1027, 6_5535]; + let payment_params = if blinded_payee { + let blinded_path = BlindedPath { + introduction_node_id: nodes[0], + 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 mut blinded_hints = Vec::new(); + for (base_fee, htlc_min) in base_fees.iter().zip(htlc_mins.iter()) { + blinded_hints.push((BlindedPayInfo { + fee_base_msat: *base_fee, + fee_proportional_millionths: 0, + htlc_minimum_msat: *htlc_min, + htlc_maximum_msat: htlc_min * 100, + cltv_expiry_delta: 10, + features: BlindedHopFeatures::empty(), + }, blinded_path.clone())); + } + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap() + } else { + let mut route_hints = Vec::new(); + for (idx, (base_fee, htlc_min)) in base_fees.iter().zip(htlc_mins.iter()).enumerate() { + route_hints.push(RouteHint(vec![RouteHintHop { + src_node_id: nodes[0], + short_channel_id: 42 + idx as u64, + fees: RoutingFees { + base_msat: *base_fee, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: Some(*htlc_min), + htlc_maximum_msat: Some(htlc_min * 100), + }])); + } + PaymentParameters::from_node_id(nodes[1], 42) + .with_route_hints(route_hints).unwrap() + .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + }; + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + + let route = get_route( + &our_id, &route_params, &netgraph, Some(&first_hops.iter().collect::>()), + Arc::clone(&logger), &scorer, &(), &random_seed_bytes + ).unwrap(); + assert_eq!(route.paths.len(), 1); + assert_eq!(route.get_total_amount(), amt_msat); + } + + #[test] + fn candidate_path_min() { + // Test that if a candidate first_hop<>network_node channel does not have enough contribution + // amount to cover the next channel's min htlc plus fees, we will not consider that candidate. + // Previously, we were storing RouteGraphNodes with a path_min that did not include fees, and + // would add a connecting first_hop node that did not have enough contribution amount, leading + // to a debug panic upon invalid path construction. + let secp_ctx = Secp256k1::new(); + let logger = Arc::new(ln_test_utils::TestLogger::new()); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger))); + let gossip_sync = P2PGossipSync::new(network_graph.clone(), None, logger.clone()); + let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), network_graph.clone(), logger.clone()); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 7_4009_8048; + let (_, our_id, privkeys, nodes) = get_nodes(&secp_ctx); + let first_hops = vec![get_channel_details( + Some(200), nodes[0], channelmanager::provided_init_features(&config), 2_7345_2000 + )]; + + add_channel(&gossip_sync, &secp_ctx, &privkeys[0], &privkeys[6], ChannelFeatures::from_le_bytes(id_to_feature_flags(6)), 6); + update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { + chain_hash: genesis_block(Network::Testnet).header.block_hash(), + short_channel_id: 6, + timestamp: 1, + flags: 0, + cltv_expiry_delta: (6 << 4) | 0, + htlc_minimum_msat: 0, + htlc_maximum_msat: MAX_VALUE_MSAT, + fee_base_msat: 0, + fee_proportional_millionths: 0, + excess_data: Vec::new() + }); + add_or_update_node(&gossip_sync, &secp_ctx, &privkeys[0], NodeFeatures::from_le_bytes(id_to_feature_flags(1)), 0); + + let htlc_min = 2_5165_8240; + let blinded_hints = vec![ + (BlindedPayInfo { + fee_base_msat: 1_6778_3453, + fee_proportional_millionths: 0, + htlc_minimum_msat: htlc_min, + htlc_maximum_msat: htlc_min * 100, + cltv_expiry_delta: 10, + features: BlindedHopFeatures::empty(), + }, BlindedPath { + introduction_node_id: nodes[0], + 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 bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let payment_params = PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + let netgraph = network_graph.read_only(); + + if let Err(LightningError { err, .. }) = get_route( + &our_id, &route_params, &netgraph, Some(&first_hops.iter().collect::>()), + Arc::clone(&logger), &scorer, &ProbabilisticScoringFeeParameters::default(), + &random_seed_bytes + ) { + assert_eq!(err, "Failed to find a path to the given destination"); + } else { panic!() } + } + + #[test] + fn path_contribution_includes_min_htlc_overpay() { + // Previously, the fuzzer hit a debug panic because we wouldn't include the amount overpaid to + // meet a last hop's min_htlc in the total collected paths value. We now include this value and + // also penalize hops along the overpaying path to ensure that it gets deprioritized in path + // selection, both tested here. + let secp_ctx = Secp256k1::new(); + let logger = Arc::new(ln_test_utils::TestLogger::new()); + let network_graph = Arc::new(NetworkGraph::new(Network::Testnet, Arc::clone(&logger))); + let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), network_graph.clone(), logger.clone()); + 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(); + + // Values are taken from the fuzz input that uncovered this panic. + let amt_msat = 562_0000; + let (_, our_id, _, nodes) = get_nodes(&secp_ctx); + let first_hops = vec![ + get_channel_details( + Some(83), nodes[0], channelmanager::provided_init_features(&config), 2199_0000, + ), + ]; + + let htlc_mins = [49_0000, 1125_0000]; + let payment_params = { + let blinded_path = BlindedPath { + introduction_node_id: nodes[0], + 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 mut blinded_hints = Vec::new(); + for htlc_min in htlc_mins.iter() { + blinded_hints.push((BlindedPayInfo { + fee_base_msat: 0, + fee_proportional_millionths: 0, + htlc_minimum_msat: *htlc_min, + htlc_maximum_msat: *htlc_min * 100, + cltv_expiry_delta: 10, + features: BlindedHopFeatures::empty(), + }, blinded_path.clone())); + } + let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + PaymentParameters::blinded(blinded_hints.clone()) + .with_bolt12_features(bolt12_features.clone()).unwrap() + }; + + let netgraph = network_graph.read_only(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + let route = get_route( + &our_id, &route_params, &netgraph, Some(&first_hops.iter().collect::>()), + Arc::clone(&logger), &scorer, &ProbabilisticScoringFeeParameters::default(), + &random_seed_bytes + ).unwrap(); + assert_eq!(route.paths.len(), 1); + assert_eq!(route.get_total_amount(), amt_msat); + } } #[cfg(all(any(test, ldk_bench), not(feature = "no-std")))] @@ -6047,9 +7628,11 @@ pub(crate) mod bench_utils { use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey}; use crate::chain::transaction::OutPoint; + use crate::routing::scoring::ScoreUpdate; use crate::sign::{EntropySource, KeysManager}; + use crate::ln::ChannelId; use crate::ln::channelmanager::{self, ChannelCounterparty, ChannelDetails}; - use crate::ln::features::InvoiceFeatures; + use crate::ln::features::Bolt11InvoiceFeatures; use crate::routing::gossip::NetworkGraph; use crate::util::config::UserConfig; use crate::util::ser::ReadableArgs; @@ -6101,7 +7684,7 @@ pub(crate) mod bench_utils { #[inline] pub(crate) fn first_hop(node_id: PublicKey) -> ChannelDetails { ChannelDetails { - channel_id: [0; 32], + channel_id: ChannelId::new_zero(), counterparty: ChannelCounterparty { features: channelmanager::provided_init_features(&UserConfig::default()), node_id, @@ -6119,8 +7702,8 @@ pub(crate) mod bench_utils { outbound_scid_alias: None, channel_value_satoshis: 10_000_000_000, user_channel_id: 0, - 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, @@ -6135,11 +7718,12 @@ pub(crate) mod bench_utils { inbound_htlc_maximum_msat: None, config: None, feerate_sat_per_1000_weight: None, + channel_shutdown_state: Some(channelmanager::ChannelShutdownState::NotShuttingDown), } } - pub(crate) fn generate_test_routes(graph: &NetworkGraph<&TestLogger>, scorer: &mut S, - score_params: &S::ScoreParams, features: InvoiceFeatures, mut seed: u64, + 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(); @@ -6161,10 +7745,12 @@ pub(crate) mod bench_utils { 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 amt_msat = starting_amount + seed % 1_000_000; + let route_params = RouteParameters::from_payment_params_and_value( + params.clone(), amt_msat); let path_exists = - get_route(&payer, ¶ms, &graph.read_only(), Some(&[&first_hop]), - amt, &TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok(); + get_route(&payer, &route_params, &graph.read_only(), Some(&[&first_hop]), + &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; @@ -6176,10 +7762,11 @@ pub(crate) mod bench_utils { 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); + let route_params = RouteParameters::from_payment_params_and_value( + params.clone(), score_amt); + let route_res = get_route(&payer, &route_params, &graph.read_only(), + Some(&[&first_hop]), &TestLogger::new(), scorer, score_params, + &random_seed_bytes); if let Ok(route) = route_res { for path in route.paths { if seed & 0x80 == 0 { @@ -6196,7 +7783,7 @@ pub(crate) mod bench_utils { score_amt /= 100; } - route_endpoints.push((first_hop, params, amt)); + route_endpoints.push((first_hop, params, amt_msat)); break; } } @@ -6205,9 +7792,11 @@ pub(crate) mod bench_utils { // 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.retain(|(first_hop, params, amt_msat)| { + let route_params = RouteParameters::from_payment_params_and_value( + params.clone(), *amt_msat); + get_route(&payer, &route_params, &graph.read_only(), Some(&[first_hop]), + &TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok() }); route_endpoints.truncate(route_count); assert_eq!(route_endpoints.len(), route_count); @@ -6218,9 +7807,10 @@ pub(crate) mod bench_utils { #[cfg(ldk_bench)] pub mod benches { use super::*; + use crate::routing::scoring::{ScoreUpdate, ScoreLookUp}; use crate::sign::{EntropySource, KeysManager}; use crate::ln::channelmanager; - use crate::ln::features::InvoiceFeatures; + use crate::ln::features::Bolt11InvoiceFeatures; use crate::routing::gossip::NetworkGraph; use crate::routing::scoring::{FixedPenaltyScorer, ProbabilisticScorer, ProbabilisticScoringFeeParameters, ProbabilisticScoringDecayParameters}; use crate::util::config::UserConfig; @@ -6238,15 +7828,15 @@ pub mod benches { 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(), 0, - "generate_routes_with_zero_penalty_scorer"); + generate_routes(bench, &network_graph, scorer, &Default::default(), + Bolt11InvoiceFeatures::empty(), 0, "generate_routes_with_zero_penalty_scorer"); } 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, &(), + generate_routes(bench, &network_graph, scorer, &Default::default(), channelmanager::provided_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_zero_penalty_scorer"); } @@ -6256,7 +7846,7 @@ pub mod benches { 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(), 0, + generate_routes(bench, &network_graph, scorer, ¶ms, Bolt11InvoiceFeatures::empty(), 0, "generate_routes_with_probabilistic_scorer"); } @@ -6280,9 +7870,45 @@ pub mod benches { "generate_large_mpp_routes_with_probabilistic_scorer"); } - fn generate_routes( + pub fn generate_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let mut params = ProbabilisticScoringFeeParameters::default(); + params.linear_success_probability = false; + let scorer = ProbabilisticScorer::new( + ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); + generate_routes(bench, &network_graph, scorer, ¶ms, + channelmanager::provided_invoice_features(&UserConfig::default()), 0, + "generate_routes_with_nonlinear_probabilistic_scorer"); + } + + pub fn generate_mpp_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let mut params = ProbabilisticScoringFeeParameters::default(); + params.linear_success_probability = false; + let scorer = ProbabilisticScorer::new( + ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); + generate_routes(bench, &network_graph, scorer, ¶ms, + channelmanager::provided_invoice_features(&UserConfig::default()), 0, + "generate_mpp_routes_with_nonlinear_probabilistic_scorer"); + } + + pub fn generate_large_mpp_routes_with_nonlinear_probabilistic_scorer(bench: &mut Criterion) { + let logger = TestLogger::new(); + let network_graph = bench_utils::read_network_graph(&logger).unwrap(); + let mut params = ProbabilisticScoringFeeParameters::default(); + params.linear_success_probability = false; + 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_nonlinear_probabilistic_scorer"); + } + + fn generate_routes( bench: &mut Criterion, graph: &NetworkGraph<&TestLogger>, mut scorer: S, - score_params: &S::ScoreParams, features: InvoiceFeatures, starting_amount: u64, + score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, starting_amount: u64, bench_name: &'static str, ) { let payer = bench_utils::payer_pubkey(); @@ -6296,7 +7922,8 @@ pub mod benches { let mut idx = 0; 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, + let route_params = RouteParameters::from_payment_params_and_value(params.clone(), *amt); + assert!(get_route(&payer, &route_params, &graph.read_only(), Some(&[first_hop]), &DummyLogger{}, &scorer, score_params, &random_seed_bytes).is_ok()); idx += 1; }));