X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=ba964d734c670e4cfbbc4d12eca1ea9e71f37491;hb=c7e198e6fca8fc31e004b51368978b109c1caff6;hp=5c7debd07e5c7ffd00feb2d5175e441617c66d97;hpb=b728216fd98a4b3996a5e51d1219c901dd09b4c2;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 5c7debd0..ba964d73 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -21,9 +21,9 @@ use routing::network_graph::{NetworkGraph, RoutingFees}; use util::ser::{Writeable, Readable}; use util::logger::Logger; -use std::cmp; +use core::cmp; use std::collections::{HashMap, BinaryHeap}; -use std::ops::Deref; +use core::ops::Deref; /// A hop in a route #[derive(Clone, PartialEq)] @@ -117,8 +117,8 @@ impl Readable for Route { } /// A channel descriptor which provides a last-hop route to get_route -#[derive(Clone)] -pub struct RouteHint { +#[derive(Eq, PartialEq, Debug, Clone)] +pub struct RouteHintHop { /// The node_id of the non-target end of the route pub src_node_id: PublicKey, /// The short_channel_id of this channel @@ -175,10 +175,15 @@ struct DummyDirectionalChannelInfo { /// 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)] -struct PathBuildingHop { - /// Hop-specific details unrelated to the path during the routing phase, - /// but rather relevant to the LN graph. - route_hop: RouteHop, +struct PathBuildingHop<'a> { + // The RouteHintHop fields which will eventually be used if this hop is used in a final Route. + // Note that node_features is calculated separately after our initial graph walk. + pubkey: PublicKey, + short_channel_id: u64, + channel_features: &'a ChannelFeatures, + fee_msat: u64, + cltv_expiry_delta: u32, + /// Minimal fees required to route to the source node of the current hop via any of its inbound channels. src_lowest_inbound_fees: RoutingFees, /// Fees of the channel used in this hop. @@ -200,20 +205,31 @@ struct PathBuildingHop { /// A mirror of the same field in RouteGraphNode. Note that this is only used during the graph /// walk and may be invalid thereafter. path_htlc_minimum_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, + #[cfg(any(test, feature = "fuzztarget"))] + // In tests, we apply further sanity checks on cases where we skip nodes we already processed + // to ensure it is specifically in cases where the fee has gone down because of a decrease in + // value_contribution_msat, which requires tracking it here. See comments below where it is + // used for more info. + value_contribution_msat: u64, } // Instantiated with a list of hops with correct data in them collected during path finding, // an instance of this struct should be further modified only via given methods. #[derive(Clone)] -struct PaymentPath { - hops: Vec, +struct PaymentPath<'a> { + hops: Vec<(PathBuildingHop<'a>, NodeFeatures)>, } -impl PaymentPath { - +impl<'a> PaymentPath<'a> { // TODO: Add a value_msat field to PaymentPath and use it instead of this function. fn get_value_msat(&self) -> u64 { - self.hops.last().unwrap().route_hop.fee_msat + self.hops.last().unwrap().0.fee_msat } fn get_total_fee_paid_msat(&self) -> u64 { @@ -222,9 +238,9 @@ impl PaymentPath { } let mut result = 0; // Can't use next_hops_fee_msat because it gets outdated. - for (i, hop) in self.hops.iter().enumerate() { + for (i, (hop, _)) in self.hops.iter().enumerate() { if i != self.hops.len() - 1 { - result += hop.route_hop.fee_msat; + result += hop.fee_msat; } } return result; @@ -233,16 +249,14 @@ impl PaymentPath { // If the amount transferred by the path is updated, the fees should be adjusted. Any other way // to change fees may result in an inconsistency. // - // Sometimes we call this function right after constructing a path which has inconsistent - // (in terms of reaching htlc_minimum_msat), so that this function puts the fees in order. - // In that case we call it on the "same" amount we initially allocated for this path, and which - // could have been reduced on the way. In that case, there is also a risk of exceeding - // available_liquidity inside this function, because the function is unaware of this bound. - // In our specific recomputation cases where we never increase the value the risk is pretty low. - // This function, however, does not support arbitrarily increasing the value being transferred, - // and the exception will be triggered. + // Sometimes we call this function right after constructing a path which is inconsistent in + // that it the value being transferred has decreased while we were doing path finding, leading + // to the fees being paid not lining up with the actual limits. + // + // Note that this function is not aware of the available_liquidity limit, and thus does not + // support increasing the value being transferred. fn update_value_and_recompute_fees(&mut self, value_msat: u64) { - assert!(value_msat <= self.hops.last().unwrap().route_hop.fee_msat); + assert!(value_msat <= self.hops.last().unwrap().0.fee_msat); let mut total_fee_paid_msat = 0 as u64; for i in (0..self.hops.len()).rev() { @@ -253,10 +267,10 @@ impl PaymentPath { // htlc_minimum_msat of the current channel. Last hop is handled separately. let mut cur_hop_fees_msat = 0; if !last_hop { - cur_hop_fees_msat = self.hops.get(i + 1).unwrap().hop_use_fee_msat; + cur_hop_fees_msat = self.hops.get(i + 1).unwrap().0.hop_use_fee_msat; } - let mut cur_hop = self.hops.get_mut(i).unwrap(); + let mut cur_hop = &mut self.hops.get_mut(i).unwrap().0; cur_hop.next_hops_fee_msat = total_fee_paid_msat; // Overpay in fees if we can't save these funds due to htlc_minimum_msat. // We try to account for htlc_minimum_msat in scoring (add_entry!), so that nodes don't @@ -280,11 +294,11 @@ impl PaymentPath { if last_hop { // Final hop is a special case: it usually has just value_msat (by design), but also // it still could overpay for the htlc_minimum_msat. - cur_hop.route_hop.fee_msat = cur_hop_transferred_amount_msat; + cur_hop.fee_msat = cur_hop_transferred_amount_msat; } else { // Propagate updated fees for the use of the channels to one hop back, where they // will be actually paid (fee_msat). The last hop is handled above separately. - cur_hop.route_hop.fee_msat = cur_hop_fees_msat; + cur_hop.fee_msat = cur_hop_fees_msat; } // Fee for the use of the current hop which will be deducted on the previous hop. @@ -339,7 +353,7 @@ fn compute_fees(amount_msat: u64, channel_fees: RoutingFees) -> Option { /// equal), however the enabled/disabled bit on such channels as well as the /// htlc_minimum_msat/htlc_maximum_msat *are* checked as they may change based on the receiving node. pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, payee: &PublicKey, payee_features: Option, first_hops: Option<&[&ChannelDetails]>, - last_hops: &[&RouteHint], final_value_msat: u64, final_cltv: u32, logger: L) -> Result where L::Target: Logger { + last_hops: &[&RouteHintHop], final_value_msat: u64, final_cltv: u32, logger: L) -> Result where L::Target: Logger { // TODO: Obviously *only* using total fee cost sucks. We should consider weighting by // uptime/success in using a node in the past. if *payee == *our_node_id { @@ -430,22 +444,6 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye } }; - let mut targets = BinaryHeap::new(); //TODO: Do we care about switching to eg Fibbonaci heap? - let mut dist = HashMap::with_capacity(network.get_nodes().len()); - - // During routing, if we ignore a path due to an htlc_minimum_msat limit, we set this, - // indicating that we may wish to try again with a higher value, potentially paying to meet an - // htlc_minimum with extra fees while still finding a cheaper path. - let mut hit_minimum_limit; - - // When arranging a route, we select multiple paths so that we can make a multi-path payment. - // We start with a path_value of the exact amount we want, and if that generates a route we may - // return it immediately. Otherwise, we don't stop searching for paths until we have 3x the - // amount we want in total across paths, selecting the best subset at the end. - const ROUTE_CAPACITY_PROVISION_FACTOR: u64 = 3; - let recommended_value_msat = final_value_msat * ROUTE_CAPACITY_PROVISION_FACTOR as u64; - let mut path_value_msat = final_value_msat; - // Allow MPP only if we have a features set from somewhere that indicates the payee supports // it. If the payee supports it they're supposed to include it in the invoice, so that should // work reliably. @@ -461,25 +459,50 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // Prepare the data we'll use for payee-to-payer search by // inserting first hops suggested by the caller as targets. // Our search will then attempt to reach them while traversing from the payee node. - let mut first_hop_targets = HashMap::with_capacity(if first_hops.is_some() { first_hops.as_ref().unwrap().len() } else { 0 }); + let mut first_hop_targets: HashMap<_, (_, ChannelFeatures, _, NodeFeatures)> = + HashMap::with_capacity(if first_hops.is_some() { first_hops.as_ref().unwrap().len() } else { 0 }); if let Some(hops) = first_hops { for chan in hops { let short_channel_id = chan.short_channel_id.expect("first_hops should be filled in with usable channels, not pending ones"); if chan.remote_network_id == *our_node_id { return Err(LightningError{err: "First hop cannot have our_node_id as a destination.".to_owned(), action: ErrorAction::IgnoreError}); } - first_hop_targets.insert(chan.remote_network_id, (short_channel_id, chan.counterparty_features.clone(), chan.outbound_capacity_msat)); + first_hop_targets.insert(chan.remote_network_id, (short_channel_id, chan.counterparty_features.to_context(), chan.outbound_capacity_msat, chan.counterparty_features.to_context())); } if first_hop_targets.is_empty() { return Err(LightningError{err: "Cannot route when there are no outbound routes away from us".to_owned(), action: ErrorAction::IgnoreError}); } } + let empty_channel_features = ChannelFeatures::empty(); + + // The main heap containing all candidate next-hops sorted by their score (max(A* 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. + let mut targets = BinaryHeap::new(); + + // Map from node_id to information about the best current path to that node, including feerate + // information. + let mut dist = HashMap::with_capacity(network.get_nodes().len()); + + // During routing, if we ignore a path due to an htlc_minimum_msat limit, we set this, + // indicating that we may wish to try again with a higher value, potentially paying to meet an + // htlc_minimum with extra fees while still finding a cheaper path. + let mut hit_minimum_limit; + + // When arranging a route, we select multiple paths so that we can make a multi-path payment. + // We start with a path_value of the exact amount we want, and if that generates a route we may + // return it immediately. Otherwise, we don't stop searching for paths until we have 3x the + // amount we want in total across paths, selecting the best subset at the end. + const ROUTE_CAPACITY_PROVISION_FACTOR: u64 = 3; + let recommended_value_msat = final_value_msat * ROUTE_CAPACITY_PROVISION_FACTOR as u64; + let mut path_value_msat = final_value_msat; + // We don't want multiple paths (as per MPP) share liquidity of the same channels. // This map allows paths to be aware of the channel use by other paths in the same call. // This would help to make a better path finding decisions and not "overbook" channels. // It is unaware of the directions (except for `outbound_capacity_msat` in `first_hops`). - let mut bookkeeped_channels_liquidity_available_msat = HashMap::new(); + let mut bookkeeped_channels_liquidity_available_msat = HashMap::with_capacity(network.get_nodes().len()); // Keeping track of how much value we already collected across other paths. Helps to decide: // - how much a new path should be transferring (upper bound); @@ -597,14 +620,11 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye fee_proportional_millionths = fees.proportional_millionths; } PathBuildingHop { - route_hop: RouteHop { - pubkey: $dest_node_id.clone(), - node_features: NodeFeatures::empty(), - short_channel_id: 0, - channel_features: $chan_features.clone(), - fee_msat: 0, - cltv_expiry_delta: 0, - }, + pubkey: $dest_node_id.clone(), + short_channel_id: 0, + channel_features: $chan_features, + fee_msat: 0, + cltv_expiry_delta: 0, src_lowest_inbound_fees: RoutingFees { base_msat: fee_base_msat, proportional_millionths: fee_proportional_millionths, @@ -615,87 +635,127 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye total_fee_msat: u64::max_value(), htlc_minimum_msat: $directional_info.htlc_minimum_msat, path_htlc_minimum_msat, + was_processed: false, + #[cfg(any(test, feature = "fuzztarget"))] + value_contribution_msat, } }); - let mut hop_use_fee_msat = 0; - let mut total_fee_msat = $next_hops_fee_msat; - - // 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 { - match compute_fees(amount_to_transfer_over_msat, $directional_info.fees) { - // max_value means we'll always fail - // the old_entry.total_fee_msat > total_fee_msat check - None => total_fee_msat = u64::max_value(), - Some(fee_msat) => { - hop_use_fee_msat = fee_msat; - total_fee_msat += hop_use_fee_msat; - // When calculating the lowest inbound fees to a node, we - // calculate fees here not based on the actual value we think - // will flow over this channel, but on the minimum value that - // we'll accept flowing over it. The minimum accepted value - // is a constant through each path collection run, ensuring - // consistent basis. Otherwise we may later find a - // different path to the source node that is more expensive, - // but which we consider to be cheaper because we are capacity - // constrained and the relative fee becomes lower. - match compute_fees(minimal_value_contribution_msat, old_entry.src_lowest_inbound_fees) - .map(|a| a.checked_add(total_fee_msat)) { - Some(Some(v)) => { - total_fee_msat = v; - }, - _ => { - total_fee_msat = u64::max_value(); - } - }; - } - } + #[allow(unused_mut)] // We only use the mut in cfg(test) + let mut should_process = !old_entry.was_processed; + #[cfg(any(test, feature = "fuzztarget"))] + { + // In test/fuzzing builds, we do extra checks to make sure the skipping + // of already-seen nodes only happens in cases we expect (see below). + if !should_process { should_process = true; } } - let new_graph_node = RouteGraphNode { - pubkey: $src_node_id, - lowest_fee_to_peer_through_node: total_fee_msat, - lowest_fee_to_node: $next_hops_fee_msat as u64 + hop_use_fee_msat, - value_contribution_msat: value_contribution_msat, - path_htlc_minimum_msat, - }; + if should_process { + let mut hop_use_fee_msat = 0; + let mut total_fee_msat = $next_hops_fee_msat; + + // 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 { + match compute_fees(amount_to_transfer_over_msat, $directional_info.fees) { + // max_value means we'll always fail + // the old_entry.total_fee_msat > total_fee_msat check + None => total_fee_msat = u64::max_value(), + Some(fee_msat) => { + hop_use_fee_msat = fee_msat; + total_fee_msat += hop_use_fee_msat; + // When calculating the lowest inbound fees to a node, we + // calculate fees here not based on the actual value we think + // will flow over this channel, but on the minimum value that + // we'll accept flowing over it. The minimum accepted value + // is a constant through each path collection run, ensuring + // consistent basis. Otherwise we may later find a + // different path to the source node that is more expensive, + // but which we consider to be cheaper because we are capacity + // constrained and the relative fee becomes lower. + match compute_fees(minimal_value_contribution_msat, old_entry.src_lowest_inbound_fees) + .map(|a| a.checked_add(total_fee_msat)) { + Some(Some(v)) => { + total_fee_msat = v; + }, + _ => { + total_fee_msat = u64::max_value(); + } + }; + } + } + } - // Update the way of reaching $src_node_id with the given $chan_id (from $dest_node_id), - // if this way is cheaper than the already known - // (considering the cost to "reach" this channel from the route destination, - // the cost of using this channel, - // and the cost of routing to the source node of this channel). - // Also, consider that htlc_minimum_msat_difference, because we might end up - // paying it. Consider the following exploit: - // we use 2 paths to transfer 1.5 BTC. One of them is 0-fee normal 1 BTC path, - // and for the other one we picked a 1sat-fee path with htlc_minimum_msat of - // 1 BTC. Now, since the latter is more expensive, we gonna try to cut it - // by 0.5 BTC, but then match htlc_minimum_msat by paying a fee of 0.5 BTC - // to this channel. - // Ideally the scoring could be smarter (e.g. 0.5*htlc_minimum_msat here), - // but it may require additional tracking - we don't want to double-count - // the fees included in $next_hops_path_htlc_minimum_msat, but also - // can't use something that may decrease on future hops. - let old_cost = cmp::max(old_entry.total_fee_msat, old_entry.path_htlc_minimum_msat); - let new_cost = cmp::max(total_fee_msat, path_htlc_minimum_msat); - - if new_cost < old_cost { - targets.push(new_graph_node); - old_entry.next_hops_fee_msat = $next_hops_fee_msat; - old_entry.hop_use_fee_msat = hop_use_fee_msat; - old_entry.total_fee_msat = total_fee_msat; - old_entry.route_hop = RouteHop { - pubkey: $dest_node_id.clone(), - node_features: NodeFeatures::empty(), - short_channel_id: $chan_id.clone(), - channel_features: $chan_features.clone(), - fee_msat: 0, // This value will be later filled with hop_use_fee_msat of the following channel - cltv_expiry_delta: $directional_info.cltv_expiry_delta as u32, + let new_graph_node = RouteGraphNode { + pubkey: $src_node_id, + lowest_fee_to_peer_through_node: total_fee_msat, + lowest_fee_to_node: $next_hops_fee_msat as u64 + hop_use_fee_msat, + value_contribution_msat: value_contribution_msat, + path_htlc_minimum_msat, }; - old_entry.channel_fees = $directional_info.fees; - old_entry.htlc_minimum_msat = $directional_info.htlc_minimum_msat; - old_entry.path_htlc_minimum_msat = path_htlc_minimum_msat; + + // Update the way of reaching $src_node_id with the given $chan_id (from $dest_node_id), + // if this way is cheaper than the already known + // (considering the cost to "reach" this channel from the route destination, + // the cost of using this channel, + // and the cost of routing to the source node of this channel). + // Also, consider that htlc_minimum_msat_difference, because we might end up + // paying it. Consider the following exploit: + // we use 2 paths to transfer 1.5 BTC. One of them is 0-fee normal 1 BTC path, + // and for the other one we picked a 1sat-fee path with htlc_minimum_msat of + // 1 BTC. Now, since the latter is more expensive, we gonna try to cut it + // by 0.5 BTC, but then match htlc_minimum_msat by paying a fee of 0.5 BTC + // to this channel. + // Ideally the scoring could be smarter (e.g. 0.5*htlc_minimum_msat here), + // but it may require additional tracking - we don't want to double-count + // the fees included in $next_hops_path_htlc_minimum_msat, but also + // can't use something that may decrease on future hops. + let old_cost = cmp::max(old_entry.total_fee_msat, old_entry.path_htlc_minimum_msat); + let new_cost = cmp::max(total_fee_msat, path_htlc_minimum_msat); + + if !old_entry.was_processed && new_cost < old_cost { + targets.push(new_graph_node); + old_entry.next_hops_fee_msat = $next_hops_fee_msat; + old_entry.hop_use_fee_msat = hop_use_fee_msat; + old_entry.total_fee_msat = total_fee_msat; + old_entry.pubkey = $dest_node_id.clone(); + old_entry.short_channel_id = $chan_id.clone(); + old_entry.channel_features = $chan_features; + old_entry.fee_msat = 0; // This value will be later filled with hop_use_fee_msat of the following channel + old_entry.cltv_expiry_delta = $directional_info.cltv_expiry_delta as u32; + old_entry.channel_fees = $directional_info.fees; + old_entry.htlc_minimum_msat = $directional_info.htlc_minimum_msat; + old_entry.path_htlc_minimum_msat = path_htlc_minimum_msat; + #[cfg(any(test, feature = "fuzztarget"))] + { + old_entry.value_contribution_msat = value_contribution_msat; + } + } else if old_entry.was_processed && new_cost < old_cost { + #[cfg(any(test, feature = "fuzztarget"))] + { + // If we're skipping processing a node which was previously + // processed even though we found another path to it with a + // cheaper fee, check that it was because the second path we + // found (which we are processing now) has a lower value + // contribution due to an HTLC minimum limit. + // + // e.g. take a graph with two paths from node 1 to node 2, one + // through channel A, and one through channel B. Channel A and + // B are both in the to-process heap, with their scores set by + // a higher htlc_minimum than fee. + // Channel A is processed first, and the channels onwards from + // node 1 are added to the to-process heap. Thereafter, we pop + // Channel B off of the heap, note that it has a much more + // restrictive htlc_maximum_msat, and recalculate the fees for + // all of node 1's channels using the new, reduced, amount. + // + // This would be bogus - we'd be selecting a higher-fee path + // with a lower htlc_maximum_msat instead of the one we'd + // already decided to use. + debug_assert!(path_htlc_minimum_msat < old_entry.path_htlc_minimum_msat); + debug_assert!(value_contribution_msat < old_entry.value_contribution_msat); + } + } } } } @@ -703,6 +763,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye }; } + let empty_node_features = NodeFeatures::empty(); // Find ways (channels with destination) to reach a given node and store them // in the corresponding data structures (routing graph etc). // $fee_to_target_msat represents how much it costs to reach to this node from the payee, @@ -710,40 +771,52 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // 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 ) => { - if first_hops.is_some() { - if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat)) = first_hop_targets.get(&$node_id) { - add_entry!(first_hop, *our_node_id, $node_id, dummy_directional_info, Some(outbound_capacity_msat / 1000), features.to_context(), $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + let skip_node = if let Some(elem) = dist.get_mut($node_id) { + let was_processed = elem.was_processed; + elem.was_processed = true; + 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. + assert_eq!($node_id, payee); + false + }; + + if !skip_node { + if first_hops.is_some() { + if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat, _)) = first_hop_targets.get(&$node_id) { + add_entry!(first_hop, *our_node_id, $node_id, dummy_directional_info, Some(outbound_capacity_msat / 1000), features, $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + } } - } - let features; - if let Some(node_info) = $node.announcement_info.as_ref() { - features = node_info.features.clone(); - } else { - features = NodeFeatures::empty(); - } + let features = if let Some(node_info) = $node.announcement_info.as_ref() { + &node_info.features + } else { + &empty_node_features + }; - if !features.requires_unknown_bits() { - for chan_id in $node.channels.iter() { - let chan = network.get_channels().get(chan_id).unwrap(); - if !chan.features.requires_unknown_bits() { - if chan.node_one == *$node_id { - // ie $node is one, ie next hop in A* is two, via the two_to_one channel - if first_hops.is_none() || chan.node_two != *our_node_id { - if let Some(two_to_one) = chan.two_to_one.as_ref() { - if two_to_one.enabled { - add_entry!(chan_id, chan.node_two, chan.node_one, two_to_one, chan.capacity_sats, chan.features, $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + if !features.requires_unknown_bits() { + for chan_id in $node.channels.iter() { + let chan = network.get_channels().get(chan_id).unwrap(); + if !chan.features.requires_unknown_bits() { + if chan.node_one == *$node_id { + // ie $node is one, ie next hop in A* is two, via the two_to_one channel + if first_hops.is_none() || chan.node_two != *our_node_id { + if let Some(two_to_one) = chan.two_to_one.as_ref() { + if two_to_one.enabled { + add_entry!(chan_id, chan.node_two, chan.node_one, two_to_one, chan.capacity_sats, &chan.features, $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + } } } - } - } else { - if first_hops.is_none() || chan.node_one != *our_node_id { - if let Some(one_to_two) = chan.one_to_two.as_ref() { - if one_to_two.enabled { - add_entry!(chan_id, chan.node_one, chan.node_two, one_to_two, chan.capacity_sats, chan.features, $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + } else { + if first_hops.is_none() || chan.node_one != *our_node_id { + if let Some(one_to_two) = chan.one_to_two.as_ref() { + if one_to_two.enabled { + add_entry!(chan_id, chan.node_one, chan.node_two, one_to_two, chan.capacity_sats, &chan.features, $fee_to_target_msat, $next_hops_value_contribution, $next_hops_path_htlc_minimum_msat); + } } } - } } } @@ -766,8 +839,8 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // If first hop is a private channel and the only way to reach the payee, this is the only // place where it could be added. if first_hops.is_some() { - if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat)) = first_hop_targets.get(&payee) { - add_entry!(first_hop, *our_node_id, payee, dummy_directional_info, Some(outbound_capacity_msat / 1000), features.to_context(), 0, path_value_msat, 0); + if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat, _)) = first_hop_targets.get(&payee) { + add_entry!(first_hop, *our_node_id, payee, dummy_directional_info, Some(outbound_capacity_msat / 1000), features, 0, path_value_msat, 0); } } @@ -790,7 +863,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // it matters only if the fees are exactly the same. for hop in last_hops.iter() { let have_hop_src_in_graph = - if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat)) = first_hop_targets.get(&hop.src_node_id) { + if let Some(&(ref first_hop, ref features, ref outbound_capacity_msat, _)) = first_hop_targets.get(&hop.src_node_id) { // If this hop connects to a node with which we have a direct channel, ignore // the network graph and add both the hop and our direct channel to // the candidate set. @@ -799,7 +872,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // bit lazy here. In the future, we should pull them out via our // ChannelManager, but there's no reason to waste the space until we // need them. - add_entry!(first_hop, *our_node_id , hop.src_node_id, dummy_directional_info, Some(outbound_capacity_msat / 1000), features.to_context(), 0, path_value_msat, 0); + add_entry!(first_hop, *our_node_id , hop.src_node_id, dummy_directional_info, Some(outbound_capacity_msat / 1000), features, 0, path_value_msat, 0); true } else { // In any other case, only add the hop if the source is in the regular network @@ -819,7 +892,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye htlc_maximum_msat: hop.htlc_maximum_msat, fees: hop.fees, }; - add_entry!(hop.short_channel_id, hop.src_node_id, payee, directional_info, None::, ChannelFeatures::empty(), 0, path_value_msat, 0); + add_entry!(hop.short_channel_id, hop.src_node_id, payee, directional_info, None::, &empty_channel_features, 0, path_value_msat, 0); } } @@ -842,34 +915,34 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // traversing the graph and arrange the path out of what we found. if pubkey == *our_node_id { let mut new_entry = dist.remove(&our_node_id).unwrap(); - let mut ordered_hops = vec!(new_entry.clone()); + let mut ordered_hops = vec!((new_entry.clone(), NodeFeatures::empty())); 'path_walk: loop { - if let Some(&(_, ref features, _)) = first_hop_targets.get(&ordered_hops.last().unwrap().route_hop.pubkey) { - ordered_hops.last_mut().unwrap().route_hop.node_features = features.to_context(); - } else if let Some(node) = network.get_nodes().get(&ordered_hops.last().unwrap().route_hop.pubkey) { + if let Some(&(_, _, _, ref features)) = first_hop_targets.get(&ordered_hops.last().unwrap().0.pubkey) { + ordered_hops.last_mut().unwrap().1 = features.clone(); + } else if let Some(node) = network.get_nodes().get(&ordered_hops.last().unwrap().0.pubkey) { if let Some(node_info) = node.announcement_info.as_ref() { - ordered_hops.last_mut().unwrap().route_hop.node_features = node_info.features.clone(); + ordered_hops.last_mut().unwrap().1 = node_info.features.clone(); } else { - ordered_hops.last_mut().unwrap().route_hop.node_features = NodeFeatures::empty(); + ordered_hops.last_mut().unwrap().1 = NodeFeatures::empty(); } } else { // We should be able to fill in features for everything except the last // hop, if the last hop was provided via a BOLT 11 invoice (though we // should be able to extend it further as BOLT 11 does have feature // flags for the last hop node itself). - assert!(ordered_hops.last().unwrap().route_hop.pubkey == *payee); + assert!(ordered_hops.last().unwrap().0.pubkey == *payee); } // Means we succesfully traversed from the payer to the payee, now // 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().route_hop.pubkey == *payee { + if ordered_hops.last().unwrap().0.pubkey == *payee { break 'path_walk; } - new_entry = match dist.remove(&ordered_hops.last().unwrap().route_hop.pubkey) { + new_entry = match dist.remove(&ordered_hops.last().unwrap().0.pubkey) { 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!). @@ -878,13 +951,13 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // We "propagate" the fees one hop backward (topologically) here, // so that fees paid for a HTLC forwarding on the current channel are // associated with the previous channel (where they will be subtracted). - ordered_hops.last_mut().unwrap().route_hop.fee_msat = new_entry.hop_use_fee_msat; - ordered_hops.last_mut().unwrap().route_hop.cltv_expiry_delta = new_entry.route_hop.cltv_expiry_delta; - ordered_hops.push(new_entry.clone()); + ordered_hops.last_mut().unwrap().0.fee_msat = new_entry.hop_use_fee_msat; + ordered_hops.last_mut().unwrap().0.cltv_expiry_delta = new_entry.cltv_expiry_delta; + ordered_hops.push((new_entry.clone(), NodeFeatures::empty())); } - ordered_hops.last_mut().unwrap().route_hop.fee_msat = value_contribution_msat; - ordered_hops.last_mut().unwrap().hop_use_fee_msat = 0; - ordered_hops.last_mut().unwrap().route_hop.cltv_expiry_delta = final_cltv; + ordered_hops.last_mut().unwrap().0.fee_msat = value_contribution_msat; + ordered_hops.last_mut().unwrap().0.hop_use_fee_msat = 0; + ordered_hops.last_mut().unwrap().0.cltv_expiry_delta = final_cltv; let mut payment_path = PaymentPath {hops: ordered_hops}; @@ -905,16 +978,11 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // 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; - for payment_hop in payment_path.hops.iter() { - let channel_liquidity_available_msat = bookkeeped_channels_liquidity_available_msat.get_mut(&payment_hop.route_hop.short_channel_id).unwrap(); + for (payment_hop, _) in payment_path.hops.iter() { + let channel_liquidity_available_msat = bookkeeped_channels_liquidity_available_msat.get_mut(&payment_hop.short_channel_id).unwrap(); let mut spent_on_hop_msat = value_contribution_msat; let next_hops_fee_msat = payment_hop.next_hops_fee_msat; spent_on_hop_msat += next_hops_fee_msat; - if *channel_liquidity_available_msat < spent_on_hop_msat { - // This should not happen because we do recompute fees right before, - // trying to avoid cases when a hop is not usable due to the fee situation. - break 'path_construction; - } if spent_on_hop_msat == *channel_liquidity_available_msat { // If this path used all of this channel's available liquidity, we know // this path will not be selected again in the next loop iteration. @@ -927,7 +995,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // we'll probably end up picking the same path again on the next iteration. // Decrease the available liquidity of a hop in the middle of the path. let victim_liquidity = bookkeeped_channels_liquidity_available_msat.get_mut( - &payment_path.hops[(payment_path.hops.len() - 1) / 2].route_hop.short_channel_id).unwrap(); + &payment_path.hops[(payment_path.hops.len() - 1) / 2].0.short_channel_id).unwrap(); *victim_liquidity = 0; } @@ -942,6 +1010,11 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye break 'path_construction; } + // If we found a path back to the payee, we shouldn't try to process it again. This is + // the equivalent of the `elem.was_processed` check in + // add_entries_to_cheapest_to_target_node!() (see comment there for more info). + if pubkey == *payee { continue 'path_construction; } + // Otherwise, since the current target node is not us, // keep "unrolling" the payment graph from payee to payer by // finding a way to reach the current target from the payer side. @@ -1047,7 +1120,7 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye // Now, substract the overpaid value from the most-expensive path. // TODO: this could also be optimized by also sorting by feerate_per_sat_routed, // so that the sender pays less fees overall. And also htlc_minimum_msat. - cur_route.sort_by_key(|path| { path.hops.iter().map(|hop| hop.channel_fees.proportional_millionths as u64).sum::() }); + cur_route.sort_by_key(|path| { path.hops.iter().map(|hop| hop.0.channel_fees.proportional_millionths as u64).sum::() }); let expensive_payment_path = cur_route.first_mut().unwrap(); // We already dropped all the small channels above, meaning all the // remaining channels are larger than remaining overpaid_value_msat. @@ -1065,7 +1138,16 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye drawn_routes.sort_by_key(|paths| paths.iter().map(|path| path.get_total_fee_paid_msat()).sum::()); let mut selected_paths = Vec::>::new(); for payment_path in drawn_routes.first().unwrap() { - selected_paths.push(payment_path.hops.iter().map(|payment_hop| payment_hop.route_hop.clone()).collect()); + selected_paths.push(payment_path.hops.iter().map(|(payment_hop, node_features)| { + RouteHop { + pubkey: payment_hop.pubkey, + node_features: node_features.clone(), + short_channel_id: payment_hop.short_channel_id, + channel_features: payment_hop.channel_features.clone(), + fee_msat: payment_hop.fee_msat, + cltv_expiry_delta: payment_hop.cltv_expiry_delta, + } + }).collect()); } if let Some(features) = &payee_features { @@ -1081,8 +1163,9 @@ pub fn get_route(our_node_id: &PublicKey, network: &NetworkGraph, paye #[cfg(test)] mod tests { - use routing::router::{get_route, RouteHint, RoutingFees}; + use routing::router::{get_route, RouteHintHop, RoutingFees}; use routing::network_graph::{NetworkGraph, NetGraphMsgHandler}; + use chain::transaction::OutPoint; use ln::features::{ChannelFeatures, InitFeatures, InvoiceFeatures, NodeFeatures}; use ln::msgs::{ErrorAction, LightningError, OptionalField, UnsignedChannelAnnouncement, ChannelAnnouncement, RoutingMessageHandler, NodeAnnouncement, UnsignedNodeAnnouncement, ChannelUpdate, UnsignedChannelUpdate}; @@ -1543,6 +1626,7 @@ mod tests { let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(2), remote_network_id: our_id, counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -1550,7 +1634,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 100000, inbound_capacity_msat: 100000, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; @@ -1861,6 +1946,7 @@ mod tests { // If we specify a channel to node7, that overrides our local channel view and that gets used let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: nodes[7].clone(), counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -1868,7 +1954,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 250_000_000, inbound_capacity_msat: 0, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; let route = get_route(&our_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2], None, Some(&our_chans.iter().collect::>()), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); @@ -1909,6 +1996,7 @@ mod tests { // If we specify a channel to node7, that overrides our local channel view and that gets used let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: nodes[7].clone(), counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -1916,7 +2004,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 250_000_000, inbound_capacity_msat: 0, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; let route = get_route(&our_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2], None, Some(&our_chans.iter().collect::>()), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); @@ -1974,6 +2063,7 @@ mod tests { // If we specify a channel to node7, that overrides our local channel view and that gets used let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: nodes[7].clone(), counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -1981,7 +2071,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 250_000_000, inbound_capacity_msat: 0, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; let route = get_route(&our_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2], None, Some(&our_chans.iter().collect::>()), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); @@ -2002,19 +2093,19 @@ mod tests { assert_eq!(route.paths[0][1].channel_features.le_flags(), &id_to_feature_flags(13)); } - fn last_hops(nodes: &Vec) -> Vec { + fn last_hops(nodes: &Vec) -> Vec { let zero_fees = RoutingFees { base_msat: 0, proportional_millionths: 0, }; - vec!(RouteHint { + vec!(RouteHintHop { src_node_id: nodes[3].clone(), short_channel_id: 8, fees: zero_fees, cltv_expiry_delta: (8 << 8) | 1, htlc_minimum_msat: None, htlc_maximum_msat: None, - }, RouteHint { + }, RouteHintHop { src_node_id: nodes[4].clone(), short_channel_id: 9, fees: RoutingFees { @@ -2024,7 +2115,7 @@ mod tests { cltv_expiry_delta: (9 << 8) | 1, htlc_minimum_msat: None, htlc_maximum_msat: None, - }, RouteHint { + }, RouteHintHop { src_node_id: nodes[5].clone(), short_channel_id: 10, fees: zero_fees, @@ -2042,7 +2133,7 @@ mod tests { // Simple test across 2, 3, 5, and 4 via a last_hop channel // First check that lst hop can't have its source as the payee. - let invalid_last_hop = RouteHint { + let invalid_last_hop = RouteHintHop { src_node_id: nodes[6], short_channel_id: 8, fees: RoutingFees { @@ -2111,6 +2202,7 @@ mod tests { // Simple test with outbound channel to 4 to test that last_hops and first_hops connect let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: nodes[3].clone(), counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -2118,7 +2210,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 250_000_000, inbound_capacity_msat: 0, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; let mut last_hops = last_hops(&nodes); @@ -2227,7 +2320,7 @@ mod tests { let target_node_id = PublicKey::from_secret_key(&Secp256k1::new(), &SecretKey::from_slice(&hex::decode(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 = vec![RouteHint { + let last_hops = vec![RouteHintHop { src_node_id: middle_node_id, short_channel_id: 8, fees: RoutingFees { @@ -2240,6 +2333,7 @@ mod tests { }]; let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: middle_node_id, counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -2247,7 +2341,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 100000, inbound_capacity_msat: 100000, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; let route = get_route(&source_node_id, &NetworkGraph::new(genesis_block(Network::Testnet).header.block_hash()), &target_node_id, None, Some(&our_chans.iter().collect::>()), &last_hops.iter().collect::>(), 100, 42, Arc::new(test_utils::TestLogger::new())).unwrap(); @@ -2372,6 +2467,7 @@ mod tests { // Now, limit the first_hop by the outbound_capacity_msat of 200_000 sats. let our_chans = vec![channelmanager::ChannelDetails { channel_id: [0; 32], + funding_txo: Some(OutPoint { txid: bitcoin::Txid::from_slice(&[0; 32]).unwrap(), index: 0 }), short_channel_id: Some(42), remote_network_id: nodes[0].clone(), counterparty_features: InitFeatures::from_le_bytes(vec![0b11]), @@ -2379,7 +2475,8 @@ mod tests { user_id: 0, outbound_capacity_msat: 200_000_000, inbound_capacity_msat: 0, - is_live: true, + is_outbound: true, is_funding_locked: true, + is_usable: true, is_public: true, counterparty_forwarding_info: None, }]; @@ -3748,6 +3845,92 @@ mod tests { assert_eq!(route.paths[0][1].channel_features.le_flags(), &id_to_feature_flags(13)); } } + + use std::fs::File; + use util::ser::Readable; + /// Tries to open a network graph file, or panics with a URL to fetch it. + pub(super) fn get_route_file() -> Result { + let res = File::open("net_graph-2021-02-12.bin") // By default we're run in RL/lightning + .or_else(|_| File::open("lightning/net_graph-2021-02-12.bin")) // We may be run manually in RL/ + .or_else(|_| { // Fall back to guessing based on the binary location + // path is likely something like .../rust-lightning/target/debug/deps/lightning-... + let mut path = std::env::current_exe().unwrap(); + path.pop(); // lightning-... + path.pop(); // deps + path.pop(); // debug + path.pop(); // target + path.push("lightning"); + path.push("net_graph-2021-02-12.bin"); + eprintln!("{}", path.to_str().unwrap()); + File::open(path) + }); + #[cfg(require_route_graph_test)] + return Ok(res.expect("Didn't have route graph and was configured to require it")); + #[cfg(not(require_route_graph_test))] + return res; + } + + pub(super) fn random_init_seed() -> u64 { + // Because the default HashMap in std pulls OS randomness, we can use it as a (bad) RNG. + use core::hash::{BuildHasher, Hasher}; + let seed = std::collections::hash_map::RandomState::new().build_hasher().finish(); + println!("Using seed of {}", seed); + seed + } + + #[test] + fn generate_routes() { + let mut d = match get_route_file() { + Ok(f) => f, + Err(_) => { + eprintln!("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); + return; + }, + }; + let graph = NetworkGraph::read(&mut d).unwrap(); + + // First, get 100 (source, destination) pairs for which route-getting actually succeeds... + let mut seed = random_init_seed() as usize; + 'load_endpoints: for _ in 0..10 { + loop { + seed = seed.overflowing_mul(0xdeadbeef).0; + let src = graph.get_nodes().keys().skip(seed % graph.get_nodes().len()).next().unwrap(); + seed = seed.overflowing_mul(0xdeadbeef).0; + let dst = graph.get_nodes().keys().skip(seed % graph.get_nodes().len()).next().unwrap(); + let amt = seed as u64 % 200_000_000; + if get_route(src, &graph, dst, None, None, &[], amt, 42, &test_utils::TestLogger::new()).is_ok() { + continue 'load_endpoints; + } + } + } + } + + #[test] + fn generate_routes_mpp() { + let mut d = match get_route_file() { + Ok(f) => f, + Err(_) => { + eprintln!("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); + return; + }, + }; + let graph = NetworkGraph::read(&mut d).unwrap(); + + // First, get 100 (source, destination) pairs for which route-getting actually succeeds... + let mut seed = random_init_seed() as usize; + 'load_endpoints: for _ in 0..10 { + loop { + seed = seed.overflowing_mul(0xdeadbeef).0; + let src = graph.get_nodes().keys().skip(seed % graph.get_nodes().len()).next().unwrap(); + seed = seed.overflowing_mul(0xdeadbeef).0; + let dst = graph.get_nodes().keys().skip(seed % graph.get_nodes().len()).next().unwrap(); + let amt = seed as u64 % 200_000_000; + if get_route(src, &graph, dst, Some(InvoiceFeatures::known()), None, &[], amt, 42, &test_utils::TestLogger::new()).is_ok() { + continue 'load_endpoints; + } + } + } + } } #[cfg(all(test, feature = "unstable"))] @@ -3755,7 +3938,6 @@ mod benches { use super::*; use util::logger::{Logger, Record}; - use std::fs::File; use test::Bencher; struct DummyLogger {} @@ -3765,7 +3947,8 @@ mod benches { #[bench] fn generate_routes(bench: &mut Bencher) { - let mut d = File::open("net_graph-2021-02-12.bin").expect("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); + let mut d = tests::get_route_file() + .expect("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); let graph = NetworkGraph::read(&mut d).unwrap(); // First, get 100 (source, destination) pairs for which route-getting actually succeeds... @@ -3796,7 +3979,8 @@ mod benches { #[bench] fn generate_mpp_routes(bench: &mut Bencher) { - let mut d = File::open("net_graph-2021-02-12.bin").expect("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); + let mut d = tests::get_route_file() + .expect("Please fetch https://bitcoin.ninja/ldk-net_graph-879e309c128-2020-02-12.bin and place it at lightning/net_graph-2021-02-12.bin"); let graph = NetworkGraph::read(&mut d).unwrap(); // First, get 100 (source, destination) pairs for which route-getting actually succeeds...