X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=9423078749d39175790a6f298831048db5482a63;hb=0c677533fc3055163c1768ef2211fbf7317d65ab;hp=940b846bbad024060d437b502d3835b1122788c6;hpb=c480b0c857d0999c12c1c2507a5d8c93592d91cc;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 940b846b..94230787 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -68,7 +68,7 @@ impl< G: Deref>, L: Deref, S: Deref, SP: Sized, Sc: Sco ) -> Result { let random_seed_bytes = { let mut locked_random_seed_bytes = self.random_seed_bytes.lock().unwrap(); - *locked_random_seed_bytes = Sha256::hash(&*locked_random_seed_bytes).into_inner(); + *locked_random_seed_bytes = Sha256::hash(&*locked_random_seed_bytes).to_byte_array(); *locked_random_seed_bytes }; find_route( @@ -90,6 +90,7 @@ pub trait Router { &self, payer: &PublicKey, route_params: &RouteParameters, first_hops: Option<&[&ChannelDetails]>, inflight_htlcs: InFlightHtlcs ) -> Result; + /// 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`] @@ -112,12 +113,12 @@ pub trait Router { /// [`find_route`]. /// /// [`ScoreLookUp`]: crate::routing::scoring::ScoreLookUp -pub struct ScorerAccountingForInFlightHtlcs<'a, SP: Sized, Sc: 'a + ScoreLookUp, S: Deref> { +pub struct ScorerAccountingForInFlightHtlcs<'a, S: Deref> where S::Target: ScoreLookUp { scorer: S, // Maps a channel's short channel id and its direction to the liquidity used up. inflight_htlcs: &'a InFlightHtlcs, } -impl<'a, SP: Sized, Sc: ScoreLookUp, S: Deref> ScorerAccountingForInFlightHtlcs<'a, SP, Sc, S> { +impl<'a, S: Deref> ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: ScoreLookUp { /// Initialize a new `ScorerAccountingForInFlightHtlcs`. pub fn new(scorer: S, inflight_htlcs: &'a InFlightHtlcs) -> Self { ScorerAccountingForInFlightHtlcs { @@ -127,25 +128,29 @@ impl<'a, SP: Sized, Sc: ScoreLookUp, S: Deref> Sc } } -#[cfg(c_bindings)] -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, 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 { +impl<'a, S: Deref> ScoreLookUp for ScorerAccountingForInFlightHtlcs<'a, S> where S::Target: ScoreLookUp { + type ScoreParams = ::ScoreParams; + fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, usage: ChannelUsage, score_params: &Self::ScoreParams) -> u64 { + let target = match candidate.target() { + Some(target) => target, + None => return self.scorer.channel_penalty_msat(candidate, usage, score_params), + }; + let short_channel_id = match candidate.short_channel_id() { + Some(short_channel_id) => short_channel_id, + None => return self.scorer.channel_penalty_msat(candidate, usage, score_params), + }; + let source = candidate.source(); if let Some(used_liquidity) = self.inflight_htlcs.used_liquidity_msat( - source, target, short_channel_id + &source, &target, short_channel_id ) { let usage = ChannelUsage { inflight_htlc_msat: usage.inflight_htlc_msat.saturating_add(used_liquidity), ..usage }; - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage, score_params) + self.scorer.channel_penalty_msat(candidate, usage, score_params) } else { - self.scorer.channel_penalty_msat(short_channel_id, source, target, usage, score_params) + self.scorer.channel_penalty_msat(candidate, usage, score_params) } } } @@ -933,6 +938,10 @@ impl Readable for RouteHint { } /// A channel descriptor for a hop along a payment path. +/// +/// While this generally comes from BOLT 11's `r` field, this struct includes more fields than are +/// available in BOLT 11. Thus, encoding and decoding this via `lightning-invoice` is lossy, as +/// fields not supported in BOLT 11 will be stripped. #[derive(Clone, Debug, Hash, Eq, PartialEq, Ord, PartialOrd)] pub struct RouteHintHop { /// The node_id of the non-target end of the route @@ -959,33 +968,24 @@ impl_writeable_tlv_based!(RouteHintHop, { }); #[derive(Eq, PartialEq)] +#[repr(align(64))] // Force the size to 64 bytes struct RouteGraphNode { node_id: NodeId, - lowest_fee_to_node: u64, - total_cltv_delta: u32, + score: u64, // The maximum value a yet-to-be-constructed payment path might flow through this node. // This value is upper-bounded by us by: // - how much is needed for a path being constructed // - how much value can channels following this node (up to the destination) can contribute, // considering their capacity and fees value_contribution_msat: u64, - /// The effective htlc_minimum_msat at this hop. If a later hop on the path had a higher HTLC - /// minimum, we use it, plus the fees required at each earlier hop to meet it. - path_htlc_minimum_msat: u64, - /// All penalties incurred from this hop on the way to the destination, as calculated using - /// channel scoring. - path_penalty_msat: u64, + total_cltv_delta: u32, /// The number of hops walked up to this node. path_length_to_node: u8, } impl cmp::Ord for RouteGraphNode { fn cmp(&self, other: &RouteGraphNode) -> cmp::Ordering { - let other_score = cmp::max(other.lowest_fee_to_node, other.path_htlc_minimum_msat) - .saturating_add(other.path_penalty_msat); - let self_score = cmp::max(self.lowest_fee_to_node, self.path_htlc_minimum_msat) - .saturating_add(self.path_penalty_msat); - other_score.cmp(&self_score).then_with(|| other.node_id.cmp(&self.node_id)) + other.score.cmp(&self.score).then_with(|| other.node_id.cmp(&self.node_id)) } } @@ -995,46 +995,134 @@ impl cmp::PartialOrd for RouteGraphNode { } } +// While RouteGraphNode can be laid out with fewer bytes, performance appears to be improved +// substantially when it is laid out at exactly 64 bytes. +// +// Thus, we use `#[repr(C)]` on the struct to force a suboptimal layout and check that it stays 64 +// bytes here. +#[cfg(any(ldk_bench, not(any(test, fuzzing))))] +const _GRAPH_NODE_SMALL: usize = 64 - core::mem::size_of::(); +#[cfg(any(ldk_bench, not(any(test, fuzzing))))] +const _GRAPH_NODE_FIXED_SIZE: usize = core::mem::size_of::() - 64; + /// A wrapper around the various hop representations. /// -/// Used to construct a [`PathBuildingHop`] and to estimate [`EffectiveCapacity`]. +/// Can be used to examine the properties of a hop, +/// potentially to decide whether to include it in a route. #[derive(Clone, Debug)] -enum CandidateRouteHop<'a> { +pub enum CandidateRouteHop<'a> { /// A hop from the payer, where the outbound liquidity is known. FirstHop { + /// Channel details of the first hop + /// + /// [`ChannelDetails::get_outbound_payment_scid`] MUST be `Some` (indicating the channel + /// has been funded and is able to pay), and accessor methods may panic otherwise. + /// + /// [`find_route`] validates this prior to constructing a [`CandidateRouteHop`]. details: &'a ChannelDetails, + /// The node id of the payer, which is also the source side of this candidate route hop. + payer_node_id: &'a NodeId, }, - /// A hop found in the [`ReadOnlyNetworkGraph`], where the channel capacity may be unknown. + /// A hop found in the [`ReadOnlyNetworkGraph`]. PublicHop { + /// Information about the channel, including potentially its capacity and + /// direction-specific information. info: DirectedChannelInfo<'a>, + /// The short channel ID of the channel, i.e. the identifier by which we refer to this + /// channel. short_channel_id: u64, }, - /// A hop to the payee found in the BOLT 11 payment invoice, though not necessarily a direct - /// channel. + /// A private hop communicated by the payee, generally via a BOLT 11 invoice. + /// + /// Because BOLT 11 route hints can take multiple hops to get to the destination, this may not + /// terminate at the payee. PrivateHop { + /// Information about the private hop communicated via BOLT 11. hint: &'a RouteHintHop, + /// Node id of the next hop in BOLT 11 route hint. + target_node_id: &'a NodeId }, - /// The payee's identity is concealed behind blinded paths provided in a BOLT 12 invoice. + /// A blinded path which starts with an introduction point and ultimately terminates with the + /// payee. + /// + /// Because we don't know the payee's identity, [`CandidateRouteHop::target`] will return + /// `None` in this state. + /// + /// Because blinded paths are "all or nothing", and we cannot use just one part of a blinded + /// path, the full path is treated as a single [`CandidateRouteHop`]. Blinded { + /// Information about the blinded path including the fee, HTLC amount limits, and + /// cryptographic material required to build an HTLC through the given path. hint: &'a (BlindedPayInfo, BlindedPath), + /// Index of the hint in the original list of blinded hints. + /// + /// This is used to cheaply uniquely identify this blinded path, even though we don't have + /// a short channel ID for this hop. 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`]. + /// Similar to [`Self::Blinded`], but the path here only has one hop. + /// + /// While we treat this similarly to [`CandidateRouteHop::Blinded`] in many respects (e.g. + /// returning `None` from [`CandidateRouteHop::target`]), in this case we do actually know the + /// payee's identity - it's the introduction point! + /// + /// [`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. + /// + /// This primarily exists to track that we need to included a blinded path at the end of our + /// [`Route`], even though it doesn't actually add an additional hop in the payment. OneHopBlinded { + /// Information about the blinded path including the fee, HTLC amount limits, and + /// cryptographic material required to build an HTLC terminating with the given path. + /// + /// Note that the [`BlindedPayInfo`] is ignored here. hint: &'a (BlindedPayInfo, BlindedPath), + /// Index of the hint in the original list of blinded hints. + /// + /// This is used to cheaply uniquely identify this blinded path, even though we don't have + /// a short channel ID for this hop. hint_idx: usize, }, } impl<'a> CandidateRouteHop<'a> { + /// Returns the short channel ID for this hop, if one is known. + /// + /// This SCID could be an alias or a globally unique SCID, and thus is only expected to + /// uniquely identify this channel in conjunction with the [`CandidateRouteHop::source`]. + /// + /// Returns `Some` as long as the candidate is a [`CandidateRouteHop::PublicHop`], a + /// [`CandidateRouteHop::PrivateHop`] from a BOLT 11 route hint, or a + /// [`CandidateRouteHop::FirstHop`] with a known [`ChannelDetails::get_outbound_payment_scid`] + /// (which is always true for channels which are funded and ready for use). + /// + /// In other words, this should always return `Some` as long as the candidate hop is not a + /// [`CandidateRouteHop::Blinded`] or a [`CandidateRouteHop::OneHopBlinded`]. + /// + /// Note that this is deliberately not public as it is somewhat of a footgun because it doesn't + /// define a global namespace. + #[inline] fn short_channel_id(&self) -> Option { match self { - CandidateRouteHop::FirstHop { details } => Some(details.get_outbound_payment_scid().unwrap()), + CandidateRouteHop::FirstHop { details, .. } => details.get_outbound_payment_scid(), CandidateRouteHop::PublicHop { short_channel_id, .. } => Some(*short_channel_id), - CandidateRouteHop::PrivateHop { hint } => Some(hint.short_channel_id), + CandidateRouteHop::PrivateHop { hint, .. } => Some(hint.short_channel_id), + CandidateRouteHop::Blinded { .. } => None, + CandidateRouteHop::OneHopBlinded { .. } => None, + } + } + + /// Returns the globally unique short channel ID for this hop, if one is known. + /// + /// This only returns `Some` if the channel is public (either our own, or one we've learned + /// from the public network graph), and thus the short channel ID we have for this channel is + /// globally unique and identifies this channel in a global namespace. + #[inline] + pub fn globally_unique_short_channel_id(&self) -> Option { + match self { + CandidateRouteHop::FirstHop { details, .. } => if details.is_public { details.short_channel_id } else { None }, + CandidateRouteHop::PublicHop { short_channel_id, .. } => Some(*short_channel_id), + CandidateRouteHop::PrivateHop { .. } => None, CandidateRouteHop::Blinded { .. } => None, CandidateRouteHop::OneHopBlinded { .. } => None, } @@ -1043,7 +1131,7 @@ impl<'a> CandidateRouteHop<'a> { // NOTE: This may alloc memory so avoid calling it in a hot code path. fn features(&self) -> ChannelFeatures { match self { - CandidateRouteHop::FirstHop { details } => details.counterparty.features.to_context(), + CandidateRouteHop::FirstHop { details, .. } => details.counterparty.features.to_context(), CandidateRouteHop::PublicHop { info, .. } => info.channel().features.clone(), CandidateRouteHop::PrivateHop { .. } => ChannelFeatures::empty(), CandidateRouteHop::Blinded { .. } => ChannelFeatures::empty(), @@ -1051,33 +1139,43 @@ impl<'a> CandidateRouteHop<'a> { } } - fn cltv_expiry_delta(&self) -> u32 { + /// Returns the required difference in HTLC CLTV expiry between the [`Self::source`] and the + /// next-hop for an HTLC taking this hop. + /// + /// This is the time that the node(s) in this hop have to claim the HTLC on-chain if the + /// next-hop goes on chain with a payment preimage. + #[inline] + pub fn cltv_expiry_delta(&self) -> u32 { match self { CandidateRouteHop::FirstHop { .. } => 0, CandidateRouteHop::PublicHop { info, .. } => info.direction().cltv_expiry_delta as u32, - CandidateRouteHop::PrivateHop { hint } => hint.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 { + /// Returns the minimum amount that can be sent over this hop, in millisatoshis. + #[inline] + pub fn htlc_minimum_msat(&self) -> u64 { match self { - CandidateRouteHop::FirstHop { details } => details.next_outbound_htlc_minimum_msat, + 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::PrivateHop { hint, .. } => hint.htlc_minimum_msat.unwrap_or(0), CandidateRouteHop::Blinded { hint, .. } => hint.0.htlc_minimum_msat, CandidateRouteHop::OneHopBlinded { .. } => 0, } } - fn fees(&self) -> RoutingFees { + /// Returns the fees that must be paid to route an HTLC over this channel. + #[inline] + pub fn fees(&self) -> RoutingFees { match self { CandidateRouteHop::FirstHop { .. } => RoutingFees { base_msat: 0, proportional_millionths: 0, }, CandidateRouteHop::PublicHop { info, .. } => info.direction().fees, - CandidateRouteHop::PrivateHop { hint } => hint.fees, + CandidateRouteHop::PrivateHop { hint, .. } => hint.fees, CandidateRouteHop::Blinded { hint, .. } => { RoutingFees { base_msat: hint.0.fee_base_msat, @@ -1089,15 +1187,19 @@ impl<'a> CandidateRouteHop<'a> { } } + /// Fetch the effective capacity of this hop. + /// + /// Note that this may be somewhat expensive, so calls to this should be limited and results + /// cached! fn effective_capacity(&self) -> EffectiveCapacity { match self { - CandidateRouteHop::FirstHop { details } => EffectiveCapacity::ExactLiquidity { + CandidateRouteHop::FirstHop { details, .. } => EffectiveCapacity::ExactLiquidity { liquidity_msat: details.next_outbound_htlc_limit_msat, }, CandidateRouteHop::PublicHop { info, .. } => info.effective_capacity(), - CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: Some(max), .. }} => + CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: Some(max), .. }, .. } => EffectiveCapacity::HintMaxHTLC { amount_msat: *max }, - CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: None, .. }} => + CandidateRouteHop::PrivateHop { hint: RouteHintHop { htlc_maximum_msat: None, .. }, .. } => EffectiveCapacity::Infinite, CandidateRouteHop::Blinded { hint, .. } => EffectiveCapacity::HintMaxHTLC { amount_msat: hint.0.htlc_maximum_msat }, @@ -1105,11 +1207,15 @@ impl<'a> CandidateRouteHop<'a> { } } - fn id(&self, channel_direction: bool /* src_node_id < target_node_id */) -> CandidateHopId { + /// Returns an ID describing the given hop. + /// + /// See the docs on [`CandidateHopId`] for when this is, or is not, unique. + #[inline] + fn id(&self) -> 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)), + _ => CandidateHopId::Clear((self.short_channel_id().unwrap(), self.source() < self.target().unwrap())), } } fn blinded_path(&self) -> Option<&'a BlindedPath> { @@ -1120,8 +1226,51 @@ impl<'a> CandidateRouteHop<'a> { _ => None, } } + /// Returns the source node id of current hop. + /// + /// Source node id refers to the node forwarding the HTLC through this hop. + /// + /// For [`Self::FirstHop`] we return payer's node id. + #[inline] + pub fn source(&self) -> NodeId { + match self { + CandidateRouteHop::FirstHop { payer_node_id, .. } => **payer_node_id, + CandidateRouteHop::PublicHop { info, .. } => *info.source(), + CandidateRouteHop::PrivateHop { hint, .. } => hint.src_node_id.into(), + CandidateRouteHop::Blinded { hint, .. } => hint.1.introduction_node_id.into(), + CandidateRouteHop::OneHopBlinded { hint, .. } => hint.1.introduction_node_id.into(), + } + } + /// Returns the target node id of this hop, if known. + /// + /// Target node id refers to the node receiving the HTLC after this hop. + /// + /// For [`Self::Blinded`] we return `None` because the ultimate destination after the blinded + /// path is unknown. + /// + /// For [`Self::OneHopBlinded`] we return `None` because the target is the same as the source, + /// and such a return value would be somewhat nonsensical. + #[inline] + pub fn target(&self) -> Option { + match self { + CandidateRouteHop::FirstHop { details, .. } => Some(details.counterparty.node_id.into()), + CandidateRouteHop::PublicHop { info, .. } => Some(*info.target()), + CandidateRouteHop::PrivateHop { target_node_id, .. } => Some(**target_node_id), + CandidateRouteHop::Blinded { .. } => None, + CandidateRouteHop::OneHopBlinded { .. } => None, + } + } } +/// A unique(ish) identifier for a specific [`CandidateRouteHop`]. +/// +/// For blinded paths, this ID is unique only within a given [`find_route`] call. +/// +/// For other hops, because SCIDs between private channels and public channels can conflict, this +/// isn't guaranteed to be unique at all. +/// +/// For our uses, this is generally fine, but it is not public as it is otherwise a rather +/// difficult-to-use API. #[derive(Clone, Copy, Eq, Hash, Ord, PartialOrd, PartialEq)] enum CandidateHopId { /// Contains (scid, src_node_id < target_node_id) @@ -1163,18 +1312,15 @@ fn iter_equal(mut iter_a: I1, mut iter_b: I2) /// Fee values should be updated only in the context of the whole path, see update_value_and_recompute_fees. /// These fee values are useful to choose hops as we traverse the graph "payee-to-payer". #[derive(Clone)] +#[repr(C)] // Force fields to appear in the order we define them. struct PathBuildingHop<'a> { - // Note that this should be dropped in favor of loading it from CandidateRouteHop, but doing so - // is a larger refactor and will require careful performance analysis. - node_id: NodeId, candidate: CandidateRouteHop<'a>, - fee_msat: u64, - - /// All the fees paid *after* this channel on the way to the destination - next_hops_fee_msat: u64, - /// Fee paid for the use of the current channel (see candidate.fees()). - /// The value will be actually deducted from the counterparty balance on the previous link. - hop_use_fee_msat: u64, + /// If we've already processed a node as the best node, we shouldn't process it again. Normally + /// we'd just ignore it if we did as all channels would have a higher new fee, but because we + /// may decrease the amounts in use as we walk the graph, the actual calculated fee may + /// decrease as well. Thus, we have to explicitly track which nodes have been processed and + /// avoid processing them again. + was_processed: bool, /// Used to compare channels when choosing the for routing. /// Includes paying for the use of a hop and the following hops, as well as /// an estimated cost of reaching this hop. @@ -1186,12 +1332,20 @@ struct PathBuildingHop<'a> { /// All penalties incurred from this channel on the way to the destination, as calculated using /// channel scoring. path_penalty_msat: u64, - /// If we've already processed a node as the best node, we shouldn't process it again. Normally - /// we'd just ignore it if we did as all channels would have a higher new fee, but because we - /// may decrease the amounts in use as we walk the graph, the actual calculated fee may - /// decrease as well. Thus, we have to explicitly track which nodes have been processed and - /// avoid processing them again. - was_processed: bool, + + // The last 16 bytes are on the next cache line by default in glibc's malloc. Thus, we should + // only place fields which are not hot there. Luckily, the next three fields are only read if + // we end up on the selected path, and only in the final path layout phase, so we don't care + // too much if reading them is slow. + + fee_msat: u64, + + /// All the fees paid *after* this channel on the way to the destination + next_hops_fee_msat: u64, + /// Fee paid for the use of the current channel (see candidate.fees()). + /// The value will be actually deducted from the counterparty balance on the previous link. + hop_use_fee_msat: u64, + #[cfg(all(not(ldk_bench), any(test, fuzzing)))] // In tests, we apply further sanity checks on cases where we skip nodes we already processed // to ensure it is specifically in cases where the fee has gone down because of a decrease in @@ -1200,11 +1354,23 @@ struct PathBuildingHop<'a> { value_contribution_msat: u64, } +// Checks that the entries in the `find_route` `dist` map fit in (exactly) two standard x86-64 +// cache lines. Sadly, they're not guaranteed to actually lie on a cache line (and in fact, +// generally won't, because at least glibc's malloc will align to a nice, big, round +// boundary...plus 16), but at least it will reduce the amount of data we'll need to load. +// +// Note that these assertions only pass on somewhat recent rustc, and thus are gated on the +// ldk_bench flag. +#[cfg(ldk_bench)] +const _NODE_MAP_SIZE_TWO_CACHE_LINES: usize = 128 - core::mem::size_of::<(NodeId, PathBuildingHop)>(); +#[cfg(ldk_bench)] +const _NODE_MAP_SIZE_EXACTLY_CACHE_LINES: usize = core::mem::size_of::<(NodeId, PathBuildingHop)>() - 128; + impl<'a> core::fmt::Debug for PathBuildingHop<'a> { fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> { let mut debug_struct = f.debug_struct("PathBuildingHop"); debug_struct - .field("node_id", &self.node_id) + .field("node_id", &self.candidate.target()) .field("short_channel_id", &self.candidate.short_channel_id()) .field("total_fee_msat", &self.total_fee_msat) .field("next_hops_fee_msat", &self.next_hops_fee_msat) @@ -1622,9 +1788,13 @@ where L::Target: Logger { |info| info.features.supports_basic_mpp())) } else { false }; - log_trace!(logger, "Searching for a route from payer {} to {} {} MPP and {} first hops {}overriding the network graph", our_node_pubkey, - LoggedPayeePubkey(payment_params.payee.node_id()), if allow_mpp { "with" } else { "without" }, - first_hops.map(|hops| hops.len()).unwrap_or(0), if first_hops.is_some() { "" } else { "not " }); + let max_total_routing_fee_msat = route_params.max_total_routing_fee_msat.unwrap_or(u64::max_value()); + + log_trace!(logger, "Searching for a route from payer {} to {} {} MPP and {} first hops {}overriding the network graph with a fee limit of {} msat", + our_node_pubkey, LoggedPayeePubkey(payment_params.payee.node_id()), + if allow_mpp { "with" } else { "without" }, + first_hops.map(|hops| hops.len()).unwrap_or(0), if first_hops.is_some() { "" } else { "not " }, + max_total_routing_fee_msat); // Step (1). // Prepare the data we'll use for payee-to-payer search by @@ -1650,6 +1820,20 @@ where L::Target: Logger { } } + let mut private_hop_key_cache = HashMap::with_capacity( + payment_params.payee.unblinded_route_hints().iter().map(|path| path.0.len()).sum() + ); + + // Because we store references to private hop node_ids in `dist`, below, we need them to exist + // (as `NodeId`, not `PublicKey`) for the lifetime of `dist`. Thus, we calculate all the keys + // we'll need here and simply fetch them when routing. + private_hop_key_cache.insert(maybe_dummy_payee_pk, NodeId::from_pubkey(&maybe_dummy_payee_pk)); + for route in payment_params.payee.unblinded_route_hints().iter() { + for hop in route.0.iter() { + private_hop_key_cache.insert(hop.src_node_id, NodeId::from_pubkey(&hop.src_node_id)); + } + } + // The main heap containing all candidate next-hops sorted by their score (max(fee, // htlc_minimum)). Ideally this would be a heap which allowed cheap score reduction instead of // adding duplicate entries when we find a better path to a given node. @@ -1713,20 +1897,20 @@ where L::Target: Logger { 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; + let mut num_ignored_value_contribution: u32 = 0; + let mut num_ignored_path_length_limit: u32 = 0; + let mut num_ignored_cltv_delta_limit: u32 = 0; + let mut num_ignored_previously_failed: u32 = 0; + let mut num_ignored_total_fee_limit: u32 = 0; + let mut num_ignored_avoid_overpayment: u32 = 0; + let mut num_ignored_htlc_minimum_msat_limit: u32 = 0; macro_rules! add_entry { - // Adds entry which goes from $src_node_id to $dest_node_id over the $candidate hop. + // Adds entry which goes from $candidate.source() to $candidate.target() 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 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, + ( $candidate: 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, and how much we can route via @@ -1736,7 +1920,8 @@ where L::Target: Logger { // 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 src_node_id = $candidate.source(); + if Some(src_node_id) != $candidate.target() { 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); @@ -1750,7 +1935,7 @@ where L::Target: Logger { // 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_liquidities - .get(&$candidate.id($src_node_id < $dest_node_id)) + .get(&$candidate.id()) .map_or(0, |used_liquidity_msat| { available_value_contribution_msat = available_value_contribution_msat .saturating_sub(*used_liquidity_msat); @@ -1788,19 +1973,19 @@ where L::Target: Logger { #[allow(unused_comparisons)] // $next_hops_path_htlc_minimum_msat is 0 in some calls so rustc complains let may_overpay_to_meet_path_minimum_msat = ((amount_to_transfer_over_msat < $candidate.htlc_minimum_msat() && - recommended_value_msat > $candidate.htlc_minimum_msat()) || + recommended_value_msat >= $candidate.htlc_minimum_msat()) || (amount_to_transfer_over_msat < $next_hops_path_htlc_minimum_msat && - recommended_value_msat > $next_hops_path_htlc_minimum_msat)); + recommended_value_msat >= $next_hops_path_htlc_minimum_msat)); 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, + let (should_log_candidate, first_hop_details) = match $candidate { + CandidateRouteHop::FirstHop { details, .. } => (true, Some(details)), + CandidateRouteHop::PrivateHop { .. } => (true, None), + CandidateRouteHop::Blinded { .. } => (true, None), + CandidateRouteHop::OneHopBlinded { .. } => (true, None), + _ => (false, None), }; // If HTLC minimum is larger than the amount we're going to transfer, we shouldn't @@ -1810,6 +1995,13 @@ where L::Target: Logger { if !contributes_sufficient_value { if should_log_candidate { log_trace!(logger, "Ignoring {} due to insufficient value contribution.", LoggedCandidateHop(&$candidate)); + + if let Some(details) = first_hop_details { + log_trace!(logger, + "First hop candidate next_outbound_htlc_limit_msat: {}", + details.next_outbound_htlc_limit_msat, + ); + } } num_ignored_value_contribution += 1; } else if exceeds_max_path_length { @@ -1820,6 +2012,14 @@ where L::Target: Logger { } else if exceeds_cltv_delta_limit { if should_log_candidate { log_trace!(logger, "Ignoring {} due to exceeding CLTV delta limit.", LoggedCandidateHop(&$candidate)); + + if let Some(_) = first_hop_details { + log_trace!(logger, + "First hop candidate cltv_expiry_delta: {}. Limit: {}", + hop_total_cltv_delta, + max_total_cltv_expiry_delta, + ); + } } num_ignored_cltv_delta_limit += 1; } else if payment_failed_on_this_channel { @@ -1832,6 +2032,13 @@ where L::Target: Logger { log_trace!(logger, "Ignoring {} to avoid overpaying to meet htlc_minimum_msat limit.", LoggedCandidateHop(&$candidate)); + + if let Some(details) = first_hop_details { + log_trace!(logger, + "First hop candidate next_outbound_htlc_minimum_msat: {}", + details.next_outbound_htlc_minimum_msat, + ); + } } num_ignored_avoid_overpayment += 1; hit_minimum_limit = true; @@ -1845,15 +2052,14 @@ where L::Target: Logger { ); 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 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 // (recall it goes payee-to-payer) of short_channel_id, first add a // semi-dummy record just to compute the fees to reach the source node. // This will affect our decision on selecting short_channel_id - // as a way to reach the $dest_node_id. + // as a way to reach the $candidate.target() node. PathBuildingHop { - node_id: $dest_node_id.clone(), candidate: $candidate.clone(), fee_msat: 0, next_hops_fee_msat: u64::max_value(), @@ -1882,7 +2088,7 @@ where L::Target: Logger { // Ignore hop_use_fee_msat for channel-from-us as we assume all channels-from-us // will have the same effective-fee - if $src_node_id != our_node_id { + if src_node_id != our_node_id { // Note that `u64::max_value` means we'll always fail the // `old_entry.total_fee_msat > total_fee_msat` check below hop_use_fee_msat = compute_fees_saturating(amount_to_transfer_over_msat, $candidate.fees()); @@ -1890,10 +2096,17 @@ where L::Target: Logger { } // 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)); + + if let Some(_) = first_hop_details { + log_trace!(logger, + "First hop candidate routing fee: {}. Limit: {}", + total_fee_msat, + max_total_routing_fee_msat, + ); + } } num_ignored_total_fee_limit += 1; } else { @@ -1902,22 +2115,15 @@ where L::Target: Logger { 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 channel_penalty_msat = + scorer.channel_penalty_msat($candidate, + 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), + // Update the way of reaching $candidate.source() + // with the given short_channel_id (from $candidate.target()), // 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, @@ -1939,11 +2145,17 @@ where L::Target: Logger { .saturating_add(path_penalty_msat); if !old_entry.was_processed && new_cost < old_cost { + let new_graph_node = RouteGraphNode { + node_id: src_node_id, + score: cmp::max(total_fee_msat, path_htlc_minimum_msat).saturating_add(path_penalty_msat), + total_cltv_delta: hop_total_cltv_delta, + value_contribution_msat, + path_length_to_node, + }; 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; @@ -1989,6 +2201,13 @@ where L::Target: Logger { log_trace!(logger, "Ignoring {} due to its htlc_minimum_msat limit.", LoggedCandidateHop(&$candidate)); + + if let Some(details) = first_hop_details { + log_trace!(logger, + "First hop candidate next_outbound_htlc_minimum_msat: {}", + details.next_outbound_htlc_minimum_msat, + ); + } } num_ignored_htlc_minimum_msat_limit += 1; } @@ -2006,28 +2225,38 @@ where L::Target: Logger { // meaning how much will be paid in fees after this node (to the best of our knowledge). // This data can later be helpful to optimize routing (pay lower fees). macro_rules! add_entries_to_cheapest_to_target_node { - ( $node: expr, $node_id: expr, $fee_to_target_msat: expr, $next_hops_value_contribution: expr, - $next_hops_path_htlc_minimum_msat: expr, $next_hops_path_penalty_msat: expr, + ( $node: expr, $node_id: expr, $next_hops_value_contribution: expr, $next_hops_cltv_delta: expr, $next_hops_path_length: expr ) => { + let fee_to_target_msat; + let next_hops_path_htlc_minimum_msat; + let next_hops_path_penalty_msat; let skip_node = if let Some(elem) = dist.get_mut(&$node_id) { let was_processed = elem.was_processed; elem.was_processed = true; + fee_to_target_msat = elem.total_fee_msat; + next_hops_path_htlc_minimum_msat = elem.path_htlc_minimum_msat; + next_hops_path_penalty_msat = elem.path_penalty_msat; was_processed } else { // Entries are added to dist in add_entry!() when there is a channel from a node. // Because there are no channels from payee, it will not have a dist entry at this point. // If we're processing any other node, it is always be the result of a channel from it. debug_assert_eq!($node_id, maybe_dummy_payee_node_id); + fee_to_target_msat = 0; + next_hops_path_htlc_minimum_msat = 0; + next_hops_path_penalty_msat = 0; false }; if !skip_node { if let Some(first_channels) = first_hop_targets.get(&$node_id) { for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { details }; - add_entry!(candidate, our_node_id, $node_id, $fee_to_target_msat, + let candidate = CandidateRouteHop::FirstHop { + details, payer_node_id: &our_node_id, + }; + add_entry!(&candidate, fee_to_target_msat, $next_hops_value_contribution, - $next_hops_path_htlc_minimum_msat, $next_hops_path_penalty_msat, + next_hops_path_htlc_minimum_msat, next_hops_path_penalty_msat, $next_hops_cltv_delta, $next_hops_path_length); } } @@ -2049,11 +2278,11 @@ where L::Target: Logger { info: directed_channel, short_channel_id: *chan_id, }; - add_entry!(candidate, *source, $node_id, - $fee_to_target_msat, + add_entry!(&candidate, + fee_to_target_msat, $next_hops_value_contribution, - $next_hops_path_htlc_minimum_msat, - $next_hops_path_penalty_msat, + next_hops_path_htlc_minimum_msat, + next_hops_path_penalty_msat, $next_hops_cltv_delta, $next_hops_path_length); } } @@ -2079,8 +2308,10 @@ where L::Target: Logger { // place where it could be added. payee_node_id_opt.map(|payee| first_hop_targets.get(&payee).map(|first_channels| { for details in first_channels { - let candidate = CandidateRouteHop::FirstHop { details }; - let added = add_entry!(candidate, our_node_id, payee, 0, path_value_msat, + let candidate = CandidateRouteHop::FirstHop { + details, payer_node_id: &our_node_id, + }; + let added = add_entry!(&candidate, 0, path_value_msat, 0, 0u64, 0, 0).is_some(); log_trace!(logger, "{} direct route to payee via {}", if added { "Added" } else { "Skipped" }, LoggedCandidateHop(&candidate)); @@ -2096,7 +2327,7 @@ where L::Target: Logger { // If not, targets.pop() will not even let us enter the loop in step 2. None => {}, Some(node) => { - add_entries_to_cheapest_to_target_node!(node, payee, 0, path_value_msat, 0, 0u64, 0, 0); + add_entries_to_cheapest_to_target_node!(node, payee, path_value_msat, 0, 0); }, }); @@ -2117,7 +2348,7 @@ where L::Target: Logger { 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, + if let Some(hop_used_msat) = add_entry!(&candidate, 0, path_contribution_msat, 0, 0_u64, 0, 0) { path_contribution_msat = hop_used_msat; @@ -2126,14 +2357,16 @@ where L::Target: Logger { 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 first_hop_candidate = CandidateRouteHop::FirstHop { + details, payer_node_id: &our_node_id, + }; 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, + add_entry!(&first_hop_candidate, 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)); } @@ -2165,8 +2398,7 @@ where L::Target: Logger { 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); - let target = NodeId::from_pubkey(&prev_hop_id); + let target = private_hop_key_cache.get(&prev_hop_id).unwrap(); if let Some(first_channels) = first_hop_targets.get(&target) { if first_channels.iter().any(|d| d.outbound_scid_alias == Some(hop.short_channel_id)) { @@ -2183,9 +2415,9 @@ where L::Target: Logger { info, short_channel_id: hop.short_channel_id, }) - .unwrap_or_else(|| CandidateRouteHop::PrivateHop { hint: hop }); + .unwrap_or_else(|| CandidateRouteHop::PrivateHop { hint: hop, target_node_id: target }); - if let Some(hop_used_msat) = add_entry!(candidate, source, target, + if let Some(hop_used_msat) = add_entry!(&candidate, 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) @@ -2199,7 +2431,7 @@ where L::Target: Logger { } let used_liquidity_msat = used_liquidities - .get(&candidate.id(source < target)).copied() + .get(&candidate.id()).copied() .unwrap_or(0); let channel_usage = ChannelUsage { amount_msat: final_value_msat + aggregate_next_hops_fee_msat, @@ -2207,7 +2439,7 @@ where L::Target: Logger { effective_capacity: candidate.effective_capacity(), }; let channel_penalty_msat = scorer.channel_penalty_msat( - hop.short_channel_id, &source, &target, channel_usage, score_params + &candidate, channel_usage, score_params ); aggregate_next_hops_path_penalty_msat = aggregate_next_hops_path_penalty_msat .saturating_add(channel_penalty_msat); @@ -2223,8 +2455,10 @@ where L::Target: Logger { sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, our_node_pubkey); for details in first_channels { - let first_hop_candidate = CandidateRouteHop::FirstHop { details }; - add_entry!(first_hop_candidate, our_node_id, target, + let first_hop_candidate = CandidateRouteHop::FirstHop { + details, payer_node_id: &our_node_id, + }; + add_entry!(&first_hop_candidate, 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); @@ -2268,9 +2502,10 @@ where L::Target: Logger { sort_first_hop_channels(first_channels, &used_liquidities, recommended_value_msat, our_node_pubkey); for details in first_channels { - let first_hop_candidate = CandidateRouteHop::FirstHop { details }; - add_entry!(first_hop_candidate, our_node_id, - NodeId::from_pubkey(&hop.src_node_id), + let first_hop_candidate = CandidateRouteHop::FirstHop { + details, payer_node_id: &our_node_id, + }; + add_entry!(&first_hop_candidate, aggregate_next_hops_fee_msat, aggregate_path_contribution_msat, aggregate_next_hops_path_htlc_minimum_msat, @@ -2299,7 +2534,7 @@ where L::Target: Logger { // Both these cases (and other cases except reaching recommended_value_msat) mean that // paths_collection will be stopped because found_new_path==false. // This is not necessarily a routing failure. - 'path_construction: while let Some(RouteGraphNode { node_id, lowest_fee_to_node, total_cltv_delta, mut value_contribution_msat, path_htlc_minimum_msat, path_penalty_msat, path_length_to_node, .. }) = targets.pop() { + 'path_construction: while let Some(RouteGraphNode { node_id, total_cltv_delta, mut value_contribution_msat, path_length_to_node, .. }) = targets.pop() { // Since we're going payee-to-payer, hitting our node as a target means we should stop // traversing the graph and arrange the path out of what we found. @@ -2309,10 +2544,13 @@ where L::Target: Logger { 'path_walk: loop { let mut features_set = false; - if let Some(first_channels) = first_hop_targets.get(&ordered_hops.last().unwrap().0.node_id) { + let target = ordered_hops.last().unwrap().0.candidate.target().unwrap_or(maybe_dummy_payee_node_id); + if let Some(first_channels) = first_hop_targets.get(&target) { for details in first_channels { - if let Some(scid) = ordered_hops.last().unwrap().0.candidate.short_channel_id() { - if details.get_outbound_payment_scid().unwrap() == scid { + if let CandidateRouteHop::FirstHop { details: last_hop_details, .. } + = ordered_hops.last().unwrap().0.candidate + { + if details.get_outbound_payment_scid() == last_hop_details.get_outbound_payment_scid() { ordered_hops.last_mut().unwrap().1 = details.counterparty.features.to_context(); features_set = true; break; @@ -2321,7 +2559,7 @@ where L::Target: Logger { } } if !features_set { - if let Some(node) = network_nodes.get(&ordered_hops.last().unwrap().0.node_id) { + if let Some(node) = network_nodes.get(&target) { if let Some(node_info) = node.announcement_info.as_ref() { ordered_hops.last_mut().unwrap().1 = node_info.features.clone(); } else { @@ -2338,11 +2576,11 @@ where L::Target: Logger { // save this path for the payment route. Also, update the liquidity // remaining on the used hops, so that we take them into account // while looking for more paths. - if ordered_hops.last().unwrap().0.node_id == maybe_dummy_payee_node_id { + if target == maybe_dummy_payee_node_id { break 'path_walk; } - new_entry = match dist.remove(&ordered_hops.last().unwrap().0.node_id) { + new_entry = match dist.remove(&target) { Some(payment_hop) => payment_hop, // We can't arrive at None because, if we ever add an entry to targets, // we also fill in the entry in dist (see add_entry!). @@ -2381,12 +2619,10 @@ where L::Target: Logger { // Remember that we used these channels so that we don't rely // on the same liquidity in future paths. let mut prevented_redundant_path_selection = false; - let prev_hop_iter = core::iter::once(&our_node_id) - .chain(payment_path.hops.iter().map(|(hop, _)| &hop.node_id)); - for (prev_hop, (hop, _)) in prev_hop_iter.zip(payment_path.hops.iter()) { + for (hop, _) in payment_path.hops.iter() { let spent_on_hop_msat = value_contribution_msat + hop.next_hops_fee_msat; let used_liquidity_msat = used_liquidities - .entry(hop.candidate.id(*prev_hop < hop.node_id)) + .entry(hop.candidate.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(); @@ -2407,8 +2643,10 @@ where L::Target: Logger { 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; + if let Some(scid) = victim_candidate.short_channel_id() { + *used_liquidities.entry(CandidateHopId::Clear((scid, false))).or_default() = exhausted; + *used_liquidities.entry(CandidateHopId::Clear((scid, true))).or_default() = exhausted; + } } // Track the total amount all our collected paths allow to send so that we know @@ -2431,8 +2669,8 @@ where L::Target: Logger { match network_nodes.get(&node_id) { None => {}, Some(node) => { - add_entries_to_cheapest_to_target_node!(node, node_id, lowest_fee_to_node, - value_contribution_msat, path_htlc_minimum_msat, path_penalty_msat, + add_entries_to_cheapest_to_target_node!(node, node_id, + value_contribution_msat, total_cltv_delta, path_length_to_node); }, } @@ -2454,6 +2692,9 @@ where L::Target: Logger { // because we deterministically terminated the search due to low liquidity. if !found_new_path && channel_saturation_pow_half != 0 { channel_saturation_pow_half = 0; + } else if !found_new_path && hit_minimum_limit && already_collected_value_msat < final_value_msat && path_value_msat != recommended_value_msat { + log_trace!(logger, "Failed to collect enough value, but running again to collect extra paths with a potentially higher limit."); + path_value_msat = recommended_value_msat; } else if already_collected_value_msat >= recommended_value_msat || !found_new_path { log_trace!(logger, "Have now collected {} msat (seeking {} msat) in paths. Last path loop {} a new path.", already_collected_value_msat, recommended_value_msat, if found_new_path { "found" } else { "did not find" }); @@ -2551,15 +2792,15 @@ where L::Target: Logger { selected_route.sort_unstable_by_key(|path| { 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.id(true)).zip(key.iter_mut()) { + for (scid, key) in path.hops.iter() .map(|h| h.0.candidate.id()).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.id(true), h.0.node_id)), - selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.id(true), h.0.node_id))) { + if iter_equal(selected_route[idx ].hops.iter().map(|h| (h.0.candidate.id(), h.0.candidate.target())), + selected_route[idx + 1].hops.iter().map(|h| (h.0.candidate.id(), h.0.candidate.target()))) { 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); @@ -2569,14 +2810,14 @@ where L::Target: Logger { let mut paths = Vec::new(); for payment_path in selected_route { 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 target = hop.candidate.target().expect("target is defined when short_channel_id is defined"); 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 { + } 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 { @@ -2584,14 +2825,14 @@ where L::Target: Logger { // 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| + network_graph.node(&target).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())) + .map_or(false, |c| c.as_directed_from(&hop.candidate.source()).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)})?, + pubkey: PublicKey::from_slice(target.as_slice()).map_err(|_| LightningError{err: format!("Public key {:?} is invalid", &target), action: ErrorAction::IgnoreAndLog(Level::Trace)})?, node_features: node_features.clone(), short_channel_id: hop.candidate.short_channel_id().unwrap(), channel_features: hop.candidate.features(), @@ -2599,8 +2840,6 @@ where L::Target: Logger { 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, _)| { @@ -2625,14 +2864,6 @@ where L::Target: Logger { // Make sure we would never create a route with more paths than we allow. debug_assert!(paths.len() <= payment_params.max_path_count.into()); - // 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}); - } - } - 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(); @@ -2640,6 +2871,15 @@ where L::Target: Logger { } let route = Route { paths, route_params: Some(route_params.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 route.get_total_fees() > 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}); + } + } + log_info!(logger, "Got route: {}", log_route!(route)); Ok(route) } @@ -2762,13 +3002,13 @@ fn build_route_from_hops_internal( impl ScoreLookUp for HopScorer { type ScoreParams = (); - fn channel_penalty_msat(&self, _short_channel_id: u64, source: &NodeId, target: &NodeId, + fn channel_penalty_msat(&self, candidate: &CandidateRouteHop, _usage: ChannelUsage, _score_params: &Self::ScoreParams) -> u64 { let mut cur_id = self.our_node_id; for i in 0..self.hop_ids.len() { if let Some(next_id) = self.hop_ids[i] { - if cur_id == *source && next_id == *target { + if cur_id == candidate.source() && Some(next_id) == candidate.target() { return 0; } cur_id = next_id; @@ -2809,13 +3049,13 @@ 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, RouteParameters}; + DEFAULT_MAX_TOTAL_CLTV_EXPIRY_DELTA, MAX_PATH_LENGTH_ESTIMATE, RouteParameters, CandidateRouteHop}; 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::ChannelId; - use crate::ln::features::{BlindedHopFeatures, Bolt12InvoiceFeatures, ChannelFeatures, InitFeatures, NodeFeatures}; + use crate::ln::features::{BlindedHopFeatures, ChannelFeatures, InitFeatures, NodeFeatures}; use crate::ln::msgs::{ErrorAction, LightningError, UnsignedChannelUpdate, MAX_VALUE_MSAT}; use crate::ln::channelmanager; use crate::offers::invoice::BlindedPayInfo; @@ -2828,13 +3068,11 @@ mod tests { use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; - use bitcoin::blockdata::constants::genesis_block; + use bitcoin::blockdata::constants::ChainHash; use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::opcodes; use bitcoin::blockdata::transaction::TxOut; - - use hex; - + use bitcoin::hashes::hex::FromHex; use bitcoin::secp256k1::{PublicKey,SecretKey}; use bitcoin::secp256k1::Secp256k1; @@ -2863,6 +3101,7 @@ 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, @@ -2958,7 +3197,7 @@ mod tests { // Disable other paths update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 2, // to disable @@ -2970,7 +3209,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 2, // to disable @@ -2982,7 +3221,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 2, // to disable @@ -2994,7 +3233,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 2, // to disable @@ -3006,7 +3245,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, // to disable @@ -3021,7 +3260,7 @@ mod tests { // Check against amount_to_transfer_over_msat. // Set minimal HTLC of 200_000_000 msat. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 3, flags: 0, @@ -3036,7 +3275,7 @@ mod tests { // Second hop only allows to forward 199_999_999 at most, thus not allowing the first hop to // be used. update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 3, flags: 0, @@ -3059,7 +3298,7 @@ mod tests { // Lift the restriction on the first hop. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 4, flags: 0, @@ -3082,7 +3321,9 @@ mod tests { let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph(); let (our_privkey, our_id, privkeys, nodes) = get_nodes(&secp_ctx); let config = UserConfig::default(); - let payment_params = PaymentParameters::from_node_id(nodes[2], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); 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(); @@ -3091,7 +3332,7 @@ mod tests { // One path allows transferring 35-40 sats, another one also allows 35-40 sats. // Thus, they can't send 60 without overpaying. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -3103,7 +3344,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 3, flags: 0, @@ -3117,7 +3358,7 @@ mod tests { // Make 0 fee. update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -3129,7 +3370,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -3143,7 +3384,7 @@ mod tests { // Disable other paths update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 3, flags: 2, // to disable @@ -3168,7 +3409,7 @@ mod tests { // Now, test that if there are 2 paths, a "cheaper" by fee path wouldn't be prioritized // while taking even more fee to match htlc_minimum_msat. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 4, flags: 0, @@ -3180,7 +3421,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 3, flags: 0, @@ -3192,7 +3433,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 4, flags: 0, @@ -3223,6 +3464,67 @@ mod tests { assert_eq!(fees, 5_000); } + #[test] + fn htlc_minimum_recipient_overpay_test() { + let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph(); + let (_, our_id, privkeys, nodes) = get_nodes(&secp_ctx); + let config = UserConfig::default(); + let payment_params = PaymentParameters::from_node_id(nodes[2], 42).with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)).unwrap(); + 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(); + + // Route to node2 over a single path which requires overpaying the recipient themselves. + + // First disable all paths except the us -> node1 -> node2 path + update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { + chain_hash: ChainHash::using_genesis_block(Network::Testnet), + short_channel_id: 13, + timestamp: 2, + flags: 3, + cltv_expiry_delta: 0, + htlc_minimum_msat: 0, + htlc_maximum_msat: 0, + fee_base_msat: 0, + fee_proportional_millionths: 0, + excess_data: Vec::new() + }); + + // Set channel 4 to free but with a high htlc_minimum_msat + update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { + chain_hash: ChainHash::using_genesis_block(Network::Testnet), + short_channel_id: 4, + timestamp: 2, + flags: 0, + cltv_expiry_delta: 0, + htlc_minimum_msat: 15_000, + htlc_maximum_msat: MAX_VALUE_MSAT, + fee_base_msat: 0, + fee_proportional_millionths: 0, + excess_data: Vec::new() + }); + + // Now check that we'll fail to find a path if we fail to find a path if the htlc_minimum + // is overrun. Note that the fees are actually calculated on 3*payment amount as that's + // what we try to find a route for, so this test only just happens to work out to exactly + // the fee limit. + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 5_000); + route_params.max_total_routing_fee_msat = Some(9_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 route that adheres to the maximum total fee limit of 9999msat"); + } else { panic!(); } + + let mut route_params = RouteParameters::from_payment_params_and_value( + payment_params.clone(), 5_000); + route_params.max_total_routing_fee_msat = Some(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.get_total_fees(), 10_000); + } + #[test] fn disable_channels_test() { let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph(); @@ -3234,7 +3536,7 @@ mod tests { // // Disable channels 4 and 12 by flags=2 update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 2, // to disable @@ -3246,7 +3548,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 2, // to disable @@ -3678,7 +3980,7 @@ mod tests { // Disabling channels 6 & 7 by flags=2 update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 2, // to disable @@ -3690,7 +3992,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, // to disable @@ -3741,7 +4043,7 @@ mod tests { let (secp_ctx, network_graph, gossip_sync, _, logger) = build_graph(); let (_, our_id, privkeys, nodes) = get_nodes(&secp_ctx); - let non_announced_privkey = SecretKey::from_slice(&hex::decode(format!("{:02x}", 0xf0).repeat(32)).unwrap()[..]).unwrap(); + let non_announced_privkey = SecretKey::from_slice(&>::from_hex(&format!("{:02x}", 0xf0).repeat(32)).unwrap()[..]).unwrap(); let non_announced_pubkey = PublicKey::from_secret_key(&secp_ctx, &non_announced_privkey); let last_hops = multi_hop_last_hops_hint([nodes[2], non_announced_pubkey]); @@ -3752,7 +4054,7 @@ mod tests { // Disabling channels 6 & 7 by flags=2 update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 2, // to disable @@ -3764,7 +4066,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, // to disable @@ -4022,9 +4324,9 @@ mod tests { } fn do_unannounced_path_test(last_hop_htlc_max: Option, last_hop_fee_prop: u32, outbound_capacity_msat: u64, route_val: u64) -> Result { - let source_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(format!("{:02}", 41).repeat(32)).unwrap()[..]).unwrap()); - let middle_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(format!("{:02}", 42).repeat(32)).unwrap()[..]).unwrap()); - let target_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(format!("{:02}", 43).repeat(32)).unwrap()[..]).unwrap()); + let source_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&>::from_hex(&format!("{:02}", 41).repeat(32)).unwrap()[..]).unwrap()); + let middle_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&>::from_hex(&format!("{:02}", 42).repeat(32)).unwrap()[..]).unwrap()); + let target_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&>::from_hex(&format!("{:02}", 43).repeat(32)).unwrap()[..]).unwrap()); // If we specify a channel to a middle hop, that overrides our local channel view and that gets used let last_hops = RouteHint(vec![RouteHintHop { @@ -4059,8 +4361,8 @@ mod tests { // hints. let route = do_unannounced_path_test(None, 1, 2000000, 1000000).unwrap(); - let middle_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(format!("{:02}", 42).repeat(32)).unwrap()[..]).unwrap()); - let target_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(format!("{:02}", 43).repeat(32)).unwrap()[..]).unwrap()); + let middle_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&>::from_hex(&format!("{:02}", 42).repeat(32)).unwrap()[..]).unwrap()); + let target_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&>::from_hex(&format!("{:02}", 43).repeat(32)).unwrap()[..]).unwrap()); assert_eq!(route.paths[0].hops.len(), 2); assert_eq!(route.paths[0].hops[0].pubkey, middle_node_id); @@ -4106,14 +4408,16 @@ 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[2], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); // We will use a simple single-path route from // our node to node2 via node0: channels {1, 3}. // First disable all other paths. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 2, @@ -4125,7 +4429,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 2, @@ -4140,7 +4444,7 @@ mod tests { // Make the first channel (#1) very permissive, // and we will be testing all limits on the second channel. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -4155,7 +4459,7 @@ mod tests { // First, let's see if routing works if we have absolutely no idea about the available amount. // In this case, it should be set to 250_000 sats. update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -4194,7 +4498,7 @@ mod tests { // Check that setting next_outbound_htlc_limit_msat in first_hops limits the channels. // Disable channel #1 and use another first hop. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 3, flags: 2, @@ -4237,7 +4541,7 @@ mod tests { // Enable channel #1 back. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 4, flags: 0, @@ -4252,7 +4556,7 @@ mod tests { // Now let's see if routing works if we know only htlc_maximum_msat. update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 3, flags: 0, @@ -4293,7 +4597,7 @@ mod tests { // We can't change UTXO capacity on the fly, so we'll disable // the existing channel and add another one with the capacity we need. update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 4, flags: 2, @@ -4317,7 +4621,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[0], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(3)), 333); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 333, timestamp: 1, flags: 0, @@ -4329,7 +4633,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 333, timestamp: 1, flags: 1, @@ -4367,7 +4671,7 @@ mod tests { // Now let's see if routing chooses htlc_maximum_msat over UTXO capacity. update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 333, timestamp: 6, flags: 0, @@ -4414,7 +4718,9 @@ 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_bolt11_invoice_features(&config)) + .unwrap(); // Path via {node7, node2, node4} is channels {12, 13, 6, 11}. // {12, 13, 11} have the capacities of 100, {6} has a capacity of 50. @@ -4422,7 +4728,7 @@ mod tests { // Disable other potential paths. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 2, @@ -4434,7 +4740,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, @@ -4449,7 +4755,7 @@ mod tests { // Limit capacities update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -4461,7 +4767,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -4474,7 +4780,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 0, @@ -4486,7 +4792,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 11, timestamp: 2, flags: 0, @@ -4552,7 +4858,7 @@ mod tests { // Path via node0 is channels {1, 3}. Limit them to 100 and 50 sats (total limit 50). update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -4564,7 +4870,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -4598,11 +4904,12 @@ mod tests { 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(); + .with_bolt11_features(channelmanager::provided_bolt11_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 bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let blinded_path = BlindedPath { introduction_node_id: nodes[2], blinding_point: ln_test_utils::pubkey(42), @@ -4665,7 +4972,7 @@ mod tests { // Path via node0 is channels {1, 3}. Limit them to 100 and 50 sats (total limit 50). update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -4677,7 +4984,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -4692,7 +4999,7 @@ mod tests { // Path via node7 is channels {12, 13}. Limit them to 60 and 60 sats // (total limit 60). update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -4704,7 +5011,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -4719,7 +5026,7 @@ mod tests { // Path via node1 is channels {2, 4}. Limit them to 200 and 180 sats // (total capacity 180 sats). update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -4731,7 +5038,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -4841,7 +5148,8 @@ mod tests { 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(); + .with_bolt11_features(channelmanager::provided_bolt11_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}. @@ -4852,7 +5160,7 @@ mod tests { // Disable other potential paths. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 2, @@ -4864,7 +5172,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, @@ -4878,7 +5186,7 @@ mod tests { // Path via {node0, node2} is channels {1, 3, 5}. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -4890,7 +5198,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -4905,7 +5213,7 @@ mod tests { // Capacity of 200 sats because this channel will be used by 3rd path as well. add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(5)), 5); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 5, timestamp: 2, flags: 0, @@ -4921,7 +5229,7 @@ mod tests { // Add 100 sats to the capacities of {12, 13}, because these channels // are also used for 3rd path. 100 sats for the rest. Total capacity: 100 sats. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -4933,7 +5241,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -4946,7 +5254,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 0, @@ -4958,7 +5266,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 11, timestamp: 2, flags: 0, @@ -5012,7 +5320,9 @@ 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_bolt11_invoice_features(&config)) + .unwrap(); // This test checks that if we have two cheaper paths and one more expensive path, // so that liquidity-wise any 2 of 3 combination is sufficient, @@ -5027,7 +5337,7 @@ mod tests { // Disable other potential paths. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 2, @@ -5039,7 +5349,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, @@ -5053,7 +5363,7 @@ mod tests { // Path via {node0, node2} is channels {1, 3, 5}. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -5065,7 +5375,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -5080,7 +5390,7 @@ mod tests { // Capacity of 200 sats because this channel will be used by 3rd path as well. add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(5)), 5); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 5, timestamp: 2, flags: 0, @@ -5096,7 +5406,7 @@ mod tests { // Add 100 sats to the capacities of {12, 13}, because these channels // are also used for 3rd path. 100 sats for the rest. Total capacity: 100 sats. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -5108,7 +5418,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -5121,7 +5431,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 0, @@ -5133,7 +5443,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 11, timestamp: 2, flags: 0, @@ -5185,7 +5495,9 @@ 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_bolt11_invoice_features(&config)) + .unwrap(); // We need a route consisting of 2 paths: // From our node to node3 via {node0, node2} and {node7, node2, node4}. @@ -5198,7 +5510,7 @@ mod tests { // Disable other potential paths. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 2, @@ -5211,7 +5523,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 7, timestamp: 2, flags: 2, @@ -5225,7 +5537,7 @@ mod tests { // Path via {node0, node2} is channels {1, 3, 5}. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -5237,7 +5549,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -5251,7 +5563,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(5)), 5); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 5, timestamp: 2, flags: 0, @@ -5274,7 +5586,7 @@ mod tests { // - fee for channel 6 is 150 sats // Let's test this by enforcing these 2 conditions and removing other limits. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -5286,7 +5598,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -5299,7 +5611,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 2, flags: 0, @@ -5311,7 +5623,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 11, timestamp: 2, flags: 0, @@ -5340,7 +5652,7 @@ mod tests { max_total_routing_fee_msat: Some(149_999) }; if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route( &our_id, &route_params, &network_graph.read_only(), None, Arc::clone(&logger), - &scorer, &(), &random_seed_bytes) { + &scorer, &Default::default(), &random_seed_bytes) { assert_eq!(err, "Failed to find a sufficient route to the given destination"); } else { panic!(); } } @@ -5384,7 +5696,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(PublicKey::from_slice(&[02; 33]).unwrap(), 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + let payment_params = PaymentParameters::from_node_id(PublicKey::from_slice(&[02; 33]).unwrap(), 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)).unwrap() .with_route_hints(vec![RouteHint(vec![RouteHintHop { src_node_id: nodes[2], short_channel_id: 42, @@ -5400,7 +5713,7 @@ mod tests { // we think we can only send up to 1 additional sat over the last-hop but refuse to as its // under 5% of our payment amount. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -5412,7 +5725,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -5424,7 +5737,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -5436,7 +5749,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0|2, // Channel disabled @@ -5479,7 +5792,9 @@ 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[2], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + let payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap() .with_max_channel_saturation_power_of_half(0); // We need a route consisting of 3 paths: @@ -5493,7 +5808,7 @@ mod tests { // Path via node0 is channels {1, 3}. Limit them to 100 and 50 sats (total limit 50); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 2, flags: 0, @@ -5505,7 +5820,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 2, flags: 0, @@ -5519,7 +5834,7 @@ mod tests { // Path via node7 is channels {12, 13}. Limit them to 60 and 60 sats (total limit 60); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -5531,7 +5846,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -5545,7 +5860,7 @@ mod tests { // Path via node1 is channels {2, 4}. Limit them to 20 and 20 sats (total capacity 20 sats). update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -5557,7 +5872,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -5652,7 +5967,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &our_privkey, &privkeys[1], ChannelFeatures::from_le_bytes(id_to_feature_flags(6)), 6); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 1, flags: 0, @@ -5667,7 +5982,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[1], &privkeys[4], ChannelFeatures::from_le_bytes(id_to_feature_flags(5)), 5); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 5, timestamp: 1, flags: 0, @@ -5682,7 +5997,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[4], &privkeys[3], ChannelFeatures::from_le_bytes(id_to_feature_flags(4)), 4); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 1, flags: 0, @@ -5697,7 +6012,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[3], &privkeys[2], ChannelFeatures::from_le_bytes(id_to_feature_flags(3)), 3); update_channel(&gossip_sync, &secp_ctx, &privkeys[3], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 3, timestamp: 1, flags: 0, @@ -5712,7 +6027,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[2], &privkeys[4], ChannelFeatures::from_le_bytes(id_to_feature_flags(2)), 2); update_channel(&gossip_sync, &secp_ctx, &privkeys[2], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 1, flags: 0, @@ -5726,7 +6041,7 @@ mod tests { add_channel(&gossip_sync, &secp_ctx, &privkeys[4], &privkeys[6], ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 1); update_channel(&gossip_sync, &secp_ctx, &privkeys[4], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 1, flags: 0, @@ -5787,7 +6102,7 @@ mod tests { // We modify the graph to set the htlc_maximum of channel 2 to below the value we wish to // send. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -5800,7 +6115,7 @@ mod tests { }); update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 12, timestamp: 2, flags: 0, @@ -5851,13 +6166,15 @@ 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[2], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); // We modify the graph to set the htlc_minimum of channel 2 and 4 as needed - channel 2 // gets an htlc_maximum_msat of 80_000 and channel 4 an htlc_minimum_msat of 90_000. We // then try to send 90_000. update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 2, timestamp: 2, flags: 0, @@ -5869,7 +6186,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -5904,7 +6221,7 @@ mod tests { assert_eq!(route.paths[0].hops[1].short_channel_id, 13); assert_eq!(route.paths[0].hops[1].fee_msat, 90_000); assert_eq!(route.paths[0].hops[1].cltv_expiry_delta, 42); - assert_eq!(route.paths[0].hops[1].node_features.le_flags(), channelmanager::provided_invoice_features(&config).le_flags()); + assert_eq!(route.paths[0].hops[1].node_features.le_flags(), channelmanager::provided_bolt11_invoice_features(&config).le_flags()); assert_eq!(route.paths[0].hops[1].channel_features.le_flags(), &id_to_feature_flags(13)); } } @@ -5923,7 +6240,9 @@ mod tests { let network_graph = NetworkGraph::new(Network::Testnet, Arc::clone(&logger)); let scorer = ln_test_utils::TestScorer::new(); let config = UserConfig::default(); - let payment_params = PaymentParameters::from_node_id(nodes[0], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[0], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); let keys_manager = ln_test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet); let random_seed_bytes = keys_manager.get_secure_random_bytes(); @@ -6035,8 +6354,8 @@ mod tests { } 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 channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { + if candidate.short_channel_id() == Some(self.short_channel_id) { u64::max_value() } else { 0 } } } @@ -6051,8 +6370,8 @@ mod tests { 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 channel_penalty_msat(&self, candidate: &CandidateRouteHop, _: ChannelUsage, _score_params:&Self::ScoreParams) -> u64 { + if candidate.target() == Some(self.node_id) { u64::max_value() } else { 0 } } } @@ -6103,17 +6422,17 @@ mod tests { let route = Route { paths: vec![Path { hops: vec![ RouteHop { - pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), + pubkey: PublicKey::from_slice(&>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), 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(), + pubkey: PublicKey::from_slice(&>::from_hex("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), 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(), + pubkey: PublicKey::from_slice(&>::from_hex("027f31ebc5462c1fdce1b737ecff52d37d75dea43ce11c74d25aa297165faa2007").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), short_channel_id: 0, fee_msat: 225, cltv_expiry_delta: 0, maybe_announced_channel: true, }, @@ -6130,23 +6449,23 @@ mod tests { let route = Route { paths: vec![Path { hops: vec![ RouteHop { - pubkey: PublicKey::from_slice(&hex::decode("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), + pubkey: PublicKey::from_slice(&>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), 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(), + pubkey: PublicKey::from_slice(&>::from_hex("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), 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(), + pubkey: PublicKey::from_slice(&>::from_hex("02eec7245d6b7d2ccb30380bfbe2a3648cd7a942653f5aa340edcea1f283686619").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), 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(), + pubkey: PublicKey::from_slice(&>::from_hex("0324653eac434488002cc06bbfb7f10fe18991e35f9fe4302dbea6d2353dc0ab1c").unwrap()[..]).unwrap(), channel_features: ChannelFeatures::empty(), node_features: NodeFeatures::empty(), short_channel_id: 0, fee_msat: 150, cltv_expiry_delta: 0, maybe_announced_channel: true, }, @@ -6409,7 +6728,7 @@ mod tests { // Set the fee on channel 13 to 100% to match channel 4 giving us two equivalent paths (us // -> node 7 -> node2 and us -> node 1 -> node 2) which we should balance over. update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 4, timestamp: 2, flags: 0, @@ -6421,7 +6740,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[7], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 13, timestamp: 2, flags: 0, @@ -6434,7 +6753,9 @@ mod tests { }); let config = UserConfig::default(); - let payment_params = PaymentParameters::from_node_id(nodes[2], 42).with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap(); + let payment_params = PaymentParameters::from_node_id(nodes[2], 42) + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); 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. @@ -6493,7 +6814,7 @@ mod tests { let params = ProbabilisticScoringFeeParameters::default(); let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); - let features = channelmanager::provided_invoice_features(&UserConfig::default()); + let features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 0, 2); } @@ -6514,7 +6835,7 @@ mod tests { let params = ProbabilisticScoringFeeParameters::default(); let mut scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &graph, &logger); - let features = channelmanager::provided_invoice_features(&UserConfig::default()); + let features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); super::bench_utils::generate_test_routes(&graph, &mut scorer, ¶ms, features, random_init_seed(), 1_000_000, 2); } @@ -6538,26 +6859,32 @@ mod tests { }; scorer_params.set_manual_penalty(&NodeId::from_pubkey(&nodes[3]), 123); scorer_params.set_manual_penalty(&NodeId::from_pubkey(&nodes[4]), 456); - assert_eq!(scorer.channel_penalty_msat(42, &NodeId::from_pubkey(&nodes[3]), &NodeId::from_pubkey(&nodes[4]), usage, &scorer_params), 456); + let network_graph = network_graph.read_only(); + let channels = network_graph.channels(); + let channel = channels.get(&5).unwrap(); + let info = channel.as_directed_from(&NodeId::from_pubkey(&nodes[3])).unwrap(); + let candidate: CandidateRouteHop = CandidateRouteHop::PublicHop { + info: info.0, + short_channel_id: 5, + }; + assert_eq!(scorer.channel_penalty_msat(&candidate, usage, &scorer_params), 456); // Then check we can get a normal route let payment_params = PaymentParameters::from_node_id(nodes[10], 42); 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, + let route = get_route(&our_id, &route_params, &network_graph, 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, &route_params, &network_graph.read_only(), None, - Arc::clone(&logger), &scorer, &scorer_params, &random_seed_bytes); + let route = get_route(&our_id, &route_params, &network_graph, 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, &route_params, &network_graph.read_only(), None, - Arc::clone(&logger), &scorer, &scorer_params, &random_seed_bytes); + let route = get_route(&our_id, &route_params, &network_graph, None, Arc::clone(&logger), &scorer, &scorer_params,&random_seed_bytes); assert!(route.is_ok()); } @@ -6588,7 +6915,8 @@ mod tests { 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(); + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); // Make sure we'll error if our route hints don't have enough liquidity according to their // htlc_maximum_msat. @@ -6607,7 +6935,8 @@ mod tests { 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(); + .with_bolt11_features(channelmanager::provided_bolt11_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); @@ -6663,7 +6992,8 @@ mod tests { 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(); + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)) + .unwrap(); let route_params = RouteParameters::from_payment_params_and_value( payment_params, amt_msat); @@ -6706,7 +7036,7 @@ mod tests { cltv_expiry_delta: 10, features: BlindedHopFeatures::empty(), }; - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let payment_params = PaymentParameters::blinded(vec![ (blinded_payinfo.clone(), blinded_path.clone()), (blinded_payinfo.clone(), blinded_path.clone())]) @@ -7015,7 +7345,7 @@ mod tests { 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 bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let blinded_path_1 = BlindedPath { introduction_node_id: nodes[2], blinding_point: ln_test_utils::pubkey(42), @@ -7043,7 +7373,7 @@ mod tests { (blinded_payinfo_2.clone(), blinded_path_2.clone()), ]; let payment_params = PaymentParameters::blinded(blinded_hints.clone()) - .with_bolt12_features(bolt12_features.clone()).unwrap(); + .with_bolt12_features(bolt12_features).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); @@ -7087,7 +7417,7 @@ mod tests { 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(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 1, flags: 0, @@ -7099,7 +7429,7 @@ mod tests { excess_data: Vec::new() }); update_channel(&gossip_sync, &secp_ctx, &privkeys[1], UnsignedChannelUpdate { - chain_hash: genesis_block(Network::Testnet).header.block_hash(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 1, timestamp: 1, flags: 1, @@ -7208,9 +7538,9 @@ mod tests { 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 bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let payment_params = PaymentParameters::blinded(blinded_hints.clone()) - .with_bolt12_features(bolt12_features.clone()).unwrap(); + .with_bolt12_features(bolt12_features).unwrap(); let netgraph = network_graph.read_only(); let route_params = RouteParameters::from_payment_params_and_value( @@ -7260,7 +7590,7 @@ mod tests { ]; blinded_hints[1].1.introduction_node_id = nodes[6]; - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let payment_params = PaymentParameters::blinded(blinded_hints.clone()) .with_bolt12_features(bolt12_features.clone()).unwrap(); @@ -7268,7 +7598,7 @@ mod tests { 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 + &our_id, &route_params, &netgraph, None, Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes ) { assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!() } @@ -7317,7 +7647,7 @@ mod tests { blinded_hints[2].1.introduction_node_id = nodes[6]; - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let payment_params = PaymentParameters::blinded(blinded_hints.clone()) .with_bolt12_features(bolt12_features.clone()).unwrap(); @@ -7325,7 +7655,7 @@ mod tests { 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 + &our_id, &route_params, &netgraph, None, Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes ) { assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!() } @@ -7377,7 +7707,7 @@ mod tests { cltv_expiry_delta: 0, features: BlindedHopFeatures::empty(), }; - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); PaymentParameters::blinded(vec![(blinded_payinfo, blinded_path)]) .with_bolt12_features(bolt12_features.clone()).unwrap() } else { @@ -7395,7 +7725,7 @@ mod tests { PaymentParameters::from_node_id(nodes[1], 42) .with_route_hints(vec![route_hint]).unwrap() - .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)).unwrap() }; let netgraph = network_graph.read_only(); @@ -7403,7 +7733,7 @@ mod tests { 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 + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes ) { assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!() } @@ -7460,7 +7790,7 @@ mod tests { features: BlindedHopFeatures::empty(), }, blinded_path.clone())); } - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); PaymentParameters::blinded(blinded_hints.clone()) .with_bolt12_features(bolt12_features.clone()).unwrap() } else { @@ -7480,7 +7810,7 @@ mod tests { } PaymentParameters::from_node_id(nodes[1], 42) .with_route_hints(route_hints).unwrap() - .with_bolt11_features(channelmanager::provided_invoice_features(&config)).unwrap() + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)).unwrap() }; let netgraph = network_graph.read_only(); @@ -7489,7 +7819,7 @@ mod tests { let route = get_route( &our_id, &route_params, &netgraph, Some(&first_hops.iter().collect::>()), - Arc::clone(&logger), &scorer, &(), &random_seed_bytes + Arc::clone(&logger), &scorer, &Default::default(), &random_seed_bytes ).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.get_total_amount(), amt_msat); @@ -7520,7 +7850,7 @@ mod tests { 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(), + chain_hash: ChainHash::using_genesis_block(Network::Testnet), short_channel_id: 6, timestamp: 1, flags: 0, @@ -7551,7 +7881,7 @@ mod tests { ], }) ]; - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); let payment_params = PaymentParameters::blinded(blinded_hints.clone()) .with_bolt12_features(bolt12_features.clone()).unwrap(); let route_params = RouteParameters::from_payment_params_and_value( @@ -7611,7 +7941,7 @@ mod tests { features: BlindedHopFeatures::empty(), }, blinded_path.clone())); } - let bolt12_features: Bolt12InvoiceFeatures = channelmanager::provided_invoice_features(&config).to_context(); + let bolt12_features = channelmanager::provided_bolt12_invoice_features(&config); PaymentParameters::blinded(blinded_hints.clone()) .with_bolt12_features(bolt12_features.clone()).unwrap() }; @@ -7627,6 +7957,203 @@ mod tests { assert_eq!(route.paths.len(), 1); assert_eq!(route.get_total_amount(), amt_msat); } + + #[test] + fn first_hop_preferred_over_hint() { + // Check that if we have a first hop to a peer we'd always prefer that over a route hint + // they gave us, but we'd still consider all subsequent hints if they are more attractive. + 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 config = UserConfig::default(); + + let amt_msat = 1_000_000; + let (our_privkey, our_node_id, privkeys, nodes) = get_nodes(&secp_ctx); + + add_channel(&gossip_sync, &secp_ctx, &our_privkey, &privkeys[0], + ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 1); + update_channel(&gossip_sync, &secp_ctx, &our_privkey, UnsignedChannelUpdate { + chain_hash: ChainHash::using_genesis_block(Network::Testnet), + 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[0], UnsignedChannelUpdate { + chain_hash: ChainHash::using_genesis_block(Network::Testnet), + 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() + }); + + add_channel(&gossip_sync, &secp_ctx, &privkeys[0], &privkeys[1], + ChannelFeatures::from_le_bytes(id_to_feature_flags(1)), 2); + update_channel(&gossip_sync, &secp_ctx, &privkeys[0], UnsignedChannelUpdate { + chain_hash: ChainHash::using_genesis_block(Network::Testnet), + short_channel_id: 2, + timestamp: 2, + 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: ChainHash::using_genesis_block(Network::Testnet), + short_channel_id: 2, + timestamp: 2, + 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 dest_node_id = nodes[2]; + + let route_hint = RouteHint(vec![RouteHintHop { + src_node_id: our_node_id, + short_channel_id: 44, + fees: RoutingFees { + base_msat: 234, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + htlc_maximum_msat: Some(5_000_000), + }, + RouteHintHop { + src_node_id: nodes[0], + short_channel_id: 45, + fees: RoutingFees { + base_msat: 123, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + htlc_maximum_msat: None, + }]); + + let payment_params = PaymentParameters::from_node_id(dest_node_id, 42) + .with_route_hints(vec![route_hint]).unwrap() + .with_bolt11_features(channelmanager::provided_bolt11_invoice_features(&config)).unwrap(); + let route_params = RouteParameters::from_payment_params_and_value( + payment_params, amt_msat); + + // First create an insufficient first hop for channel with SCID 1 and check we'd use the + // route hint. + let first_hop = get_channel_details(Some(1), nodes[0], + channelmanager::provided_init_features(&config), 999_999); + let first_hops = vec![first_hop]; + + let route = get_route(&our_node_id, &route_params.clone(), &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 1); + assert_eq!(route.get_total_amount(), amt_msat); + assert_eq!(route.paths[0].hops.len(), 2); + assert_eq!(route.paths[0].hops[0].short_channel_id, 44); + assert_eq!(route.paths[0].hops[1].short_channel_id, 45); + assert_eq!(route.get_total_fees(), 123); + + // Now check we would trust our first hop info, i.e., fail if we detect the route hint is + // for a first hop channel. + let mut first_hop = get_channel_details(Some(1), nodes[0], channelmanager::provided_init_features(&config), 999_999); + first_hop.outbound_scid_alias = Some(44); + let first_hops = vec![first_hop]; + + let route_res = get_route(&our_node_id, &route_params.clone(), &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes); + assert!(route_res.is_err()); + + // Finally check we'd use the first hop if has sufficient outbound capacity. But we'd stil + // use the cheaper second hop of the route hint. + let mut first_hop = get_channel_details(Some(1), nodes[0], + channelmanager::provided_init_features(&config), 10_000_000); + first_hop.outbound_scid_alias = Some(44); + let first_hops = vec![first_hop]; + + let route = get_route(&our_node_id, &route_params.clone(), &network_graph.read_only(), + Some(&first_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); + assert_eq!(route.paths.len(), 1); + assert_eq!(route.get_total_amount(), amt_msat); + assert_eq!(route.paths[0].hops.len(), 2); + assert_eq!(route.paths[0].hops[0].short_channel_id, 1); + assert_eq!(route.paths[0].hops[1].short_channel_id, 45); + assert_eq!(route.get_total_fees(), 123); + } + + #[test] + fn allow_us_being_first_hint() { + // Check that we consider a route hint even if we are the src of the first hop. + 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(); + + let (_, our_node_id, _, nodes) = get_nodes(&secp_ctx); + + let amt_msat = 1_000_000; + let dest_node_id = nodes[1]; + + let first_hop = get_channel_details(Some(1), nodes[0], channelmanager::provided_init_features(&config), 10_000_000); + let first_hops = vec![first_hop]; + + let route_hint = RouteHint(vec![RouteHintHop { + src_node_id: our_node_id, + short_channel_id: 44, + fees: RoutingFees { + base_msat: 123, + proportional_millionths: 0, + }, + cltv_expiry_delta: 10, + htlc_minimum_msat: None, + htlc_maximum_msat: None, + }]); + + let payment_params = PaymentParameters::from_node_id(dest_node_id, 42) + .with_route_hints(vec![route_hint]).unwrap() + .with_bolt11_features(channelmanager::provided_bolt11_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_hops.iter().collect::>()), Arc::clone(&logger), &scorer, + &Default::default(), &random_seed_bytes).unwrap(); + + assert_eq!(route.paths.len(), 1); + assert_eq!(route.get_total_amount(), amt_msat); + assert_eq!(route.get_total_fees(), 0); + assert_eq!(route.paths[0].hops.len(), 1); + + assert_eq!(route.paths[0].hops[0].short_channel_id, 44); + } } #[cfg(all(any(test, ldk_bench), not(feature = "no-std")))] @@ -7712,6 +8239,7 @@ 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, @@ -7769,7 +8297,7 @@ pub(crate) mod bench_utils { // Generate fail/success paths for a wider range of potential amounts with // MPP enabled to give us a chance to apply penalties for more potential // routes. - let mpp_features = channelmanager::provided_invoice_features(&UserConfig::default()); + let mpp_features = channelmanager::provided_bolt11_invoice_features(&UserConfig::default()); let params = PaymentParameters::from_node_id(dst, 42) .with_bolt11_features(mpp_features).unwrap(); let route_params = RouteParameters::from_payment_params_and_value( @@ -7831,7 +8359,7 @@ pub mod benches { struct DummyLogger {} impl Logger for DummyLogger { - fn log(&self, _record: &Record) {} + fn log(&self, _record: Record) {} } pub fn generate_routes_with_zero_penalty_scorer(bench: &mut Criterion) { @@ -7847,7 +8375,7 @@ pub mod benches { let network_graph = bench_utils::read_network_graph(&logger).unwrap(); let scorer = FixedPenaltyScorer::with_penalty(0); generate_routes(bench, &network_graph, scorer, &Default::default(), - channelmanager::provided_invoice_features(&UserConfig::default()), 0, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_zero_penalty_scorer"); } @@ -7866,7 +8394,7 @@ pub mod benches { let params = ProbabilisticScoringFeeParameters::default(); let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, - channelmanager::provided_invoice_features(&UserConfig::default()), 0, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_probabilistic_scorer"); } @@ -7876,7 +8404,7 @@ pub mod benches { let params = ProbabilisticScoringFeeParameters::default(); let scorer = ProbabilisticScorer::new(ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, - channelmanager::provided_invoice_features(&UserConfig::default()), 100_000_000, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 100_000_000, "generate_large_mpp_routes_with_probabilistic_scorer"); } @@ -7888,7 +8416,7 @@ pub mod benches { let scorer = ProbabilisticScorer::new( ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, - channelmanager::provided_invoice_features(&UserConfig::default()), 0, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_routes_with_nonlinear_probabilistic_scorer"); } @@ -7900,7 +8428,7 @@ pub mod benches { let scorer = ProbabilisticScorer::new( ProbabilisticScoringDecayParameters::default(), &network_graph, &logger); generate_routes(bench, &network_graph, scorer, ¶ms, - channelmanager::provided_invoice_features(&UserConfig::default()), 0, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 0, "generate_mpp_routes_with_nonlinear_probabilistic_scorer"); } @@ -7912,7 +8440,7 @@ pub mod benches { 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, + channelmanager::provided_bolt11_invoice_features(&UserConfig::default()), 100_000_000, "generate_large_mpp_routes_with_nonlinear_probabilistic_scorer"); }