X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Frouter.rs;h=6f70e610e0093f547030711b333c4459d1fcd20c;hb=87126b391b895098484a86dc484a381b825e9a31;hp=28d14c4d0a44dd1b43441dcb1b18fc555ae8dd46;hpb=afd42821076854acac0d775a3448e97a94ddc475;p=rust-lightning diff --git a/lightning/src/routing/router.rs b/lightning/src/routing/router.rs index 28d14c4d..6f70e610 100644 --- a/lightning/src/routing/router.rs +++ b/lightning/src/routing/router.rs @@ -1,20 +1,21 @@ //! The top-level routing/network map tracking logic lives here. //! -//! You probably want to create a Router and use that as your RoutingMessageHandler and then +//! You probably want to create a NetGraphMsgHandler and use that as your RoutingMessageHandler and then //! interrogate it to get routes for your own payments. use bitcoin::secp256k1::key::PublicKey; +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 util::ser::{Writeable, Readable}; -use util::logger::{Logger, LogHolder}; +use util::logger::Logger; use std::cmp; -use std::sync::Arc; use std::collections::{HashMap,BinaryHeap}; +use std::ops::Deref; /// A hop in a route #[derive(Clone, PartialEq)] @@ -138,7 +139,6 @@ impl cmp::PartialOrd for RouteGraphNode { } struct DummyDirectionalChannelInfo { - src_node_id: PublicKey, cltv_expiry_delta: u32, htlc_minimum_msat: u64, fees: RoutingFees, @@ -152,7 +152,7 @@ struct DummyDirectionalChannelInfo { /// /// If some channels aren't announced, it may be useful to fill in a first_hops with the /// results from a local ChannelManager::list_usable_channels() call. If it is filled in, our -/// (this Router's) view of our local channels will be ignored, and only those in first_hops +/// view of our local channels (from net_graph_msg_handler) will be ignored, and only those in first_hops /// will be used. /// /// Panics if first_hops contains channels without short_channel_ids @@ -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: Arc) -> Result { +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 { // 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 { @@ -180,7 +180,6 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan // one. let dummy_directional_info = DummyDirectionalChannelInfo { // used for first_hops routes - src_node_id: our_node_id.clone(), cltv_expiry_delta: 0, htlc_minimum_msat: 0, fees: RoutingFees { @@ -217,10 +216,10 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan } macro_rules! add_entry { - // Adds entry which goes from the node pointed to by $directional_info to - // $dest_node_id over the channel with id $chan_id with fees described in + // Adds entry which goes from $src_node_id to $dest_node_id + // over the channel with id $chan_id with fees described in // $directional_info. - ( $chan_id: expr, $dest_node_id: expr, $directional_info: expr, $chan_features: expr, $starting_fee_msat: expr ) => { + ( $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 { let proportional_fee_millions = ($starting_fee_msat + final_value_msat).checked_mul($directional_info.fees.proportional_millionths as u64); @@ -228,9 +227,9 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan ($directional_info.fees.base_msat as u64).checked_add(part / 1000000) }) { let mut total_fee = $starting_fee_msat as u64; - let hm_entry = dist.entry(&$directional_info.src_node_id); + let hm_entry = dist.entry(&$src_node_id); let old_entry = hm_entry.or_insert_with(|| { - let node = network.get_nodes().get(&$directional_info.src_node_id).unwrap(); + let node = network.get_nodes().get(&$src_node_id).unwrap(); let mut fee_base_msat = u32::max_value(); let mut fee_proportional_millionths = u32::max_value(); if let Some(fees) = node.lowest_inbound_channel_fees { @@ -249,7 +248,7 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan cltv_expiry_delta: 0, }) }); - if $directional_info.src_node_id != *our_node_id { + if $src_node_id != *our_node_id { // Ignore new_fee for channel-from-us as we assume all channels-from-us // will have the same effective-fee total_fee += new_fee; @@ -261,7 +260,7 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan } } let new_graph_node = RouteGraphNode { - pubkey: $directional_info.src_node_id, + pubkey: $src_node_id, lowest_fee_to_peer_through_node: total_fee, lowest_fee_to_node: $starting_fee_msat as u64 + new_fee, }; @@ -286,7 +285,7 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan ( $node: expr, $node_id: expr, $fee_to_target_msat: expr ) => { if first_hops.is_some() { if let Some(&(ref first_hop, ref features)) = first_hop_targets.get(&$node_id) { - add_entry!(first_hop, $node_id, dummy_directional_info, features.to_context(), $fee_to_target_msat); + add_entry!(first_hop, *our_node_id, $node_id, dummy_directional_info, features.to_context(), $fee_to_target_msat); } } @@ -301,18 +300,23 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan for chan_id in $node.channels.iter() { let chan = network.get_channels().get(chan_id).unwrap(); if !chan.features.requires_unknown_bits() { - if chan.one_to_two.src_node_id == *$node_id { + if chan.node_one == *$node_id { // ie $node is one, ie next hop in A* is two, via the two_to_one channel - if first_hops.is_none() || chan.two_to_one.src_node_id != *our_node_id { - if chan.two_to_one.enabled { - add_entry!(chan_id, chan.one_to_two.src_node_id, chan.two_to_one, chan.features, $fee_to_target_msat); + if first_hops.is_none() || chan.node_two != *our_node_id { + if let Some(two_to_one) = chan.two_to_one.as_ref() { + if two_to_one.enabled { + add_entry!(chan_id, chan.node_two, chan.node_one, two_to_one, chan.features, $fee_to_target_msat); + } } } } else { - if first_hops.is_none() || chan.one_to_two.src_node_id != *our_node_id { - if chan.one_to_two.enabled { - add_entry!(chan_id, chan.two_to_one.src_node_id, chan.one_to_two, chan.features, $fee_to_target_msat); + if first_hops.is_none() || chan.node_one != *our_node_id { + if let Some(one_to_two) = chan.one_to_two.as_ref() { + if one_to_two.enabled { + add_entry!(chan_id, chan.node_one, chan.node_two, one_to_two, chan.features, $fee_to_target_msat); + } } + } } } @@ -337,12 +341,12 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan // bit lazy here. In the future, we should pull them out via our // ChannelManager, but there's no reason to waste the space until we // need them. - add_entry!(first_hop, hop.src_node_id, dummy_directional_info, features.to_context(), 0); + add_entry!(first_hop, *our_node_id , hop.src_node_id, dummy_directional_info, features.to_context(), 0); } } // BOLT 11 doesn't allow inclusion of features for the last hop hints, which // really sucks, cause we're gonna need that eventually. - add_entry!(hop.short_channel_id, target, hop, ChannelFeatures::empty(), 0); + add_entry!(hop.short_channel_id, hop.src_node_id, target, hop, ChannelFeatures::empty(), 0); } } } @@ -381,8 +385,7 @@ pub fn get_route(our_node_id: &PublicKey, net_graph_msg_handler: &NetGraphMsgHan res.last_mut().unwrap().fee_msat = final_value_msat; res.last_mut().unwrap().cltv_expiry_delta = final_cltv; let route = Route { paths: vec![res] }; - let log_holder = LogHolder { logger: &logger }; - log_trace!(log_holder, "Got route: {}", log_route!(route)); + log_trace!(logger, "Got route: {}", log_route!(route)); return Ok(route); } @@ -407,7 +410,6 @@ mod tests { NodeAnnouncement, UnsignedNodeAnnouncement, ChannelUpdate, UnsignedChannelUpdate}; use ln::channelmanager; use util::test_utils; - use util::logger::Logger; use util::ser::Writeable; use bitcoin::hashes::sha256d::Hash as Sha256dHash; @@ -424,7 +426,7 @@ mod tests { use std::sync::Arc; // Using the same keys for LN and BTC ids - fn add_channel(net_graph_msg_handler: &NetGraphMsgHandler, secp_ctx: &Secp256k1, node_1_privkey: &SecretKey, + fn add_channel(net_graph_msg_handler: &NetGraphMsgHandler, Arc>, secp_ctx: &Secp256k1, node_1_privkey: &SecretKey, node_2_privkey: &SecretKey, features: ChannelFeatures, short_channel_id: u64) { let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey); let node_id_2 = PublicKey::from_secret_key(&secp_ctx, node_2_privkey); @@ -454,7 +456,7 @@ mod tests { }; } - fn update_channel(net_graph_msg_handler: &NetGraphMsgHandler, secp_ctx: &Secp256k1, node_privkey: &SecretKey, update: UnsignedChannelUpdate) { + fn update_channel(net_graph_msg_handler: &NetGraphMsgHandler, Arc>, secp_ctx: &Secp256k1, node_privkey: &SecretKey, update: UnsignedChannelUpdate) { let msghash = hash_to_message!(&Sha256dHash::hash(&update.encode()[..])[..]); let valid_channel_update = ChannelUpdate { signature: secp_ctx.sign(&msghash, node_privkey), @@ -469,7 +471,7 @@ mod tests { } - fn add_or_update_node(net_graph_msg_handler: &NetGraphMsgHandler, secp_ctx: &Secp256k1, node_privkey: &SecretKey, + fn add_or_update_node(net_graph_msg_handler: &NetGraphMsgHandler, Arc>, secp_ctx: &Secp256k1, node_privkey: &SecretKey, features: NodeFeatures, timestamp: u32) { let node_id = PublicKey::from_secret_key(&secp_ctx, node_privkey); let unsigned_announcement = UnsignedNodeAnnouncement { @@ -499,8 +501,8 @@ mod tests { let secp_ctx = Secp256k1::new(); let our_privkey = &SecretKey::from_slice(&hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap(); let our_id = PublicKey::from_secret_key(&secp_ctx, our_privkey); - let logger: Arc = Arc::new(test_utils::TestLogger::new()); - let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger))); + let logger = Arc::new(test_utils::TestLogger::new()); + let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet)); let net_graph_msg_handler = NetGraphMsgHandler::new(chain_monitor, Arc::clone(&logger)); // Build network from our_id to node8: //