From e76ac4eff36e5e6131ce70743b16727436dacd28 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sat, 6 Jun 2020 20:51:41 -0400 Subject: [PATCH 01/16] Add default implementation for tracking metadata Adds NetworkTracker trait that allows users to implement interface between their metadata and their view of NetworkGraph. Users can implement their own metadata structs, but at a minimum will have to implement the UpdateMetadata trait (even if the functions do nothing). By default, this trait uses a new struct called DefaultMetadata which just tracks previously failed routes, and can find out if a route has previously failed. --- lightning/src/routing/network_graph.rs | 66 +++++++++++++++++++++++++- 1 file changed, 65 insertions(+), 1 deletion(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index 3168a1fd850..c2b323af180 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -13,6 +13,7 @@ use chain::chaininterface::{ChainError, ChainWatchInterface}; use ln::features::{ChannelFeatures, NodeFeatures}; use ln::msgs::{DecodeError,ErrorAction,LightningError,RoutingMessageHandler,NetAddress}; use ln::msgs; +use routing::router::RouteHop; use util::ser::{Writeable, Readable, Writer}; use util::logger::Logger; @@ -278,7 +279,6 @@ impl_writeable!(ChannelInfo, 0, { announcement_message }); - /// Fees for routing via a given channel or a node #[derive(Eq, PartialEq, Copy, Clone, Debug)] pub struct RoutingFees { @@ -428,6 +428,70 @@ impl Readable for NodeInfo { } } +/// Allows for updating user's network metadata. +pub trait UpdateMetadata { + /// Adds a failed route to track. If we see the route again, we'll reject it or we can take + /// some action (like set its fee to make route-finding not find that route again) + fn add_failed_route(&mut self, route: Vec>); + /// If a route starts working again, then we can take it off the failed route list. + fn remove_failed_route(&mut self, route: Vec>); + /// Returns true if a route is on the failed routes list, false otherwise. + fn check_route(&self, route: Vec>) -> bool; + /// Sets the channel fee penalty being tracked in the Metadata object. + fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64); + /// Gets a channel's fee penalty based on its channel_id (as stored in a NetworkGraph object). + fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64>; +} + +/// A default metadata object that is used to implement the default functionality for the +/// NetworkTracker trait. A user could make their own Metadata object and extend the +/// functionality of it by implementing other functions/traits for their metadata. +pub struct DefaultMetadata { + /// A lits of failed routes. Referenced by the failed route trackers, and sets channel fee + /// penalty to a high number if in trait + failed_routes: Vec>>, + /// Minimum fee willing to be paid to avoid using a given channel. Often, this is updated when + /// a channel ends up on a failed route. + channel_fee_penalty: BTreeMap, +} + +impl UpdateMetadata for DefaultMetadata { + fn add_failed_route(&mut self, route: Vec>) { self.failed_routes.push(route); } + fn remove_failed_route(&mut self, route: Vec>) { + self.failed_routes.retain(|item| item != &route); + } + fn check_route(&self, route: Vec>) -> bool { + self.failed_routes.contains(&route) + } + fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64) { self.channel_fee_penalty.insert(chan_id, fee_penalty); } + fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> { self.channel_fee_penalty.get(&chan_id) } +} + +/// Users store custom metadata about the network separately. This trait is implemented by users, who may use +/// the NetworkGraph to update whatever metadata they are storing about their view of the network. +pub trait NetworkTracker { + /// Return score for a given channel by using user-defined channel_scorers + fn calculate_minimum_fee_penalty_for_channel(&self, chan_id: u64, network_metadata: T) -> u64 { + let chan_score = network_metadata.get_channel_fee_penalty(chan_id); + if chan_score != None { + return *chan_score.unwrap(); + } else { + return 0; + } + } + + /// Store routes that have previously failed by adding them to a list being held in Metadata + fn track_previously_failed_route(&self, mut network_metadata: T, failed_route: Vec>) { + network_metadata.add_failed_route(failed_route); + } + + /// Returns true if this route was attempted previously and failed by searching in Metadata's + /// failed routes + fn check_route_for_previous_failure(&self, network_metadata: T, route: Vec>) -> bool { + network_metadata.check_route(route) + } +} + /// Represents the network as nodes and channels between them #[derive(PartialEq)] pub struct NetworkGraph { From 42f7d567e00e055816bdaf0f186b6af33a3656a6 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sun, 7 Jun 2020 21:08:01 -0400 Subject: [PATCH 02/16] Track failed portion of MPP, not entire MPP --- lightning/src/routing/network_graph.rs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index c2b323af180..0109a7d5b5f 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -432,11 +432,11 @@ impl Readable for NodeInfo { pub trait UpdateMetadata { /// Adds a failed route to track. If we see the route again, we'll reject it or we can take /// some action (like set its fee to make route-finding not find that route again) - fn add_failed_route(&mut self, route: Vec>); + fn add_failed_route(&mut self, route: Vec); /// If a route starts working again, then we can take it off the failed route list. - fn remove_failed_route(&mut self, route: Vec>); + fn remove_failed_route(&mut self, route: Vec); /// Returns true if a route is on the failed routes list, false otherwise. - fn check_route(&self, route: Vec>) -> bool; + fn check_route(&self, route: Vec) -> bool; /// Sets the channel fee penalty being tracked in the Metadata object. fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64); /// Gets a channel's fee penalty based on its channel_id (as stored in a NetworkGraph object). @@ -449,18 +449,18 @@ pub trait UpdateMetadata { pub struct DefaultMetadata { /// A lits of failed routes. Referenced by the failed route trackers, and sets channel fee /// penalty to a high number if in trait - failed_routes: Vec>>, + failed_routes: Vec>, /// Minimum fee willing to be paid to avoid using a given channel. Often, this is updated when /// a channel ends up on a failed route. channel_fee_penalty: BTreeMap, } impl UpdateMetadata for DefaultMetadata { - fn add_failed_route(&mut self, route: Vec>) { self.failed_routes.push(route); } - fn remove_failed_route(&mut self, route: Vec>) { + fn add_failed_route(&mut self, route: Vec) { self.failed_routes.push(route); } + fn remove_failed_route(&mut self, route: Vec) { self.failed_routes.retain(|item| item != &route); } - fn check_route(&self, route: Vec>) -> bool { + fn check_route(&self, route: Vec) -> bool { self.failed_routes.contains(&route) } fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64) { self.channel_fee_penalty.insert(chan_id, fee_penalty); } @@ -481,13 +481,13 @@ pub trait NetworkTracker { } /// Store routes that have previously failed by adding them to a list being held in Metadata - fn track_previously_failed_route(&self, mut network_metadata: T, failed_route: Vec>) { + fn track_previously_failed_route(&self, mut network_metadata: T, failed_route: Vec) { network_metadata.add_failed_route(failed_route); } /// Returns true if this route was attempted previously and failed by searching in Metadata's /// failed routes - fn check_route_for_previous_failure(&self, network_metadata: T, route: Vec>) -> bool { + fn check_route_for_previous_failure(&self, network_metadata: T, route: Vec) -> bool { network_metadata.check_route(route) } } From a424c63bd03d27768824a7e1647a32876af28cad Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sun, 7 Jun 2020 21:26:27 -0400 Subject: [PATCH 03/16] Remove failed route tracking methods --- lightning/src/routing/network_graph.rs | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index 0109a7d5b5f..9ebeca3d634 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -430,12 +430,7 @@ impl Readable for NodeInfo { /// Allows for updating user's network metadata. pub trait UpdateMetadata { - /// Adds a failed route to track. If we see the route again, we'll reject it or we can take - /// some action (like set its fee to make route-finding not find that route again) - fn add_failed_route(&mut self, route: Vec); - /// If a route starts working again, then we can take it off the failed route list. - fn remove_failed_route(&mut self, route: Vec); - /// Returns true if a route is on the failed routes list, false otherwise. + /// Checks if a route has failed previously fn check_route(&self, route: Vec) -> bool; /// Sets the channel fee penalty being tracked in the Metadata object. fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64); @@ -456,10 +451,6 @@ pub struct DefaultMetadata { } impl UpdateMetadata for DefaultMetadata { - fn add_failed_route(&mut self, route: Vec) { self.failed_routes.push(route); } - fn remove_failed_route(&mut self, route: Vec) { - self.failed_routes.retain(|item| item != &route); - } fn check_route(&self, route: Vec) -> bool { self.failed_routes.contains(&route) } @@ -480,11 +471,6 @@ pub trait NetworkTracker { } } - /// Store routes that have previously failed by adding them to a list being held in Metadata - fn track_previously_failed_route(&self, mut network_metadata: T, failed_route: Vec) { - network_metadata.add_failed_route(failed_route); - } - /// Returns true if this route was attempted previously and failed by searching in Metadata's /// failed routes fn check_route_for_previous_failure(&self, network_metadata: T, route: Vec) -> bool { From 51c8d1b705cc5ab7d395dac6cb681bbd04edb476 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sun, 7 Jun 2020 21:53:24 -0400 Subject: [PATCH 04/16] Remove functions that would never be called Also add route_succeeded() function which removes the successful route off the failed_route Vec. --- lightning/src/routing/network_graph.rs | 27 ++++++++++---------------- 1 file changed, 10 insertions(+), 17 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index 9ebeca3d634..cc72f795711 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -429,13 +429,11 @@ impl Readable for NodeInfo { } /// Allows for updating user's network metadata. -pub trait UpdateMetadata { - /// Checks if a route has failed previously - fn check_route(&self, route: Vec) -> bool; - /// Sets the channel fee penalty being tracked in the Metadata object. - fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64); +pub trait RouteFeePenalty { /// Gets a channel's fee penalty based on its channel_id (as stored in a NetworkGraph object). fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64>; + /// Informs metadata object that a route has successfully executed its payment. + fn route_succeeded(&mut self, route: Vec); } /// A default metadata object that is used to implement the default functionality for the @@ -450,17 +448,18 @@ pub struct DefaultMetadata { channel_fee_penalty: BTreeMap, } -impl UpdateMetadata for DefaultMetadata { - fn check_route(&self, route: Vec) -> bool { - self.failed_routes.contains(&route) - } - fn set_channel_fee_penalty(&mut self, chan_id: u64, fee_penalty: u64) { self.channel_fee_penalty.insert(chan_id, fee_penalty); } +impl RouteFeePenalty for DefaultMetadata { fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> { self.channel_fee_penalty.get(&chan_id) } + fn route_succeeded(&mut self, route: Vec) { + if self.failed_routes.contains(&route) { + self.failed_routes.retain(|item| item != &route); + } + } } /// Users store custom metadata about the network separately. This trait is implemented by users, who may use /// the NetworkGraph to update whatever metadata they are storing about their view of the network. -pub trait NetworkTracker { +pub trait NetworkTracker { /// Return score for a given channel by using user-defined channel_scorers fn calculate_minimum_fee_penalty_for_channel(&self, chan_id: u64, network_metadata: T) -> u64 { let chan_score = network_metadata.get_channel_fee_penalty(chan_id); @@ -470,12 +469,6 @@ pub trait NetworkTracker { return 0; } } - - /// Returns true if this route was attempted previously and failed by searching in Metadata's - /// failed routes - fn check_route_for_previous_failure(&self, network_metadata: T, route: Vec) -> bool { - network_metadata.check_route(route) - } } /// Represents the network as nodes and channels between them From 1a1dc96ef36d45911f1a35d5c2d307f6baf5bc81 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sun, 7 Jun 2020 22:21:04 -0400 Subject: [PATCH 05/16] Return u64::MAX if chan is on failed list Track the number of successes a failed channel needs to get off the "failed" list. If it is on the list, it penalty fee is u64::MAX. If route_success is called and the channel ID is on the route, its score is decremented until it hits 0, at which point it is removed from the failed list. --- lightning/src/routing/network_graph.rs | 33 +++++++++++++++++++------- 1 file changed, 24 insertions(+), 9 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index cc72f795711..3938a79549c 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -440,19 +440,34 @@ pub trait RouteFeePenalty { /// NetworkTracker trait. A user could make their own Metadata object and extend the /// functionality of it by implementing other functions/traits for their metadata. pub struct DefaultMetadata { - /// A lits of failed routes. Referenced by the failed route trackers, and sets channel fee - /// penalty to a high number if in trait - failed_routes: Vec>, - /// Minimum fee willing to be paid to avoid using a given channel. Often, this is updated when - /// a channel ends up on a failed route. - channel_fee_penalty: BTreeMap, + /// A lits of failed channels. Maps channel_id (as specified in the NetworkGraph object) to + /// the number of successful routes to participate before being removed from the list. All + /// channels in failed_channels are assumed to have a penalty of u64::max. + failed_channels: BTreeMap, } impl RouteFeePenalty for DefaultMetadata { - fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> { self.channel_fee_penalty.get(&chan_id) } + fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> { + if self.failed_channels.get(&chan_id) == None { + return Some(&0); + } else { + return Some(&u64::MAX); + } + } fn route_succeeded(&mut self, route: Vec) { - if self.failed_routes.contains(&route) { - self.failed_routes.retain(|item| item != &route); + for route_hop in route { + let chan_id = route_hop.short_channel_id; + let successes_needed = self.failed_channels.get(&chan_id); + if successes_needed == None { + self.failed_channels.insert(chan_id, 5); + } else { + let dec_successes_needed = successes_needed.unwrap() - 1; + if dec_successes_needed > 0 { + self.failed_channels.insert(chan_id, dec_successes_needed); + } else { + self.failed_channels.remove(&chan_id); + } + } } } } From 4664e99ff2fc56f8d323899f1df2a360f3b8d803 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Thu, 11 Jun 2020 20:54:40 -0400 Subject: [PATCH 06/16] Change output of get_channel_fee_penalty --- lightning/src/routing/network_graph.rs | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index 3938a79549c..e214c282783 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -431,7 +431,7 @@ impl Readable for NodeInfo { /// Allows for updating user's network metadata. pub trait RouteFeePenalty { /// Gets a channel's fee penalty based on its channel_id (as stored in a NetworkGraph object). - fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64>; + fn get_channel_fee_penalty(&self, chan_id: u64) -> u64; /// Informs metadata object that a route has successfully executed its payment. fn route_succeeded(&mut self, route: Vec); } @@ -447,11 +447,11 @@ pub struct DefaultMetadata { } impl RouteFeePenalty for DefaultMetadata { - fn get_channel_fee_penalty(&self, chan_id: u64) -> Option<&u64> { + fn get_channel_fee_penalty(&self, chan_id: u64) -> u64 { if self.failed_channels.get(&chan_id) == None { - return Some(&0); + return 0; } else { - return Some(&u64::MAX); + return u64::MAX; } } fn route_succeeded(&mut self, route: Vec) { @@ -477,12 +477,7 @@ impl RouteFeePenalty for DefaultMetadata { pub trait NetworkTracker { /// Return score for a given channel by using user-defined channel_scorers fn calculate_minimum_fee_penalty_for_channel(&self, chan_id: u64, network_metadata: T) -> u64 { - let chan_score = network_metadata.get_channel_fee_penalty(chan_id); - if chan_score != None { - return *chan_score.unwrap(); - } else { - return 0; - } + return network_metadata.get_channel_fee_penalty(chan_id); } } From 37c6de6486e7ac8d24f1c912d10f5d0ac6d81b77 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Thu, 11 Jun 2020 21:20:59 -0400 Subject: [PATCH 07/16] Add failed_route() --- lightning/src/routing/network_graph.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index e214c282783..c976b5d444e 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -434,6 +434,8 @@ pub trait RouteFeePenalty { fn get_channel_fee_penalty(&self, chan_id: u64) -> u64; /// Informs metadata object that a route has successfully executed its payment. fn route_succeeded(&mut self, route: Vec); + /// Informs metadata object that a route has failed to execute a payment. + fn route_failed(&mut self, route: Vec, failed_hop: RouteHop); } /// A default metadata object that is used to implement the default functionality for the @@ -454,6 +456,7 @@ impl RouteFeePenalty for DefaultMetadata { return u64::MAX; } } + fn route_succeeded(&mut self, route: Vec) { for route_hop in route { let chan_id = route_hop.short_channel_id; @@ -470,6 +473,15 @@ impl RouteFeePenalty for DefaultMetadata { } } } + + fn route_failed(&mut self, route: Vec, failed_hop: RouteHop) { + for route_hop in route { + if route_hop == failed_hop { + *self.failed_channels.entry(failed_hop.short_channel_id).or_insert(5) += 1; + break; + } + } + } } /// Users store custom metadata about the network separately. This trait is implemented by users, who may use From 4397c0ea11910e7600a3ee65b02d5d032f6c3e6c Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Fri, 12 Jun 2020 06:48:20 -0400 Subject: [PATCH 08/16] Add RoutingFeePenalty param to get_route --- lightning/src/routing/network_graph.rs | 2 +- lightning/src/routing/router.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index c976b5d444e..025bf50a692 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -453,7 +453,7 @@ impl RouteFeePenalty for DefaultMetadata { if self.failed_channels.get(&chan_id) == None { return 0; } else { - return u64::MAX; + return u64::max_value(); } } diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 6f70e610e00..cc808ed959a 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -9,7 +9,7 @@ use chain::chaininterface::ChainWatchInterface; use ln::channelmanager; use ln::features::{ChannelFeatures, NodeFeatures}; use ln::msgs::{DecodeError,ErrorAction,LightningError}; -use routing::network_graph::{NetGraphMsgHandler, RoutingFees}; +use routing::network_graph::{NetGraphMsgHandler, RoutingFees, RouteFeePenalty}; use util::ser::{Writeable, Readable}; use util::logger::Logger; @@ -162,7 +162,7 @@ struct DummyDirectionalChannelInfo { /// equal), however the enabled/disabled bit on such channels as well as the htlc_minimum_msat /// *is* checked as they may change based on the receiving node. pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHandler, target: &PublicKey, first_hops: Option<&[channelmanager::ChannelDetails]>, - last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32, logger: L) -> Result where C::Target: ChainWatchInterface, L::Target: Logger { + last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32, logger: L, net_metadata: impl RouteFeePenalty) -> Result where C::Target: ChainWatchInterface, 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 *target == *our_node_id { From 84b7f6b42fc5ce8b2534227aa8aeaa9165382cbe Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Sun, 14 Jun 2020 17:29:33 -0400 Subject: [PATCH 09/16] Add fee penalty to htlc minimum in get_route() --- lightning/src/routing/router.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index cc808ed959a..044f8a9f7d5 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -221,7 +221,7 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_hand // $directional_info. ( $chan_id: expr, $src_node_id: expr, $dest_node_id: expr, $directional_info: expr, $chan_features: expr, $starting_fee_msat: expr ) => { //TODO: Explore simply adding fee to hit htlc_minimum_msat - if $starting_fee_msat as u64 + final_value_msat >= $directional_info.htlc_minimum_msat { + if $starting_fee_msat as u64 + final_value_msat >= $directional_info.htlc_minimum_msat + net_metadata.get_channel_fee_penalty($chan_id.clone()) { let proportional_fee_millions = ($starting_fee_msat + final_value_msat).checked_mul($directional_info.fees.proportional_millionths as u64); if let Some(new_fee) = proportional_fee_millions.and_then(|part| { ($directional_info.fees.base_msat as u64).checked_add(part / 1000000) }) From 33deb1f446a76dfc629a8953e6d1009a4054e6db Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 17 Jun 2020 07:02:13 -0400 Subject: [PATCH 10/16] Do not add route to failed list on success --- lightning/src/routing/network_graph.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index 025bf50a692..f034831355e 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -461,9 +461,7 @@ impl RouteFeePenalty for DefaultMetadata { for route_hop in route { let chan_id = route_hop.short_channel_id; let successes_needed = self.failed_channels.get(&chan_id); - if successes_needed == None { - self.failed_channels.insert(chan_id, 5); - } else { + if successes_needed != None { let dec_successes_needed = successes_needed.unwrap() - 1; if dec_successes_needed > 0 { self.failed_channels.insert(chan_id, dec_successes_needed); From 5e229fc9f1e06c226a1a653db45eb787bc3bc98f Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 17 Jun 2020 07:02:50 -0400 Subject: [PATCH 11/16] Move penalty fee check to correct place in code --- lightning/src/routing/router.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 044f8a9f7d5..010a9dab995 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -221,10 +221,10 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_hand // $directional_info. ( $chan_id: expr, $src_node_id: expr, $dest_node_id: expr, $directional_info: expr, $chan_features: expr, $starting_fee_msat: expr ) => { //TODO: Explore simply adding fee to hit htlc_minimum_msat - if $starting_fee_msat as u64 + final_value_msat >= $directional_info.htlc_minimum_msat + net_metadata.get_channel_fee_penalty($chan_id.clone()) { + if $starting_fee_msat as u64 + final_value_msat >= $directional_info.htlc_minimum_msat { let proportional_fee_millions = ($starting_fee_msat + final_value_msat).checked_mul($directional_info.fees.proportional_millionths as u64); if let Some(new_fee) = proportional_fee_millions.and_then(|part| { - ($directional_info.fees.base_msat as u64).checked_add(part / 1000000) }) + ($directional_info.fees.base_msat as u64).checked_add(net_metadata.get_channel_fee_penalty($chan_id.clone()) + part/1000000) }) { let mut total_fee = $starting_fee_msat as u64; let hm_entry = dist.entry(&$src_node_id); From 6beca99e25421a642c2fd9cf2aa9d1c92fb7b9bc Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Tue, 23 Jun 2020 21:46:18 -0400 Subject: [PATCH 12/16] Address ariard review --- lightning/src/routing/network_graph.rs | 17 ++++++++--------- lightning/src/routing/router.rs | 4 ++-- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index f034831355e..ea0123e0a03 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -442,7 +442,7 @@ pub trait RouteFeePenalty { /// NetworkTracker trait. A user could make their own Metadata object and extend the /// functionality of it by implementing other functions/traits for their metadata. pub struct DefaultMetadata { - /// A lits of failed channels. Maps channel_id (as specified in the NetworkGraph object) to + /// A list of failed channels. Maps channel_id (as specified in the NetworkGraph object) to /// the number of successful routes to participate before being removed from the list. All /// channels in failed_channels are assumed to have a penalty of u64::max. failed_channels: BTreeMap, @@ -460,14 +460,13 @@ impl RouteFeePenalty for DefaultMetadata { fn route_succeeded(&mut self, route: Vec) { for route_hop in route { let chan_id = route_hop.short_channel_id; - let successes_needed = self.failed_channels.get(&chan_id); - if successes_needed != None { - let dec_successes_needed = successes_needed.unwrap() - 1; - if dec_successes_needed > 0 { - self.failed_channels.insert(chan_id, dec_successes_needed); - } else { - self.failed_channels.remove(&chan_id); - } + let mut can_remove = false; + if let Some(successes_needed) = self.failed_channels.get_mut(&chan_id) { + *successes_needed = *successes_needed - 1; + can_remove = *successes_needed == 0; + } + if can_remove { + self.failed_channels.remove(&chan_id); } } } diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 010a9dab995..c1ede984fbc 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -161,8 +161,8 @@ struct DummyDirectionalChannelInfo { /// The fees on channels from us to next-hops are ignored (as they are assumed to all be /// equal), however the enabled/disabled bit on such channels as well as the htlc_minimum_msat /// *is* checked as they may change based on the receiving node. -pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHandler, target: &PublicKey, first_hops: Option<&[channelmanager::ChannelDetails]>, - last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32, logger: L, net_metadata: impl RouteFeePenalty) -> Result where C::Target: ChainWatchInterface, L::Target: Logger { +pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHandler, target: &PublicKey, first_hops: Option<&[channelmanager::ChannelDetails]>, + last_hops: &[RouteHint], final_value_msat: u64, final_cltv: u32, logger: L, net_metadata: N) -> Result where C::Target: ChainWatchInterface, 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 *target == *our_node_id { From 9e7e2f6f161232b3a8a73f5e7c13001e3ce71704 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 24 Jun 2020 07:10:07 -0400 Subject: [PATCH 13/16] Add constructor for DefaultMetadata --- lightning/src/routing/network_graph.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index ea0123e0a03..be5b2b418b8 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -448,6 +448,13 @@ pub struct DefaultMetadata { failed_channels: BTreeMap, } +impl DefaultMetadata { + /// Instantiates an instance of DefaultMetadata + pub fn new() -> DefaultMetadata { + DefaultMetadata { failed_channels: std::collections::BTreeMap::new() } + } +} + impl RouteFeePenalty for DefaultMetadata { fn get_channel_fee_penalty(&self, chan_id: u64) -> u64 { if self.failed_channels.get(&chan_id) == None { From 75297264f52b5163349e9e5f8255b75262fd75eb Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 24 Jun 2020 07:10:24 -0400 Subject: [PATCH 14/16] Add DefaultMetadata param to get_route calls --- lightning/src/ln/chanmon_update_fail_tests.rs | 64 ++++--- lightning/src/ln/functional_test_utils.rs | 8 +- lightning/src/ln/functional_tests.rs | 160 ++++++++++++------ lightning/src/routing/router.rs | 31 ++-- 4 files changed, 176 insertions(+), 87 deletions(-) diff --git a/lightning/src/ln/chanmon_update_fail_tests.rs b/lightning/src/ln/chanmon_update_fail_tests.rs index ccd2540575e..a0c2a552327 100644 --- a/lightning/src/ln/chanmon_update_fail_tests.rs +++ b/lightning/src/ln/chanmon_update_fail_tests.rs @@ -10,6 +10,7 @@ use ln::features::InitFeatures; use ln::msgs; use ln::msgs::{ChannelMessageHandler, ErrorAction, RoutingMessageHandler}; use routing::router::get_route; +use routing::network_graph::DefaultMetadata; use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider}; use util::errors::APIError; @@ -34,7 +35,8 @@ fn test_simple_monitor_permanent_update_fail() { *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable {..}, {}); check_added_monitors!(nodes[0], 2); @@ -71,7 +73,8 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) { { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_1, &None), false, APIError::MonitorUpdateFailed, {}); check_added_monitors!(nodes[0], 1); } @@ -118,7 +121,8 @@ fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) { { *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {}); check_added_monitors!(nodes[0], 1); } @@ -184,7 +188,8 @@ fn do_test_monitor_temporary_update_fail(disconnect_count: usize) { { *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, payment_hash_2, &None), false, APIError::MonitorUpdateFailed, {}); check_added_monitors!(nodes[0], 1); } @@ -515,7 +520,8 @@ fn test_monitor_update_fail_cs() { let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -604,7 +610,8 @@ fn test_monitor_update_fail_no_rebroadcast() { let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -655,7 +662,8 @@ fn test_monitor_update_raa_while_paused() { let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash_1, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -664,7 +672,8 @@ fn test_monitor_update_raa_while_paused() { let (payment_preimage_2, our_payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, our_payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[1], 1); } @@ -756,7 +765,8 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -783,7 +793,8 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { let (_, payment_hash_3) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -832,7 +843,8 @@ fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) { // Try to route another payment backwards from 2 to make sure 1 holds off on responding let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[2].net_graph_msg_handler; - let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[2].node.send_payment(&route, payment_hash_4, &None).unwrap(); check_added_monitors!(nodes[2], 1); @@ -1086,7 +1098,8 @@ fn raa_no_response_awaiting_raa_state() { // generation during RAA while in monitor-update-failed state. { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap(); check_added_monitors!(nodes[0], 1); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); @@ -1140,7 +1153,8 @@ fn raa_no_response_awaiting_raa_state() { // commitment transaction states) whereas here we can explicitly check for it. { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap(); check_added_monitors!(nodes[0], 0); assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty()); @@ -1232,7 +1246,8 @@ fn claim_while_disconnected_monitor_update_fail() { let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1328,7 +1343,8 @@ fn monitor_failed_no_reestablish_response() { let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1402,7 +1418,8 @@ fn first_message_on_recv_ordering() { let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1427,7 +1444,8 @@ fn first_message_on_recv_ordering() { let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1507,7 +1525,8 @@ fn test_monitor_update_fail_claim() { let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[2].net_graph_msg_handler; - let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[2], 1); } @@ -1592,7 +1611,8 @@ fn test_monitor_update_on_pending_forwards() { let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[2].net_graph_msg_handler; - let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[2].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[2].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[2], 1); } @@ -1655,7 +1675,8 @@ fn monitor_update_claim_fail_no_response() { let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1820,7 +1841,8 @@ fn test_path_paused_mpp() { let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]); let payment_secret = PaymentSecret([0xdb; 32]); - let mut route = get_route(&nodes[0].node.get_our_node_id(), &nodes[0].net_graph_msg_handler, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let mut route = get_route(&nodes[0].node.get_our_node_id(), &nodes[0].net_graph_msg_handler, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); // Set us up to take multiple routes, one 0 -> 1 -> 3 and one 0 -> 2 -> 3: let path = route.paths[0].clone(); diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index bed83a925cb..84e2e14293b 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -6,7 +6,7 @@ use chain::transaction::OutPoint; use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure}; use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor}; use routing::router::{Route, get_route}; -use routing::network_graph::{NetGraphMsgHandler, NetworkGraph}; +use routing::network_graph::{NetGraphMsgHandler, NetworkGraph, DefaultMetadata}; use ln::features::InitFeatures; use ln::msgs; use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler}; @@ -953,7 +953,8 @@ pub const TEST_FINAL_CLTV: u32 = 32; pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) -> (PaymentPreimage, PaymentHash) { let net_graph_msg_handler = &origin_node.net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].len(), expected_route.len()); for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) { @@ -966,7 +967,8 @@ pub fn route_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: pub fn route_over_limit<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: &[&Node<'a, 'b, 'c>], recv_value: u64) { let logger = test_utils::TestLogger::new(); let net_graph_msg_handler = &origin_node.net_graph_msg_handler; - let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&origin_node.node.get_our_node_id(), net_graph_msg_handler, &expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); assert_eq!(route.paths.len(), 1); assert_eq!(route.paths[0].len(), expected_route.len()); for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) { diff --git a/lightning/src/ln/functional_tests.rs b/lightning/src/ln/functional_tests.rs index bd1b1d4f029..3cdba7672a8 100644 --- a/lightning/src/ln/functional_tests.rs +++ b/lightning/src/ln/functional_tests.rs @@ -13,6 +13,7 @@ use ln::channelmonitor; use ln::channel::{Channel, ChannelError}; use ln::{chan_utils, onion_utils}; use routing::router::{Route, RouteHop, get_route}; +use routing::network_graph::DefaultMetadata; use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; use ln::msgs; use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, ErrorAction}; @@ -159,7 +160,8 @@ fn test_async_inbound_update_fee() { // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]... let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap(); + let default_metadata = DefaultMetadata::new(); + nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(), our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[1], 1); let payment_event = { @@ -257,7 +259,8 @@ fn test_update_fee_unordered_raa() { // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]... let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap(); + let default_metadata = DefaultMetadata::new(); + nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(), our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[1], 1); let payment_event = { @@ -641,7 +644,8 @@ fn test_update_fee_with_fundee_update_add_htlc() { let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); // nothing happens since node[1] is in AwaitingRemoteRevoke nodes[1].node.send_payment(&route, our_payment_hash, &None).unwrap(); @@ -865,8 +869,10 @@ fn updates_shutdown_wait() { let net_graph_msg_handler0 = &nodes[0].net_graph_msg_handler; let net_graph_msg_handler1 = &nodes[1].net_graph_msg_handler; - let route_1 = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler0, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); - let route_2 = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler1, &nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata0 = DefaultMetadata::new(); + let default_metadata1 = DefaultMetadata::new(); + let route_1 = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler0, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata0).unwrap(); + let route_2 = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler1, &nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata1).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {}); unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {}); @@ -929,7 +935,8 @@ fn htlc_fail_async_shutdown() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -1304,7 +1311,8 @@ fn holding_cell_htlc_counting() { for _ in 0..::ln::channel::OUR_MAX_HTLCS { let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, payment_hash, &None).unwrap(); payments.push((payment_preimage, payment_hash)); } @@ -1321,7 +1329,8 @@ fn holding_cell_htlc_counting() { let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable { err }, assert_eq!(err, "Cannot push more than their max accepted HTLCs")); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); @@ -1332,7 +1341,8 @@ fn holding_cell_htlc_counting() { let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); } @@ -1465,7 +1475,8 @@ fn test_duplicate_htlc_different_direction_onchain() { let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800_000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800_000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash); // Provide preimage to node 0 by claiming payment @@ -1540,7 +1551,8 @@ fn do_channel_reserve_test(test_recv: bool) { ($recv_value: expr) => {{ let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); (route, payment_hash, payment_preimage) }} }; @@ -1820,7 +1832,8 @@ fn channel_reserve_in_flight_removes() { let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]); let send_1 = { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut events = nodes[0].node.get_and_clear_pending_msg_events(); @@ -1893,7 +1906,8 @@ fn channel_reserve_in_flight_removes() { let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[1]); let send_2 = { let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &[], 10000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &[], 10000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, payment_hash_4, &None).unwrap(); check_added_monitors!(nodes[1], 1); let mut events = nodes[1].node.get_and_clear_pending_msg_events(); @@ -2810,7 +2824,8 @@ fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, fourth_payment_hash, &None).unwrap(); assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty()); assert!(nodes[1].node.get_and_clear_pending_events().is_empty()); @@ -2956,7 +2971,8 @@ fn fail_backward_pending_htlc_upon_channel_failure() { { let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -2973,7 +2989,8 @@ fn fail_backward_pending_htlc_upon_channel_failure() { let (_, failed_payment_hash) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, failed_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 0); @@ -2994,7 +3011,8 @@ fn fail_backward_pending_htlc_upon_channel_failure() { let current_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1; let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &None, current_height).unwrap(); let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap(); let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash); @@ -3060,7 +3078,8 @@ fn test_force_close_fail_back() { let mut payment_event = { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -3233,7 +3252,8 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) { let logger = test_utils::TestLogger::new(); let payment_event = { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -3408,7 +3428,8 @@ fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) { // Channel should still work fine... let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0; claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000); } @@ -3509,7 +3530,8 @@ fn test_funding_peer_disconnect() { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000); claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000); } @@ -3530,7 +3552,8 @@ fn test_drop_messages_peer_disconnect_dual_htlc() { // Now try to send a second payment which will fail to send let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -3671,7 +3694,8 @@ fn do_test_htlc_timeout(send_partial_mpp: bool) { let our_payment_hash = if send_partial_mpp { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let (_, our_payment_hash) = get_payment_preimage_hash!(&nodes[0]); let payment_secret = PaymentSecret([0xdb; 32]); // Use the utility function send_payment_along_path to send the payment with MPP data which @@ -3734,7 +3758,8 @@ fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) { let (_, first_payment_hash) = get_payment_preimage_hash!(nodes[0]); { let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, first_payment_hash, &None).unwrap(); } assert_eq!(nodes[1].node.get_and_clear_pending_msg_events().len(), 1); @@ -3744,7 +3769,8 @@ fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) { let (_, second_payment_hash) = get_payment_preimage_hash!(nodes[0]); if forwarded_htlc { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, second_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0)); @@ -3754,7 +3780,8 @@ fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) { check_added_monitors!(nodes[1], 0); } else { let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[1].node.send_payment(&route, second_payment_hash, &None).unwrap(); check_added_monitors!(nodes[1], 0); } @@ -5019,7 +5046,8 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; let our_node_id = &nodes[1].node.get_our_node_id(); - let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata0 = DefaultMetadata::new(); + let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger, default_metadata0).unwrap(); // 2nd HTLC: send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_1); // not added < dust limit + HTLC tx fee // 3rd HTLC: @@ -5028,7 +5056,8 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno let (_, payment_hash_3) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000); // 5th HTLC: let (_, payment_hash_4) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000); - let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata1 = DefaultMetadata::new(); + let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata1).unwrap(); // 6th HTLC: send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_3); // 7th HTLC: @@ -5037,13 +5066,15 @@ fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, anno // 8th HTLC: let (_, payment_hash_5) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000); // 9th HTLC: - let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata2 = DefaultMetadata::new(); + let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger, default_metadata2).unwrap(); send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_5); // not added < dust limit + HTLC tx fee // 10th HTLC: let (_, payment_hash_6) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee // 11th HTLC: - let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata3 = DefaultMetadata::new(); + let route = get_route(our_node_id, net_graph_msg_handler, &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger, default_metadata3).unwrap(); send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_6); // Double-check that six of the new HTLC were added @@ -5432,7 +5463,8 @@ fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) { let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -5758,7 +5790,8 @@ fn test_onion_failure() { let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); // positve case send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000); @@ -6059,7 +6092,8 @@ fn test_update_add_htlc_bolt2_sender_value_below_minimum_msat() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); route.paths[0][0].fee_msat = 100; unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err }, @@ -6080,7 +6114,8 @@ fn test_update_add_htlc_bolt2_sender_zero_value_msat() { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); route.paths[0][0].fee_msat = 0; unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err }, assert_eq!(err, "Cannot send 0-msat HTLC")); @@ -6101,7 +6136,8 @@ fn test_update_add_htlc_bolt2_receiver_zero_value_msat() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6127,7 +6163,8 @@ fn test_update_add_htlc_bolt2_sender_cltv_expiry_too_high() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000000, 500000001, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000000, 500000001, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::RouteError { err }, assert_eq!(err, "Channel CLTV overflowed?!")); } @@ -6149,7 +6186,8 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment() let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let payment_event = { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -6171,7 +6209,8 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment() } let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err }, assert_eq!(err, "Cannot push more than their max accepted HTLCs")); @@ -6195,7 +6234,8 @@ fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], max_in_flight+1, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], max_in_flight+1, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { err }, assert_eq!(err, "Cannot send value that would put us over the max HTLC value in flight our peer will accept")); @@ -6224,7 +6264,8 @@ fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], htlc_minimum_msat, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], htlc_minimum_msat, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6250,7 +6291,8 @@ fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; let logger = test_utils::TestLogger::new(); - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 5000000-their_channel_reserve, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 5000000-their_channel_reserve, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6285,7 +6327,8 @@ fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() { }).expect("RNG is bad!"); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 3999999, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 3999999, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1; let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap(); @@ -6326,7 +6369,8 @@ fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6351,7 +6395,8 @@ fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() { create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known()); let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6378,7 +6423,8 @@ fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() { create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6425,7 +6471,8 @@ fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() { let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()); let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -6459,7 +6506,8 @@ fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() { let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6492,7 +6540,8 @@ fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment() let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id()); @@ -6608,7 +6657,8 @@ fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_messag let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); @@ -6661,7 +6711,8 @@ fn test_update_fulfill_htlc_bolt2_after_malformed_htlc_message_must_forward_upda //First hop let mut payment_event = { let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap(); check_added_monitors!(nodes[0], 1); let mut events = nodes[0].node.get_and_clear_pending_msg_events(); @@ -7347,7 +7398,8 @@ fn test_bump_penalty_txn_on_revoked_commitment() { let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0; let net_graph_msg_handler = &nodes[1].net_graph_msg_handler; - let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 3000000, 30, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[1].node.get_our_node_id(), net_graph_msg_handler, &nodes[0].node.get_our_node_id(), None, &Vec::new(), 3000000, 30, &logger, default_metadata).unwrap(); send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000); let revoked_txn = get_local_commitment_txn!(nodes[0], chan.2); @@ -7899,7 +7951,8 @@ fn test_simple_payment_secret() { let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]); let payment_secret = PaymentSecret([0xdb; 32]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone())); // Claiming with all the correct values but the wrong secret should result in nothing... assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false); @@ -7925,7 +7978,8 @@ fn test_simple_mpp() { let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]); let payment_secret = PaymentSecret([0xdb; 32]); let net_graph_msg_handler = &nodes[0].net_graph_msg_handler; - let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap(); + let default_metadata = DefaultMetadata::new(); + let mut route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger, default_metadata).unwrap(); let path = route.paths[0].clone(); route.paths.push(path); route.paths[0][0].pubkey = nodes[1].node.get_our_node_id(); diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index c1ede984fbc..4c0226e2f4b 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -405,6 +405,7 @@ mod tests { use chain::chaininterface; use routing::router::{NetGraphMsgHandler, RoutingFees}; use routing::router::{get_route, RouteHint}; + use routing::network_graph::DefaultMetadata; use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; use ln::msgs::{ErrorAction, LightningError, UnsignedChannelAnnouncement, ChannelAnnouncement, RoutingMessageHandler, NodeAnnouncement, UnsignedNodeAnnouncement, ChannelUpdate, UnsignedChannelUpdate}; @@ -816,7 +817,8 @@ mod tests { add_or_update_node(&net_graph_msg_handler, &secp_ctx, node6_privkey, NodeFeatures::from_le_bytes(id_to_feature_flags!(6)), 0); // Simple route to 3 via 2 - let route = get_route(&our_id, &net_graph_msg_handler, &node3, None, &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node3, None, &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 2); assert_eq!(route.paths[0][0].pubkey, node2); @@ -859,7 +861,8 @@ mod tests { }); // If all the channels require some features we don't understand, route should fail - if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &net_graph_msg_handler, &node3, None, &Vec::new(), 100, 42, Arc::clone(&logger)) { + let default_metadata = DefaultMetadata::new(); + if let Err(LightningError{err, action: ErrorAction::IgnoreError}) = get_route(&our_id, &net_graph_msg_handler, &node3, None, &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata) { assert_eq!(err, "Failed to find a path to the given destination"); } else { panic!(); } @@ -875,7 +878,8 @@ mod tests { inbound_capacity_msat: 0, is_live: true, }]; - let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 2); assert_eq!(route.paths[0][0].pubkey, node8); @@ -939,7 +943,8 @@ mod tests { inbound_capacity_msat: 0, is_live: true, }]; - let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 2); assert_eq!(route.paths[0][0].pubkey, node8); @@ -966,7 +971,8 @@ mod tests { // the node_announcement. // Route to 1 via 2 and 3 because our channel to 1 is disabled - let route = get_route(&our_id, &net_graph_msg_handler, &node1, None, &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node1, None, &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 3); assert_eq!(route.paths[0][0].pubkey, node2); @@ -1002,7 +1008,8 @@ mod tests { inbound_capacity_msat: 0, is_live: true, }]; - let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node3, Some(&our_chans), &Vec::new(), 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 2); assert_eq!(route.paths[0][0].pubkey, node8); @@ -1047,7 +1054,8 @@ mod tests { }); // Simple test across 2, 3, 5, and 4 via a last_hop channel - let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 5); assert_eq!(route.paths[0][0].pubkey, node2); @@ -1099,7 +1107,8 @@ mod tests { inbound_capacity_msat: 0, is_live: true, }]; - let route = get_route(&our_id, &net_graph_msg_handler, &node7, Some(&our_chans), &last_hops, 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node7, Some(&our_chans), &last_hops, 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 2); assert_eq!(route.paths[0][0].pubkey, node4); @@ -1119,7 +1128,8 @@ mod tests { last_hops[0].fees.base_msat = 1000; // Revert to via 6 as the fee on 8 goes up - let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 100, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 100, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 4); assert_eq!(route.paths[0][0].pubkey, node2); @@ -1153,7 +1163,8 @@ mod tests { assert_eq!(route.paths[0][3].channel_features.le_flags(), &Vec::new()); // We can't learn any flags from invoices, sadly // ...but still use 8 for larger payments as 6 has a variable feerate - let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 2000, 42, Arc::clone(&logger)).unwrap(); + let default_metadata = DefaultMetadata::new(); + let route = get_route(&our_id, &net_graph_msg_handler, &node7, None, &last_hops, 2000, 42, Arc::clone(&logger), default_metadata).unwrap(); assert_eq!(route.paths[0].len(), 5); assert_eq!(route.paths[0][0].pubkey, node2); From 8dd338c236ed72963d68f02f94c33d974f4cf9c8 Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 24 Jun 2020 21:38:22 -0400 Subject: [PATCH 15/16] Use checked_add when calculating new_fee in get_route() --- lightning/src/routing/router.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 4c0226e2f4b..13b13d2449a 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -224,7 +224,10 @@ pub fn get_route(our_node_id: &PublicKey if $starting_fee_msat as u64 + final_value_msat >= $directional_info.htlc_minimum_msat { let proportional_fee_millions = ($starting_fee_msat + final_value_msat).checked_mul($directional_info.fees.proportional_millionths as u64); if let Some(new_fee) = proportional_fee_millions.and_then(|part| { - ($directional_info.fees.base_msat as u64).checked_add(net_metadata.get_channel_fee_penalty($chan_id.clone()) + part/1000000) }) + ($directional_info.fees.base_msat as u64).checked_add( + net_metadata.get_channel_fee_penalty($chan_id.clone()).checked_add(part).unwrap()/1000000 + ) + }) { let mut total_fee = $starting_fee_msat as u64; let hm_entry = dist.entry(&$src_node_id); From bb5c7255b7461caff54e6339cd5e9d7ce3ed1def Mon Sep 17 00:00:00 2001 From: Sourabh Marathe Date: Wed, 24 Jun 2020 21:50:55 -0400 Subject: [PATCH 16/16] Remove channel from failed channels on success On success: all channels on the route are removed from the failed channels list. On failure: all channels are incremented a count tracking consecutive failed payments executated. --- lightning/src/routing/network_graph.rs | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/lightning/src/routing/network_graph.rs b/lightning/src/routing/network_graph.rs index be5b2b418b8..4a90beddef9 100644 --- a/lightning/src/routing/network_graph.rs +++ b/lightning/src/routing/network_graph.rs @@ -443,7 +443,7 @@ pub trait RouteFeePenalty { /// functionality of it by implementing other functions/traits for their metadata. pub struct DefaultMetadata { /// A list of failed channels. Maps channel_id (as specified in the NetworkGraph object) to - /// the number of successful routes to participate before being removed from the list. All + /// the number of consecutive failed routes a given channel ID has participated in. All /// channels in failed_channels are assumed to have a penalty of u64::max. failed_channels: BTreeMap, } @@ -464,24 +464,22 @@ impl RouteFeePenalty for DefaultMetadata { } } + /// If a route succeeds, remove any channels that successfully exeucted a payment off + /// the failed channels list fn route_succeeded(&mut self, route: Vec) { for route_hop in route { let chan_id = route_hop.short_channel_id; - let mut can_remove = false; - if let Some(successes_needed) = self.failed_channels.get_mut(&chan_id) { - *successes_needed = *successes_needed - 1; - can_remove = *successes_needed == 0; - } - if can_remove { + if self.failed_channels.contains_key(&chan_id) { self.failed_channels.remove(&chan_id); } } } + /// If a route fails, increment a failure count for the channels on the route. fn route_failed(&mut self, route: Vec, failed_hop: RouteHop) { for route_hop in route { if route_hop == failed_hop { - *self.failed_channels.entry(failed_hop.short_channel_id).or_insert(5) += 1; + *self.failed_channels.entry(failed_hop.short_channel_id).or_insert(1) += 1; break; } }