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, Invoice as Bolt12Invoice};
+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<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: Score<ScoreParams = SP>> where
+pub struct DefaultRouter<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>> 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,
score_params: SP
}
-impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: Score<ScoreParams = SP>> DefaultRouter<G, L, S, SP, Sc> where
+impl<G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>> DefaultRouter<G, L, S, SP, Sc> 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 {
}
}
-impl< G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: Score<ScoreParams = SP>> Router for DefaultRouter<G, L, S, SP, Sc> where
+impl< G: Deref<Target = NetworkGraph<L>>, L: Deref, S: Deref, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>> Router for DefaultRouter<G, L, S, SP, Sc> 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<Route, LightningError> {
let random_seed_bytes = {
let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap();
};
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
)
/// 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<Route, LightningError>;
- /// 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<Route, LightningError> {
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<ScoreParams = SP>, S: Deref<Target = Sc>> {
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<ScoreParams = SP>, S: Deref<Target = Sc>> ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> {
/// Initialize a new `ScorerAccountingForInFlightHtlcs`.
pub fn new(scorer: S, inflight_htlcs: &'a InFlightHtlcs) -> Self {
ScorerAccountingForInFlightHtlcs {
}
#[cfg(c_bindings)]
-impl<'a, S: Score> Writeable for ScorerAccountingForInFlightHtlcs<'a, S> {
+impl<'a, SP: Sized, Sc: ScoreLookUp<ScoreParams = SP>, S: Deref<Target = Sc>> Writeable for ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> {
fn write<W: Writer>(&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<ScoreParams = SP>, S: Deref<Target = Sc>> 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
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
}
}
+ /// 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<u64> {
});
/// 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.
}
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),
/// [`BlindedTail`]s are present, then the pubkey of the last [`RouteHop`] in each path must be
/// the same.
pub paths: Vec<Path>,
- /// The `payment_params` parameter passed to [`find_route`].
- /// This is used by `ChannelManager` to track information which may be required for retries,
- /// provided back to you via [`Event::PaymentPathFailed`].
+ /// The `payment_params` parameter passed via [`RouteParameters`] to [`find_route`].
///
- /// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
+ /// This is used by `ChannelManager` to track information which may be required for retries.
pub payment_params: Option<PaymentParameters>,
}
/// Returns the total amount of fees paid on this [`Route`].
///
/// This doesn't include any extra payment made to the recipient, which can happen in excess of
- /// the amount passed to [`find_route`]'s `params.final_value_msat`.
+ /// the amount passed to [`find_route`]'s `route_params.final_value_msat`.
pub fn get_total_fees(&self) -> u64 {
self.paths.iter().map(|path| path.fee_msat()).sum()
}
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),
});
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;
}
}
/// Parameters needed to find a [`Route`].
///
-/// Passed to [`find_route`] and [`build_route_from_hops`], but also provided in
-/// [`Event::PaymentPathFailed`].
-///
-/// [`Event::PaymentPathFailed`]: crate::events::Event::PaymentPathFailed
+/// Passed to [`find_route`] and [`build_route_from_hops`].
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RouteParameters {
/// The parameters of the failed payment path.
impl Readable for RouteParameters {
fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
- _init_and_read_tlv_fields!(reader, {
+ _init_and_read_len_prefixed_tlv_fields!(reader, {
(0, payment_params, (required: ReadableArgs, 0)),
(2, final_value_msat, required),
(4, final_cltv_delta, option),
(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),
});
impl ReadableArgs<u32> for PaymentParameters {
fn read<R: io::Read>(reader: &mut R, default_final_cltv_expiry_delta: u32) -> Result<Self, DecodeError> {
- _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),
+ (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) }
/// [`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(InvoiceFeatures::for_keysend(allow_mpp))
+ .with_bolt11_features(Bolt11InvoiceFeatures::for_keysend(allow_mpp))
.expect("PaymentParameters::from_node_id should always initialize the payee as unblinded")
}
/// [`PaymentParameters::expiry_time`].
pub fn from_bolt12_invoice(invoice: &Bolt12Invoice) -> Self {
Self::blinded(invoice.payment_paths().to_vec())
- .with_bolt12_features(invoice.features().clone()).unwrap()
+ .with_bolt12_features(invoice.invoice_features().clone()).unwrap()
.with_expiry_time(invoice.created_at().as_secs().saturating_add(invoice.relative_expiry().as_secs()))
}
- fn blinded(blinded_route_hints: Vec<(BlindedPayInfo, BlindedPath)>) -> Self {
+ /// 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,
/// [`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<Self, ()> {
+ pub fn with_bolt11_features(self, features: Bolt11InvoiceFeatures) -> Result<Self, ()> {
match self.payee {
Payee::Blinded { .. } => Err(()),
Payee::Clear { route_hints, node_id, final_cltv_expiry_delta, .. } =>
/// does not contain any features.
///
/// [`for_keysend`]: PaymentParameters::for_keysend
- features: Option<InvoiceFeatures>,
+ features: Option<Bolt11InvoiceFeatures>,
/// The minimum CLTV delta at the end of the route. This value must not be zero.
final_cltv_expiry_delta: u32,
},
_ => 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),
}
_ => None,
}
}
- fn bolt11(self) -> Option<InvoiceFeatures> {
+ fn bolt11(self) -> Option<Bolt11InvoiceFeatures> {
match self {
Self::Bolt11(f) => Some(f),
_ => None,
_ => 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)]
cur_hop_fees_msat = self.hops.get(i + 1).unwrap().0.hop_use_fee_msat;
}
- let mut cur_hop = &mut self.hops.get_mut(i).unwrap().0;
+ let cur_hop = &mut self.hops.get_mut(i).unwrap().0;
cur_hop.next_hops_fee_msat = total_fee_paid_msat;
// Overpay in fees if we can't save these funds due to htlc_minimum_msat.
// We try to account for htlc_minimum_msat in scoring (add_entry!), so that nodes don't
" 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)
/// 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
/// 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<L: Deref, GL: Deref, S: Score>(
+pub fn find_route<L: Deref, GL: Deref, S: ScoreLookUp>(
our_node_pubkey: &PublicKey, route_params: &RouteParameters,
network_graph: &NetworkGraph<GL>, first_hops: Option<&[&ChannelDetails]>, logger: L,
scorer: &S, score_params: &S::ScoreParams, random_seed_bytes: &[u8; 32]
Ok(route)
}
-pub(crate) fn get_route<L: Deref, S: Score>(
+pub(crate) fn get_route<L: Deref, S: ScoreLookUp>(
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,
_random_seed_bytes: &[u8; 32]
}
}
},
- _ => 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 {
log_trace!(logger, "Building path from {} to payer {} for value {} msat.",
LoggedPayeePubkey(payment_params.payee.node_id()), our_node_pubkey, final_value_msat);
+ // Remember how many candidates we ignored to allow for some logging afterwards.
+ let mut num_ignored_value_contribution = 0;
+ let mut num_ignored_path_length_limit = 0;
+ let mut num_ignored_cltv_delta_limit = 0;
+ let mut num_ignored_previously_failed = 0;
+
macro_rules! add_entry {
// Adds entry which goes from $src_node_id to $dest_node_id over the $candidate hop.
// $next_hops_fee_msat represents the fees paid for using all the channels *after* this one,
let payment_failed_on_this_channel = scid_opt.map_or(false,
|scid| payment_params.previously_failed_channels.contains(&scid));
+ let should_log_candidate = match $candidate {
+ CandidateRouteHop::FirstHop { .. } => true,
+ CandidateRouteHop::PrivateHop { .. } => true,
+ CandidateRouteHop::Blinded { .. } => true,
+ _ => false,
+ };
+
// If HTLC minimum is larger than the amount we're going to transfer, we shouldn't
// bother considering this channel. If retrying with recommended_value_msat may
// allow us to hit the HTLC minimum limit, set htlc_minimum_limit so that we go
// around again with a higher amount.
- if !contributes_sufficient_value || exceeds_max_path_length ||
- exceeds_cltv_delta_limit || payment_failed_on_this_channel {
- // Path isn't useful, ignore it and move on.
+ if !contributes_sufficient_value {
+ if should_log_candidate {
+ log_trace!(logger, "Ignoring {} due to insufficient value contribution.", LoggedCandidateHop(&$candidate));
+ }
+ num_ignored_value_contribution += 1;
+ } else if exceeds_max_path_length {
+ if should_log_candidate {
+ log_trace!(logger, "Ignoring {} due to exceeding maximum path length limit.", LoggedCandidateHop(&$candidate));
+ }
+ num_ignored_path_length_limit += 1;
+ } else if exceeds_cltv_delta_limit {
+ if should_log_candidate {
+ log_trace!(logger, "Ignoring {} due to exceeding CLTV delta limit.", LoggedCandidateHop(&$candidate));
+ }
+ num_ignored_cltv_delta_limit += 1;
+ } else if payment_failed_on_this_channel {
+ if should_log_candidate {
+ log_trace!(logger, "Ignoring {} due to a failed previous payment attempt.", LoggedCandidateHop(&$candidate));
+ }
+ num_ignored_previously_failed += 1;
} else if may_overpay_to_meet_path_minimum_msat {
hit_minimum_limit = true;
} else if over_path_minimum_msat {
// If a caller provided us with last hops, add them to routing targets. Since this happens
// earlier than general path finding, they will be somewhat prioritized, although currently
// it matters only if the fees are exactly the same.
- let route_hints = match &payment_params.payee {
- Payee::Clear { route_hints, .. } => route_hints,
- _ => return Err(LightningError{err: "Routing to blinded paths isn't supported yet".to_owned(), action: ErrorAction::IgnoreError}),
- };
- for route in route_hints.iter().filter(|route| !route.0.is_empty()) {
+ for (hint_idx, hint) in payment_params.payee.blinded_route_hints().iter().enumerate() {
+ let intro_node_id = NodeId::from_pubkey(&hint.1.introduction_node_id);
+ let have_intro_node_in_graph =
+ // Only add the hops in this route to our candidate set if either
+ // we have a direct channel to the first hop or the first hop is
+ // in the regular network graph.
+ first_hop_targets.get(&intro_node_id).is_some() ||
+ network_nodes.get(&intro_node_id).is_some();
+ if !have_intro_node_in_graph { continue }
+ let candidate = if hint.1.blinded_hops.len() == 1 {
+ CandidateRouteHop::OneHopBlinded { hint, hint_idx }
+ } else { CandidateRouteHop::Blinded { hint, hint_idx } };
+ let mut path_contribution_msat = path_value_msat;
+ if let Some(hop_used_msat) = add_entry!(candidate, intro_node_id, maybe_dummy_payee_node_id,
+ 0, path_contribution_msat, 0, 0_u64, 0, 0)
+ {
+ path_contribution_msat = hop_used_msat;
+ } else { continue }
+ if let Some(first_channels) = first_hop_targets.get_mut(&NodeId::from_pubkey(&hint.1.introduction_node_id)) {
+ sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat,
+ our_node_pubkey);
+ for details in first_channels {
+ let first_hop_candidate = CandidateRouteHop::FirstHop { details };
+ let blinded_path_fee = match compute_fees(path_contribution_msat, candidate.fees()) {
+ Some(fee) => fee,
+ None => continue
+ };
+ add_entry!(first_hop_candidate, our_node_id, intro_node_id, blinded_path_fee,
+ path_contribution_msat, candidate.htlc_minimum_msat(), 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
}
}
+ let num_ignored_total = num_ignored_value_contribution + num_ignored_path_length_limit +
+ num_ignored_cltv_delta_limit + num_ignored_previously_failed;
+ if num_ignored_total > 0 {
+ log_trace!(logger, "Ignored {} candidate hops due to insufficient value contribution, {} due to path length limit, {} due to CLTV delta limit, {} due to previous payment failure. Total: {} ignored candidates.", num_ignored_value_contribution, num_ignored_path_length_limit, num_ignored_cltv_delta_limit, num_ignored_previously_failed, num_ignored_total);
+ }
+
// Step (5).
if payment_paths.len() == 0 {
return Err(LightningError{err: "Failed to find a path to the given destination".to_owned(), action: ErrorAction::IgnoreError});
});
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::<Vec<Result<RouteHop, LightningError>>>::new();
+ let mut paths = Vec::new();
for payment_path in selected_route {
- let mut path = payment_path.hops.iter().filter(|(h, _)| h.candidate.short_channel_id().is_some())
- .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)})?,
- node_features: node_features.clone(),
- short_channel_id: payment_hop.candidate.short_channel_id().unwrap(),
- channel_features: payment_hop.candidate.features(),
- fee_msat: payment_hop.fee_msat,
- cltv_expiry_delta: payment_hop.candidate.cltv_expiry_delta(),
+ let mut hops = Vec::with_capacity(payment_path.hops.len());
+ for (hop, node_features) in payment_path.hops.iter()
+ .filter(|(h, _)| h.candidate.short_channel_id().is_some())
+ {
+ hops.push(RouteHop {
+ pubkey: PublicKey::from_slice(hop.node_id.as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &hop.node_id), action: ErrorAction::IgnoreAndLog(Level::Trace)})?,
+ node_features: node_features.clone(),
+ short_channel_id: hop.candidate.short_channel_id().unwrap(),
+ channel_features: hop.candidate.features(),
+ fee_msat: hop.fee_msat,
+ cltv_expiry_delta: hop.candidate.cltv_expiry_delta(),
+ });
+ }
+ let mut final_cltv_delta = final_cltv_expiry_delta;
+ let blinded_tail = payment_path.hops.last().and_then(|(h, _)| {
+ if let Some(blinded_path) = h.candidate.blinded_path() {
+ final_cltv_delta = h.candidate.cltv_expiry_delta();
+ Some(BlindedTail {
+ hops: blinded_path.blinded_hops.clone(),
+ blinding_point: blinded_path.blinding_point,
+ excess_final_cltv_expiry_delta: 0,
+ final_value_msat: h.fee_msat,
})
- }).collect::<Vec<_>>();
+ } else { None }
+ });
// Propagate the cltv_expiry_delta one hop backwards since the delta from the current hop is
// applicable for the previous hop.
- path.iter_mut().rev().fold(final_cltv_expiry_delta, |prev_cltv_expiry_delta, hop| {
- core::mem::replace(&mut hop.as_mut().unwrap().cltv_expiry_delta, prev_cltv_expiry_delta)
+ hops.iter_mut().rev().fold(final_cltv_delta, |prev_cltv_expiry_delta, hop| {
+ core::mem::replace(&mut hop.cltv_expiry_delta, prev_cltv_expiry_delta)
});
- selected_paths.push(path);
+
+ paths.push(Path { hops, blinded_tail });
}
// Make sure we would never create a route with more paths than we allow.
- debug_assert!(selected_paths.len() <= payment_params.max_path_count.into());
+ debug_assert!(paths.len() <= payment_params.max_path_count.into());
if let Some(node_features) = payment_params.payee.node_features() {
- for path in selected_paths.iter_mut() {
- if let Ok(route_hop) = path.last_mut().unwrap() {
- route_hop.node_features = node_features.clone();
- }
+ for path in paths.iter_mut() {
+ path.hops.last_mut().unwrap().node_features = node_features.clone();
}
}
- let mut paths: Vec<Path> = Vec::new();
- for results_vec in selected_paths {
- let mut hops = Vec::with_capacity(results_vec.len());
- for res in results_vec { hops.push(res?); }
- paths.push(Path { hops, blinded_tail: None });
- }
- let route = Route {
- paths,
- payment_params: Some(payment_params.clone()),
- };
+ let route = Route { paths, payment_params: Some(payment_params.clone()) };
log_info!(logger, "Got route: {}", log_route!(route));
Ok(route)
}
hop_ids: [Option<NodeId>; 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
}
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 {
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};
+ 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;
fn get_channel_details(short_channel_id: Option<u64>, 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,
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_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),
}
}
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);
#[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).
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);
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);
impl Writeable for BadChannelScorer {
fn write<W: Writer>(&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 {
fn write<W: Writer>(&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]
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);
}
assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat);
assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat);
assert_eq!(route.get_total_amount(), amt_msat);
+
+ // Make sure this works for blinded route hints.
+ let blinded_path = BlindedPath {
+ introduction_node_id: intermed_node_id,
+ blinding_point: ln_test_utils::pubkey(42),
+ blinded_hops: vec![
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(42), encrypted_payload: vec![] },
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(43), encrypted_payload: vec![] },
+ ],
+ };
+ let blinded_payinfo = BlindedPayInfo {
+ fee_base_msat: 100,
+ fee_proportional_millionths: 0,
+ htlc_minimum_msat: 1,
+ htlc_maximum_msat: max_htlc_msat,
+ cltv_expiry_delta: 10,
+ features: BlindedHopFeatures::empty(),
+ };
+ let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context();
+ let payment_params = PaymentParameters::blinded(vec![
+ (blinded_payinfo.clone(), blinded_path.clone()),
+ (blinded_payinfo.clone(), blinded_path.clone())])
+ .with_bolt12_features(bolt12_features).unwrap();
+ let route = get_route(&our_node_id, &payment_params, &network_graph.read_only(),
+ Some(&first_hops.iter().collect::<Vec<_>>()), amt_msat, Arc::clone(&logger), &scorer, &(),
+ &random_seed_bytes).unwrap();
+ assert_eq!(route.paths.len(), 2);
+ assert!(route.paths[0].hops.last().unwrap().fee_msat <= max_htlc_msat);
+ assert!(route.paths[1].hops.last().unwrap().fee_msat <= max_htlc_msat);
+ assert_eq!(route.get_total_amount(), amt_msat);
}
#[test]
assert_eq!(route.paths[0].blinded_tail.as_ref().unwrap().excess_final_cltv_expiry_delta, 40);
assert_eq!(route.paths[0].hops.last().unwrap().cltv_expiry_delta, 40);
}
+
+ #[test]
+ fn simple_blinded_route_hints() {
+ do_simple_blinded_route_hints(1);
+ do_simple_blinded_route_hints(2);
+ do_simple_blinded_route_hints(3);
+ }
+
+ fn do_simple_blinded_route_hints(num_blinded_hops: usize) {
+ // Check that we can generate a route to a blinded path with the expected hops.
+ let (secp_ctx, network, _, _, logger) = build_graph();
+ let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+ let network_graph = network.read_only();
+
+ let scorer = ln_test_utils::TestScorer::new();
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let random_seed_bytes = keys_manager.get_secure_random_bytes();
+
+ let mut blinded_path = BlindedPath {
+ introduction_node_id: nodes[2],
+ blinding_point: ln_test_utils::pubkey(42),
+ blinded_hops: Vec::with_capacity(num_blinded_hops),
+ };
+ for i in 0..num_blinded_hops {
+ blinded_path.blinded_hops.push(
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 + i as u8), encrypted_payload: Vec::new() },
+ );
+ }
+ let blinded_payinfo = BlindedPayInfo {
+ fee_base_msat: 100,
+ fee_proportional_millionths: 500,
+ htlc_minimum_msat: 1000,
+ htlc_maximum_msat: 100_000_000,
+ cltv_expiry_delta: 15,
+ features: BlindedHopFeatures::empty(),
+ };
+
+ let final_amt_msat = 1001;
+ let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), blinded_path.clone())]);
+ let route = get_route(&our_id, &payment_params, &network_graph, None, final_amt_msat , Arc::clone(&logger),
+ &scorer, &(), &random_seed_bytes).unwrap();
+ assert_eq!(route.paths.len(), 1);
+ assert_eq!(route.paths[0].hops.len(), 2);
+
+ let tail = route.paths[0].blinded_tail.as_ref().unwrap();
+ assert_eq!(tail.hops, blinded_path.blinded_hops);
+ assert_eq!(tail.excess_final_cltv_expiry_delta, 0);
+ assert_eq!(tail.final_value_msat, 1001);
+
+ let final_hop = route.paths[0].hops.last().unwrap();
+ assert_eq!(final_hop.pubkey, blinded_path.introduction_node_id);
+ if tail.hops.len() > 1 {
+ assert_eq!(final_hop.fee_msat,
+ blinded_payinfo.fee_base_msat as u64 + blinded_payinfo.fee_proportional_millionths as u64 * tail.final_value_msat / 1000000);
+ assert_eq!(final_hop.cltv_expiry_delta, blinded_payinfo.cltv_expiry_delta as u32);
+ } else {
+ assert_eq!(final_hop.fee_msat, 0);
+ assert_eq!(final_hop.cltv_expiry_delta, 0);
+ }
+ }
+
+ #[test]
+ fn blinded_path_routing_errors() {
+ // Check that we can generate a route to a blinded path with the expected hops.
+ let (secp_ctx, network, _, _, logger) = build_graph();
+ let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+ let network_graph = network.read_only();
+
+ let scorer = ln_test_utils::TestScorer::new();
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let random_seed_bytes = keys_manager.get_secure_random_bytes();
+
+ let mut invalid_blinded_path = BlindedPath {
+ introduction_node_id: nodes[2],
+ blinding_point: ln_test_utils::pubkey(42),
+ blinded_hops: vec![
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(43), encrypted_payload: vec![0; 43] },
+ ],
+ };
+ let blinded_payinfo = BlindedPayInfo {
+ fee_base_msat: 100,
+ fee_proportional_millionths: 500,
+ htlc_minimum_msat: 1000,
+ htlc_maximum_msat: 100_000_000,
+ cltv_expiry_delta: 15,
+ features: BlindedHopFeatures::empty(),
+ };
+
+ let mut invalid_blinded_path_2 = invalid_blinded_path.clone();
+ invalid_blinded_path_2.introduction_node_id = ln_test_utils::pubkey(45);
+ let payment_params = PaymentParameters::blinded(vec![
+ (blinded_payinfo.clone(), invalid_blinded_path.clone()),
+ (blinded_payinfo.clone(), invalid_blinded_path_2)]);
+ match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger),
+ &scorer, &(), &random_seed_bytes)
+ {
+ Err(LightningError { err, .. }) => {
+ assert_eq!(err, "1-hop blinded paths must all have matching introduction node ids");
+ },
+ _ => panic!("Expected error")
+ }
+
+ invalid_blinded_path.introduction_node_id = our_id;
+ let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo.clone(), invalid_blinded_path.clone())]);
+ match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger),
+ &scorer, &(), &random_seed_bytes)
+ {
+ Err(LightningError { err, .. }) => {
+ assert_eq!(err, "Cannot generate a route to blinded paths if we are the introduction node to all of them");
+ },
+ _ => panic!("Expected error")
+ }
+
+ invalid_blinded_path.introduction_node_id = ln_test_utils::pubkey(46);
+ invalid_blinded_path.blinded_hops.clear();
+ let payment_params = PaymentParameters::blinded(vec![(blinded_payinfo, invalid_blinded_path)]);
+ match get_route(&our_id, &payment_params, &network_graph, None, 1001, Arc::clone(&logger),
+ &scorer, &(), &random_seed_bytes)
+ {
+ Err(LightningError { err, .. }) => {
+ assert_eq!(err, "0-hop blinded path provided");
+ },
+ _ => panic!("Expected error")
+ }
+ }
+
+ #[test]
+ fn matching_intro_node_paths_provided() {
+ // Check that if multiple blinded paths with the same intro node are provided in payment
+ // parameters, we'll return the correct paths in the resulting MPP route.
+ let (secp_ctx, network, _, _, logger) = build_graph();
+ let (_, our_id, _, nodes) = get_nodes(&secp_ctx);
+ let network_graph = network.read_only();
+
+ let scorer = ln_test_utils::TestScorer::new();
+ let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
+ let random_seed_bytes = keys_manager.get_secure_random_bytes();
+ let config = UserConfig::default();
+
+ let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context();
+ let blinded_path_1 = BlindedPath {
+ introduction_node_id: nodes[2],
+ blinding_point: ln_test_utils::pubkey(42),
+ blinded_hops: vec![
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 as u8), encrypted_payload: Vec::new() },
+ BlindedHop { blinded_node_id: ln_test_utils::pubkey(42 as u8), encrypted_payload: Vec::new() }
+ ],
+ };
+ let blinded_payinfo_1 = BlindedPayInfo {
+ fee_base_msat: 0,
+ fee_proportional_millionths: 0,
+ htlc_minimum_msat: 0,
+ htlc_maximum_msat: 30_000,
+ cltv_expiry_delta: 0,
+ features: BlindedHopFeatures::empty(),
+ };
+
+ let mut blinded_path_2 = blinded_path_1.clone();
+ blinded_path_2.blinding_point = ln_test_utils::pubkey(43);
+ let mut blinded_payinfo_2 = blinded_payinfo_1.clone();
+ blinded_payinfo_2.htlc_maximum_msat = 70_000;
+
+ let blinded_hints = vec![
+ (blinded_payinfo_1.clone(), blinded_path_1.clone()),
+ (blinded_payinfo_2.clone(), blinded_path_2.clone()),
+ ];
+ let payment_params = PaymentParameters::blinded(blinded_hints.clone())
+ .with_bolt12_features(bolt12_features.clone()).unwrap();
+
+ let route = get_route(&our_id, &payment_params, &network_graph, None,
+ 100_000, Arc::clone(&logger), &scorer, &(), &random_seed_bytes).unwrap();
+ assert_eq!(route.paths.len(), 2);
+ let mut total_amount_paid_msat = 0;
+ for path in route.paths.into_iter() {
+ assert_eq!(path.hops.last().unwrap().pubkey, nodes[2]);
+ if let Some(bt) = &path.blinded_tail {
+ assert_eq!(bt.blinding_point,
+ blinded_hints.iter().find(|(p, _)| p.htlc_maximum_msat == path.final_value_msat())
+ .map(|(_, bp)| bp.blinding_point).unwrap());
+ } else { panic!(); }
+ total_amount_paid_msat += path.final_value_msat();
+ }
+ assert_eq!(total_amount_paid_msat, 100_000);
+ }
+
+ #[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();
+ if let Err(LightningError { err, .. }) = get_route(&nodes[0], &payment_params, &netgraph,
+ Some(&first_hops.iter().collect::<Vec<_>>()), amt_msat, Arc::clone(&logger), &scorer, &(),
+ &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 = get_route(&nodes[0], &payment_params, &netgraph,
+ Some(&first_hops.iter().collect::<Vec<_>>()), amt_minus_blinded_path_fee,
+ Arc::clone(&logger), &scorer, &(), &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 = get_route(&nodes[0], &payment_params, &netgraph,
+ Some(&first_hops.iter().collect::<Vec<_>>()), amt_msat,
+ Arc::clone(&logger), &scorer, &(), &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);
+ }
}
#[cfg(all(any(test, ldk_bench), not(feature = "no-std")))]
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;
#[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,
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_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<S: Score>(graph: &NetworkGraph<&TestLogger>, scorer: &mut S,
- score_params: &S::ScoreParams, features: InvoiceFeatures, mut seed: u64,
+ pub(crate) fn generate_test_routes<S: ScoreLookUp + ScoreUpdate>(graph: &NetworkGraph<&TestLogger>, scorer: &mut S,
+ score_params: &S::ScoreParams, features: Bolt11InvoiceFeatures, mut seed: u64,
starting_amount: u64, route_count: usize,
) -> Vec<(ChannelDetails, PaymentParameters, u64)> {
let payer = payer_pubkey();
let amt = starting_amount + seed % 1_000_000;
let path_exists =
get_route(&payer, ¶ms, &graph.read_only(), Some(&[&first_hop]),
- amt, &TestLogger::new(), &scorer, score_params, &random_seed_bytes).is_ok();
+ amt, &TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok();
if path_exists {
// ...and seed the scorer with success and failure data...
seed = seed.overflowing_mul(6364136223846793005).0.overflowing_add(1).0;
.with_bolt11_features(mpp_features).unwrap();
let route_res = get_route(&payer, ¶ms, &graph.read_only(),
- Some(&[&first_hop]), score_amt, &TestLogger::new(), &scorer,
+ Some(&[&first_hop]), score_amt, &TestLogger::new(), scorer,
score_params, &random_seed_bytes);
if let Ok(route) = route_res {
for path in route.paths {
// 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()
+ &TestLogger::new(), scorer, score_params, &random_seed_bytes).is_ok()
});
route_endpoints.truncate(route_count);
assert_eq!(route_endpoints.len(), route_count);
#[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;
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(bench, &network_graph, scorer, &(), Bolt11InvoiceFeatures::empty(), 0,
"generate_routes_with_zero_penalty_scorer");
}
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");
}
"generate_large_mpp_routes_with_probabilistic_scorer");
}
- fn generate_routes<S: Score>(
+ fn generate_routes<S: ScoreLookUp + ScoreUpdate>(
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();
projects / rust-lightning / blobdiff