X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Frouting%2Fgossip.rs;h=00846a7ba794a1e3b9ba52319d1daf97641097b6;hb=384c4dc7753e4b7ac53ea380e52809babd8f0f9b;hp=37bf1ea5a6f9757d1da5a29f636aa0a853f2de8e;hpb=79b55f081557f7df7fc27f6c39574904bdbd1737;p=rust-lightning diff --git a/lightning/src/routing/gossip.rs b/lightning/src/routing/gossip.rs index 37bf1ea5..00846a7b 100644 --- a/lightning/src/routing/gossip.rs +++ b/lightning/src/routing/gossip.rs @@ -16,32 +16,33 @@ use bitcoin::secp256k1; use bitcoin::hashes::sha256d::Hash as Sha256dHash; use bitcoin::hashes::Hash; -use bitcoin::blockdata::script::Builder; use bitcoin::blockdata::transaction::TxOut; -use bitcoin::blockdata::opcodes; use bitcoin::hash_types::BlockHash; -use chain; -use chain::Access; -use ln::features::{ChannelFeatures, NodeFeatures}; -use ln::msgs::{DecodeError, ErrorAction, Init, LightningError, RoutingMessageHandler, NetAddress, MAX_VALUE_MSAT}; -use ln::msgs::{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, GossipTimestampFilter}; -use ln::msgs::{QueryChannelRange, ReplyChannelRange, QueryShortChannelIds, ReplyShortChannelIdsEnd}; -use ln::msgs; -use util::ser::{Readable, ReadableArgs, Writeable, Writer, MaybeReadable}; -use util::logger::{Logger, Level}; -use util::events::{Event, EventHandler, MessageSendEvent, MessageSendEventsProvider}; -use util::scid_utils::{block_from_scid, scid_from_parts, MAX_SCID_BLOCK}; - -use io; -use io_extras::{copy, sink}; -use prelude::*; +use crate::chain; +use crate::chain::Access; +use crate::ln::chan_utils::make_funding_redeemscript; +use crate::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures}; +use crate::ln::msgs::{DecodeError, ErrorAction, Init, LightningError, RoutingMessageHandler, NetAddress, MAX_VALUE_MSAT}; +use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, GossipTimestampFilter}; +use crate::ln::msgs::{QueryChannelRange, ReplyChannelRange, QueryShortChannelIds, ReplyShortChannelIdsEnd}; +use crate::ln::msgs; +use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer, MaybeReadable}; +use crate::util::logger::{Logger, Level}; +use crate::util::events::{Event, EventHandler, MessageSendEvent, MessageSendEventsProvider}; +use crate::util::scid_utils::{block_from_scid, scid_from_parts, MAX_SCID_BLOCK}; +use crate::util::string::PrintableString; + +use crate::io; +use crate::io_extras::{copy, sink}; +use crate::prelude::*; use alloc::collections::{BTreeMap, btree_map::Entry as BtreeEntry}; use core::{cmp, fmt}; -use sync::{RwLock, RwLockReadGuard}; +use crate::sync::{RwLock, RwLockReadGuard}; +#[cfg(feature = "std")] use core::sync::atomic::{AtomicUsize, Ordering}; -use sync::Mutex; -use core::ops::Deref; +use crate::sync::Mutex; +use core::ops::{Bound, Deref}; use bitcoin::hashes::hex::ToHex; #[cfg(feature = "std")] @@ -51,6 +52,9 @@ use std::time::{SystemTime, UNIX_EPOCH}; /// suggestion. const STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS: u64 = 60 * 60 * 24 * 14; +/// We stop tracking the removal of permanently failed nodes and channels one week after removal +const REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS: u64 = 60 * 60 * 24 * 7; + /// The maximum number of extra bytes which we do not understand in a gossip message before we will /// refuse to relay the message. const MAX_EXCESS_BYTES_FOR_RELAY: usize = 1024; @@ -131,6 +135,25 @@ pub struct NetworkGraph where L::Target: Logger { // Lock order: channels -> nodes channels: RwLock>, nodes: RwLock>, + // Lock order: removed_channels -> removed_nodes + // + // NOTE: In the following `removed_*` maps, we use seconds since UNIX epoch to track time instead + // of `std::time::Instant`s for a few reasons: + // * We want it to be possible to do tracking in no-std environments where we can compare + // a provided current UNIX timestamp with the time at which we started tracking. + // * In the future, if we decide to persist these maps, they will already be serializable. + // * Although we lose out on the platform's monotonic clock, the system clock in a std + // environment should be practical over the time period we are considering (on the order of a + // week). + // + /// Keeps track of short channel IDs for channels we have explicitly removed due to permanent + /// failure so that we don't resync them from gossip. Each SCID is mapped to the time (in seconds) + /// it was removed so that once some time passes, we can potentially resync it from gossip again. + removed_channels: Mutex>>, + /// Keeps track of `NodeId`s we have explicitly removed due to permanent failure so that we don't + /// resync them from gossip. Each `NodeId` is mapped to the time (in seconds) it was removed so + /// that once some time passes, we can potentially resync it from gossip again. + removed_nodes: Mutex>>, } /// A read-only view of [`NetworkGraph`]. @@ -143,7 +166,7 @@ pub struct ReadOnlyNetworkGraph<'a> { /// return packet by a node along the route. See [BOLT #4] for details. /// /// [BOLT #4]: https://github.com/lightning/bolts/blob/master/04-onion-routing.md -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub enum NetworkUpdate { /// An error indicating a `channel_update` messages should be applied via /// [`NetworkGraph::update_channel`]. @@ -161,7 +184,7 @@ pub enum NetworkUpdate { is_permanent: bool, }, /// An error indicating that a node failed to route a payment, which should be applied via - /// [`NetworkGraph::node_failed`]. + /// [`NetworkGraph::node_failed_permanent`] if permanent. NodeFailure { /// The node id of the failed node. node_id: PublicKey, @@ -198,6 +221,7 @@ where C::Target: chain::Access, L::Target: Logger { network_graph: G, chain_access: Option, + #[cfg(feature = "std")] full_syncs_requested: AtomicUsize, pending_events: Mutex>, logger: L, @@ -214,6 +238,7 @@ where C::Target: chain::Access, L::Target: Logger pub fn new(network_graph: G, chain_access: Option, logger: L) -> Self { P2PGossipSync { network_graph, + #[cfg(feature = "std")] full_syncs_requested: AtomicUsize::new(0), chain_access, pending_events: Mutex::new(vec![]), @@ -236,6 +261,7 @@ where C::Target: chain::Access, L::Target: Logger &self.network_graph } + #[cfg(feature = "std")] /// Returns true when a full routing table sync should be performed with a peer. fn should_request_full_sync(&self, _node_id: &PublicKey) -> bool { //TODO: Determine whether to request a full sync based on the network map. @@ -267,9 +293,11 @@ impl EventHandler for NetworkGraph where L::Target: Logger { self.channel_failed(short_channel_id, is_permanent); }, NetworkUpdate::NodeFailure { ref node_id, is_permanent } => { - let action = if is_permanent { "Removing" } else { "Disabling" }; - log_debug!(self.logger, "{} node graph entry for {} due to a payment failure.", action, node_id); - self.node_failed(node_id, is_permanent); + if is_permanent { + log_debug!(self.logger, + "Removed node graph entry for {} due to a payment failure.", log_pubkey!(node_id)); + self.node_failed_permanent(node_id); + }; }, } } @@ -318,56 +346,43 @@ where C::Target: chain::Access, L::Target: Logger Ok(msg.contents.excess_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY) } - fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(ChannelAnnouncement, Option, Option)> { - let mut result = Vec::with_capacity(batch_amount as usize); + fn get_next_channel_announcement(&self, starting_point: u64) -> Option<(ChannelAnnouncement, Option, Option)> { let channels = self.network_graph.channels.read().unwrap(); - let mut iter = channels.range(starting_point..); - while result.len() < batch_amount as usize { - if let Some((_, ref chan)) = iter.next() { - if chan.announcement_message.is_some() { - let chan_announcement = chan.announcement_message.clone().unwrap(); - let mut one_to_two_announcement: Option = None; - let mut two_to_one_announcement: Option = None; - if let Some(one_to_two) = chan.one_to_two.as_ref() { - one_to_two_announcement = one_to_two.last_update_message.clone(); - } - if let Some(two_to_one) = chan.two_to_one.as_ref() { - two_to_one_announcement = two_to_one.last_update_message.clone(); - } - result.push((chan_announcement, one_to_two_announcement, two_to_one_announcement)); - } else { - // TODO: We may end up sending un-announced channel_updates if we are sending - // initial sync data while receiving announce/updates for this channel. + for (_, ref chan) in channels.range(starting_point..) { + if chan.announcement_message.is_some() { + let chan_announcement = chan.announcement_message.clone().unwrap(); + let mut one_to_two_announcement: Option = None; + let mut two_to_one_announcement: Option = None; + if let Some(one_to_two) = chan.one_to_two.as_ref() { + one_to_two_announcement = one_to_two.last_update_message.clone(); } + if let Some(two_to_one) = chan.two_to_one.as_ref() { + two_to_one_announcement = two_to_one.last_update_message.clone(); + } + return Some((chan_announcement, one_to_two_announcement, two_to_one_announcement)); } else { - return result; + // TODO: We may end up sending un-announced channel_updates if we are sending + // initial sync data while receiving announce/updates for this channel. } } - result + None } - fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec { - let mut result = Vec::with_capacity(batch_amount as usize); + fn get_next_node_announcement(&self, starting_point: Option<&PublicKey>) -> Option { let nodes = self.network_graph.nodes.read().unwrap(); - let mut iter = if let Some(pubkey) = starting_point { - let mut iter = nodes.range(NodeId::from_pubkey(pubkey)..); - iter.next(); - iter + let iter = if let Some(pubkey) = starting_point { + nodes.range((Bound::Excluded(NodeId::from_pubkey(pubkey)), Bound::Unbounded)) } else { - nodes.range::(..) + nodes.range(..) }; - while result.len() < batch_amount as usize { - if let Some((_, ref node)) = iter.next() { - if let Some(node_info) = node.announcement_info.as_ref() { - if node_info.announcement_message.is_some() { - result.push(node_info.announcement_message.clone().unwrap()); - } + for (_, ref node) in iter { + if let Some(node_info) = node.announcement_info.as_ref() { + if let Some(msg) = node_info.announcement_message.clone() { + return Some(msg); } - } else { - return result; } } - result + None } /// Initiates a stateless sync of routing gossip information with a peer @@ -379,10 +394,12 @@ where C::Target: chain::Access, L::Target: Logger /// to request gossip messages for each channel. The sync is considered complete /// when the final reply_scids_end message is received, though we are not /// tracking this directly. - fn peer_connected(&self, their_node_id: &PublicKey, init_msg: &Init) { + fn peer_connected(&self, their_node_id: &PublicKey, init_msg: &Init) -> Result<(), ()> { // We will only perform a sync with peers that support gossip_queries. if !init_msg.features.supports_gossip_queries() { - return (); + // Don't disconnect peers for not supporting gossip queries. We may wish to have + // channels with peers even without being able to exchange gossip. + return Ok(()); } // The lightning network's gossip sync system is completely broken in numerous ways. @@ -435,13 +452,12 @@ where C::Target: chain::Access, L::Target: Logger // `gossip_timestamp_filter`, with the filter time set either two weeks ago or an hour ago. // // For no-std builds, we bury our head in the sand and do a full sync on each connection. - let should_request_full_sync = self.should_request_full_sync(&their_node_id); #[allow(unused_mut, unused_assignments)] let mut gossip_start_time = 0; #[cfg(feature = "std")] { gossip_start_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs(); - if should_request_full_sync { + if self.should_request_full_sync(&their_node_id) { gossip_start_time -= 60 * 60 * 24 * 7 * 2; // 2 weeks ago } else { gossip_start_time -= 60 * 60; // an hour ago @@ -457,6 +473,7 @@ where C::Target: chain::Access, L::Target: Logger timestamp_range: u32::max_value(), }, }); + Ok(()) } fn handle_reply_channel_range(&self, _their_node_id: &PublicKey, _msg: ReplyChannelRange) -> Result<(), LightningError> { @@ -584,6 +601,18 @@ where C::Target: chain::Access, L::Target: Logger action: ErrorAction::IgnoreError, }) } + + fn provided_node_features(&self) -> NodeFeatures { + let mut features = NodeFeatures::empty(); + features.set_gossip_queries_optional(); + features + } + + fn provided_init_features(&self, _their_node_id: &PublicKey) -> InitFeatures { + let mut features = InitFeatures::empty(); + features.set_gossip_queries_optional(); + features + } } impl>, C: Deref, L: Deref> MessageSendEventsProvider for P2PGossipSync @@ -599,7 +628,7 @@ where } } -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] /// Details about one direction of a channel as received within a [`ChannelUpdate`]. pub struct ChannelUpdateInfo { /// When the last update to the channel direction was issued. @@ -630,7 +659,7 @@ impl fmt::Display for ChannelUpdateInfo { } impl Writeable for ChannelUpdateInfo { - fn write(&self, writer: &mut W) -> Result<(), io::Error> { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { write_tlv_fields!(writer, { (0, self.last_update, required), (2, self.enabled, required), @@ -682,7 +711,7 @@ impl Readable for ChannelUpdateInfo { } } -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] /// Details about a channel (both directions). /// Received within a channel announcement. pub struct ChannelInfo { @@ -722,7 +751,7 @@ impl ChannelInfo { return None; } }; - Some((DirectedChannelInfo::new(self, direction), source)) + direction.map(|dir| (DirectedChannelInfo::new(self, dir), source)) } /// Returns a [`DirectedChannelInfo`] for the channel directed from the given `source` to a @@ -737,7 +766,7 @@ impl ChannelInfo { return None; } }; - Some((DirectedChannelInfo::new(self, direction), target)) + direction.map(|dir| (DirectedChannelInfo::new(self, dir), target)) } /// Returns a [`ChannelUpdateInfo`] based on the direction implied by the channel_flag. @@ -760,7 +789,7 @@ impl fmt::Display for ChannelInfo { } impl Writeable for ChannelInfo { - fn write(&self, writer: &mut W) -> Result<(), io::Error> { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { write_tlv_fields!(writer, { (0, self.features, required), (1, self.announcement_received_time, (default_value, 0)), @@ -784,7 +813,7 @@ struct ChannelUpdateInfoDeserWrapper(Option); impl MaybeReadable for ChannelUpdateInfoDeserWrapper { fn read(reader: &mut R) -> Result, DecodeError> { - match ::util::ser::Readable::read(reader) { + match crate::util::ser::Readable::read(reader) { Ok(channel_update_option) => Ok(Some(Self(channel_update_option))), Err(DecodeError::ShortRead) => Ok(None), Err(DecodeError::InvalidValue) => Ok(None), @@ -832,29 +861,23 @@ impl Readable for ChannelInfo { #[derive(Clone)] pub struct DirectedChannelInfo<'a> { channel: &'a ChannelInfo, - direction: Option<&'a ChannelUpdateInfo>, + direction: &'a ChannelUpdateInfo, htlc_maximum_msat: u64, effective_capacity: EffectiveCapacity, } impl<'a> DirectedChannelInfo<'a> { #[inline] - fn new(channel: &'a ChannelInfo, direction: Option<&'a ChannelUpdateInfo>) -> Self { - let htlc_maximum_msat = direction.map(|direction| direction.htlc_maximum_msat); + fn new(channel: &'a ChannelInfo, direction: &'a ChannelUpdateInfo) -> Self { + let mut htlc_maximum_msat = direction.htlc_maximum_msat; let capacity_msat = channel.capacity_sats.map(|capacity_sats| capacity_sats * 1000); - let (htlc_maximum_msat, effective_capacity) = match (htlc_maximum_msat, capacity_msat) { - (Some(amount_msat), Some(capacity_msat)) => { - let htlc_maximum_msat = cmp::min(amount_msat, capacity_msat); - (htlc_maximum_msat, EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat: Some(htlc_maximum_msat) }) - }, - (Some(amount_msat), None) => { - (amount_msat, EffectiveCapacity::MaximumHTLC { amount_msat }) - }, - (None, Some(capacity_msat)) => { - (capacity_msat, EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat: None }) + let effective_capacity = match capacity_msat { + Some(capacity_msat) => { + htlc_maximum_msat = cmp::min(htlc_maximum_msat, capacity_msat); + EffectiveCapacity::Total { capacity_msat, htlc_maximum_msat: htlc_maximum_msat } }, - (None, None) => (EffectiveCapacity::Unknown.as_msat(), EffectiveCapacity::Unknown), + None => EffectiveCapacity::MaximumHTLC { amount_msat: htlc_maximum_msat }, }; Self { @@ -863,12 +886,11 @@ impl<'a> DirectedChannelInfo<'a> { } /// Returns information for the channel. + #[inline] pub fn channel(&self) -> &'a ChannelInfo { self.channel } - /// Returns information for the direction. - pub fn direction(&self) -> Option<&'a ChannelUpdateInfo> { self.direction } - /// Returns the maximum HTLC amount allowed over the channel in the direction. + #[inline] pub fn htlc_maximum_msat(&self) -> u64 { self.htlc_maximum_msat } @@ -882,13 +904,9 @@ impl<'a> DirectedChannelInfo<'a> { self.effective_capacity } - /// Returns `Some` if [`ChannelUpdateInfo`] is available in the direction. - pub(super) fn with_update(self) -> Option> { - match self.direction { - Some(_) => Some(DirectedChannelInfoWithUpdate { inner: self }), - None => None, - } - } + /// Returns information for the direction. + #[inline] + pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.direction } } impl<'a> fmt::Debug for DirectedChannelInfo<'a> { @@ -899,37 +917,11 @@ impl<'a> fmt::Debug for DirectedChannelInfo<'a> { } } -/// A [`DirectedChannelInfo`] with [`ChannelUpdateInfo`] available in its direction. -#[derive(Clone)] -pub(super) struct DirectedChannelInfoWithUpdate<'a> { - inner: DirectedChannelInfo<'a>, -} - -impl<'a> DirectedChannelInfoWithUpdate<'a> { - /// Returns information for the channel. - #[inline] - pub(super) fn channel(&self) -> &'a ChannelInfo { &self.inner.channel } - - /// Returns information for the direction. - #[inline] - pub(super) fn direction(&self) -> &'a ChannelUpdateInfo { self.inner.direction.unwrap() } - - /// Returns the [`EffectiveCapacity`] of the channel in the direction. - #[inline] - pub(super) fn effective_capacity(&self) -> EffectiveCapacity { self.inner.effective_capacity() } -} - -impl<'a> fmt::Debug for DirectedChannelInfoWithUpdate<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - self.inner.fmt(f) - } -} - /// The effective capacity of a channel for routing purposes. /// /// While this may be smaller than the actual channel capacity, amounts greater than /// [`Self::as_msat`] should not be routed through the channel. -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug)] pub enum EffectiveCapacity { /// The available liquidity in the channel known from being a channel counterparty, and thus a /// direct hop. @@ -948,7 +940,7 @@ pub enum EffectiveCapacity { /// The funding amount denominated in millisatoshi. capacity_msat: u64, /// The maximum HTLC amount denominated in millisatoshi. - htlc_maximum_msat: Option + htlc_maximum_msat: u64 }, /// A capacity sufficient to route any payment, typically used for private channels provided by /// an invoice. @@ -990,7 +982,7 @@ impl_writeable_tlv_based!(RoutingFees, { (2, proportional_millionths, required) }); -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] /// Information received in the latest node_announcement from this node. pub struct NodeAnnouncementInfo { /// Protocol features the node announced support for @@ -1026,28 +1018,22 @@ impl_writeable_tlv_based!(NodeAnnouncementInfo, { /// /// Since node aliases are provided by third parties, they are a potential avenue for injection /// attacks. Care must be taken when processing. -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub struct NodeAlias(pub [u8; 32]); impl fmt::Display for NodeAlias { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - let control_symbol = core::char::REPLACEMENT_CHARACTER; let first_null = self.0.iter().position(|b| *b == 0).unwrap_or(self.0.len()); let bytes = self.0.split_at(first_null).0; match core::str::from_utf8(bytes) { - Ok(alias) => { - for c in alias.chars() { - let mut bytes = [0u8; 4]; - let c = if !c.is_control() { c } else { control_symbol }; - f.write_str(c.encode_utf8(&mut bytes))?; - } - }, + Ok(alias) => PrintableString(alias).fmt(f)?, Err(_) => { + use core::fmt::Write; for c in bytes.iter().map(|b| *b as char) { // Display printable ASCII characters - let mut bytes = [0u8; 4]; + let control_symbol = core::char::REPLACEMENT_CHARACTER; let c = if c >= '\x20' && c <= '\x7e' { c } else { control_symbol }; - f.write_str(c.encode_utf8(&mut bytes))?; + f.write_char(c)?; } }, }; @@ -1067,7 +1053,7 @@ impl Readable for NodeAlias { } } -#[derive(Clone, Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq, Eq)] /// Details about a node in the network, known from the network announcement. pub struct NodeInfo { /// All valid channels a node has announced @@ -1091,7 +1077,7 @@ impl fmt::Display for NodeInfo { } impl Writeable for NodeInfo { - fn write(&self, writer: &mut W) -> Result<(), io::Error> { + fn write(&self, writer: &mut W) -> Result<(), io::Error> { write_tlv_fields!(writer, { (0, self.lowest_inbound_channel_fees, option), (2, self.announcement_info, option), @@ -1109,7 +1095,7 @@ struct NodeAnnouncementInfoDeserWrapper(NodeAnnouncementInfo); impl MaybeReadable for NodeAnnouncementInfoDeserWrapper { fn read(reader: &mut R) -> Result, DecodeError> { - match ::util::ser::Readable::read(reader) { + match crate::util::ser::Readable::read(reader) { Ok(node_announcement_info) => return Ok(Some(Self(node_announcement_info))), Err(_) => { copy(reader, &mut sink()).unwrap(); @@ -1200,6 +1186,8 @@ impl ReadableArgs for NetworkGraph where L::Target: Logger { channels: RwLock::new(channels), nodes: RwLock::new(nodes), last_rapid_gossip_sync_timestamp: Mutex::new(last_rapid_gossip_sync_timestamp), + removed_nodes: Mutex::new(HashMap::new()), + removed_channels: Mutex::new(HashMap::new()), }) } } @@ -1218,6 +1206,7 @@ impl fmt::Display for NetworkGraph where L::Target: Logger { } } +impl Eq for NetworkGraph where L::Target: Logger {} impl PartialEq for NetworkGraph where L::Target: Logger { fn eq(&self, other: &Self) -> bool { self.genesis_hash == other.genesis_hash && @@ -1236,6 +1225,8 @@ impl NetworkGraph where L::Target: Logger { channels: RwLock::new(BTreeMap::new()), nodes: RwLock::new(BTreeMap::new()), last_rapid_gossip_sync_timestamp: Mutex::new(None), + removed_channels: Mutex::new(HashMap::new()), + removed_nodes: Mutex::new(HashMap::new()), } } @@ -1299,7 +1290,7 @@ impl NetworkGraph where L::Target: Logger { // updates to ensure you always have the latest one, only vaguely suggesting // that it be at least the current time. if node_info.last_update > msg.timestamp { - return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreAndLog(Level::Gossip)}); + return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); } else if node_info.last_update == msg.timestamp { return Err(LightningError{err: "Update had the same timestamp as last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); } @@ -1447,6 +1438,54 @@ impl NetworkGraph where L::Target: Logger { return Err(LightningError{err: "Channel announcement node had a channel with itself".to_owned(), action: ErrorAction::IgnoreError}); } + let node_one = NodeId::from_pubkey(&msg.node_id_1); + let node_two = NodeId::from_pubkey(&msg.node_id_2); + + { + let channels = self.channels.read().unwrap(); + + if let Some(chan) = channels.get(&msg.short_channel_id) { + if chan.capacity_sats.is_some() { + // If we'd previously looked up the channel on-chain and checked the script + // against what appears on-chain, ignore the duplicate announcement. + // + // Because a reorg could replace one channel with another at the same SCID, if + // the channel appears to be different, we re-validate. This doesn't expose us + // to any more DoS risk than not, as a peer can always flood us with + // randomly-generated SCID values anyway. + // + // We use the Node IDs rather than the bitcoin_keys to check for "equivalence" + // as we didn't (necessarily) store the bitcoin keys, and we only really care + // if the peers on the channel changed anyway. + if node_one == chan.node_one && node_two == chan.node_two { + return Err(LightningError { + err: "Already have chain-validated channel".to_owned(), + action: ErrorAction::IgnoreDuplicateGossip + }); + } + } else if chain_access.is_none() { + // Similarly, if we can't check the chain right now anyway, ignore the + // duplicate announcement without bothering to take the channels write lock. + return Err(LightningError { + err: "Already have non-chain-validated channel".to_owned(), + action: ErrorAction::IgnoreDuplicateGossip + }); + } + } + } + + { + let removed_channels = self.removed_channels.lock().unwrap(); + let removed_nodes = self.removed_nodes.lock().unwrap(); + if removed_channels.contains_key(&msg.short_channel_id) || + removed_nodes.contains_key(&node_one) || + removed_nodes.contains_key(&node_two) { + return Err(LightningError{ + err: format!("Channel with SCID {} or one of its nodes was removed from our network graph recently", &msg.short_channel_id), + action: ErrorAction::IgnoreAndLog(Level::Gossip)}); + } + } + let utxo_value = match &chain_access { &None => { // Tentatively accept, potentially exposing us to DoS attacks @@ -1455,13 +1494,10 @@ impl NetworkGraph where L::Target: Logger { &Some(ref chain_access) => { match chain_access.get_utxo(&msg.chain_hash, msg.short_channel_id) { Ok(TxOut { value, script_pubkey }) => { - let expected_script = Builder::new().push_opcode(opcodes::all::OP_PUSHNUM_2) - .push_slice(&msg.bitcoin_key_1.serialize()) - .push_slice(&msg.bitcoin_key_2.serialize()) - .push_opcode(opcodes::all::OP_PUSHNUM_2) - .push_opcode(opcodes::all::OP_CHECKMULTISIG).into_script().to_v0_p2wsh(); + let expected_script = + make_funding_redeemscript(&msg.bitcoin_key_1, &msg.bitcoin_key_2).to_v0_p2wsh(); if script_pubkey != expected_script { - return Err(LightningError{err: format!("Channel announcement key ({}) didn't match on-chain script ({})", script_pubkey.to_hex(), expected_script.to_hex()), action: ErrorAction::IgnoreError}); + return Err(LightningError{err: format!("Channel announcement key ({}) didn't match on-chain script ({})", expected_script.to_hex(), script_pubkey.to_hex()), action: ErrorAction::IgnoreError}); } //TODO: Check if value is worth storing, use it to inform routing, and compare it //to the new HTLC max field in channel_update @@ -1486,9 +1522,9 @@ impl NetworkGraph where L::Target: Logger { let chan_info = ChannelInfo { features: msg.features.clone(), - node_one: NodeId::from_pubkey(&msg.node_id_1), + node_one, one_to_two: None, - node_two: NodeId::from_pubkey(&msg.node_id_2), + node_two, two_to_one: None, capacity_sats: utxo_value, announcement_message: if msg.excess_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY @@ -1504,10 +1540,16 @@ impl NetworkGraph where L::Target: Logger { /// May cause the removal of nodes too, if this was their last channel. /// If not permanent, makes channels unavailable for routing. pub fn channel_failed(&self, short_channel_id: u64, is_permanent: bool) { + #[cfg(feature = "std")] + let current_time_unix = Some(SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs()); + #[cfg(not(feature = "std"))] + let current_time_unix = None; + let mut channels = self.channels.write().unwrap(); if is_permanent { if let Some(chan) = channels.remove(&short_channel_id) { let mut nodes = self.nodes.write().unwrap(); + self.removed_channels.lock().unwrap().insert(short_channel_id, current_time_unix); Self::remove_channel_in_nodes(&mut nodes, &chan, short_channel_id); } } else { @@ -1522,12 +1564,36 @@ impl NetworkGraph where L::Target: Logger { } } - /// Marks a node in the graph as failed. - pub fn node_failed(&self, _node_id: &PublicKey, is_permanent: bool) { - if is_permanent { - // TODO: Wholly remove the node - } else { - // TODO: downgrade the node + /// Marks a node in the graph as permanently failed, effectively removing it and its channels + /// from local storage. + pub fn node_failed_permanent(&self, node_id: &PublicKey) { + #[cfg(feature = "std")] + let current_time_unix = Some(SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs()); + #[cfg(not(feature = "std"))] + let current_time_unix = None; + + let node_id = NodeId::from_pubkey(node_id); + let mut channels = self.channels.write().unwrap(); + let mut nodes = self.nodes.write().unwrap(); + let mut removed_channels = self.removed_channels.lock().unwrap(); + let mut removed_nodes = self.removed_nodes.lock().unwrap(); + + if let Some(node) = nodes.remove(&node_id) { + for scid in node.channels.iter() { + if let Some(chan_info) = channels.remove(scid) { + let other_node_id = if node_id == chan_info.node_one { chan_info.node_two } else { chan_info.node_one }; + if let BtreeEntry::Occupied(mut other_node_entry) = nodes.entry(other_node_id) { + other_node_entry.get_mut().channels.retain(|chan_id| { + *scid != *chan_id + }); + if other_node_entry.get().channels.is_empty() { + other_node_entry.remove_entry(); + } + } + removed_channels.insert(*scid, current_time_unix); + } + } + removed_nodes.insert(node_id, current_time_unix); } } @@ -1543,11 +1609,14 @@ impl NetworkGraph where L::Target: Logger { /// Note that for users of the `lightning-background-processor` crate this method may be /// automatically called regularly for you. /// + /// This method will also cause us to stop tracking removed nodes and channels if they have been + /// in the map for a while so that these can be resynced from gossip in the future. + /// /// This method is only available with the `std` feature. See - /// [`NetworkGraph::remove_stale_channels_with_time`] for `no-std` use. - pub fn remove_stale_channels(&self) { + /// [`NetworkGraph::remove_stale_channels_and_tracking_with_time`] for `no-std` use. + pub fn remove_stale_channels_and_tracking(&self) { let time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs(); - self.remove_stale_channels_with_time(time); + self.remove_stale_channels_and_tracking_with_time(time); } /// Removes information about channels that we haven't heard any updates about in some time. @@ -1558,9 +1627,12 @@ impl NetworkGraph where L::Target: Logger { /// updates every two weeks, the non-normative section of BOLT 7 currently suggests that /// pruning occur for updates which are at least two weeks old, which we implement here. /// + /// This method will also cause us to stop tracking removed nodes and channels if they have been + /// in the map for a while so that these can be resynced from gossip in the future. + /// /// This function takes the current unix time as an argument. For users with the `std` feature - /// enabled, [`NetworkGraph::remove_stale_channels`] may be preferable. - pub fn remove_stale_channels_with_time(&self, current_time_unix: u64) { + /// enabled, [`NetworkGraph::remove_stale_channels_and_tracking`] may be preferable. + pub fn remove_stale_channels_and_tracking_with_time(&self, current_time_unix: u64) { let mut channels = self.channels.write().unwrap(); // Time out if we haven't received an update in at least 14 days. if current_time_unix > u32::max_value() as u64 { return; } // Remove by 2106 @@ -1576,7 +1648,7 @@ impl NetworkGraph where L::Target: Logger { if info.two_to_one.is_some() && info.two_to_one.as_ref().unwrap().last_update < min_time_unix { info.two_to_one = None; } - if info.one_to_two.is_none() && info.two_to_one.is_none() { + if info.one_to_two.is_none() || info.two_to_one.is_none() { // We check the announcement_received_time here to ensure we don't drop // announcements that we just received and are just waiting for our peer to send a // channel_update for. @@ -1590,8 +1662,29 @@ impl NetworkGraph where L::Target: Logger { for scid in scids_to_remove { let info = channels.remove(&scid).expect("We just accessed this scid, it should be present"); Self::remove_channel_in_nodes(&mut nodes, &info, scid); + self.removed_channels.lock().unwrap().insert(scid, Some(current_time_unix)); } } + + let should_keep_tracking = |time: &mut Option| { + if let Some(time) = time { + current_time_unix.saturating_sub(*time) < REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS + } else { + // NOTE: In the case of no-std, we won't have access to the current UNIX time at the time of removal, + // so we'll just set the removal time here to the current UNIX time on the very next invocation + // of this function. + #[cfg(feature = "no-std")] + { + let mut tracked_time = Some(current_time_unix); + core::mem::swap(time, &mut tracked_time); + return true; + } + #[allow(unreachable_code)] + false + }}; + + self.removed_channels.lock().unwrap().retain(|_, time| should_keep_tracking(time)); + self.removed_nodes.lock().unwrap().retain(|_, time| should_keep_tracking(time)); } /// For an already known (from announcement) channel, update info about one of the directions @@ -1664,7 +1757,7 @@ impl NetworkGraph where L::Target: Logger { // pruning based on the timestamp field being more than two weeks old, // but only in the non-normative section. if existing_chan_info.last_update > msg.timestamp { - return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreAndLog(Level::Gossip)}); + return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); } else if existing_chan_info.last_update == msg.timestamp { return Err(LightningError{err: "Update had same timestamp as last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip}); } @@ -1796,6 +1889,12 @@ impl ReadOnlyNetworkGraph<'_> { self.channels.get(&short_channel_id) } + #[cfg(c_bindings)] // Non-bindings users should use `channels` + /// Returns the list of channels in the graph + pub fn list_channels(&self) -> Vec { + self.channels.keys().map(|c| *c).collect() + } + /// Returns all known nodes' public keys along with announced node info. /// /// (C-not exported) because we have no mapping for `BTreeMap`s @@ -1808,6 +1907,12 @@ impl ReadOnlyNetworkGraph<'_> { self.nodes.get(node_id) } + #[cfg(c_bindings)] // Non-bindings users should use `nodes` + /// Returns the list of nodes in the graph + pub fn list_nodes(&self) -> Vec { + self.nodes.keys().map(|n| *n).collect() + } + /// Get network addresses by node id. /// Returns None if the requested node is completely unknown, /// or if node announcement for the node was never received. @@ -1823,37 +1928,39 @@ impl ReadOnlyNetworkGraph<'_> { #[cfg(test)] mod tests { - use chain; - use ln::PaymentHash; - use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures}; - use routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo, NodeAnnouncementInfo, NodeInfo}; - use ln::msgs::{Init, RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement, + use crate::chain; + use crate::ln::channelmanager; + use crate::ln::chan_utils::make_funding_redeemscript; + use crate::ln::PaymentHash; + use crate::ln::features::InitFeatures; + use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo, NodeAnnouncementInfo, NodeInfo}; + use crate::ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement, UnsignedChannelAnnouncement, ChannelAnnouncement, UnsignedChannelUpdate, ChannelUpdate, ReplyChannelRange, QueryChannelRange, QueryShortChannelIds, MAX_VALUE_MSAT}; - use util::test_utils; - use util::ser::{ReadableArgs, Writeable}; - use util::events::{Event, EventHandler, MessageSendEvent, MessageSendEventsProvider}; - use util::scid_utils::scid_from_parts; + use crate::util::test_utils; + use crate::util::ser::{ReadableArgs, Writeable}; + use crate::util::events::{Event, EventHandler, MessageSendEvent, MessageSendEventsProvider}; + use crate::util::scid_utils::scid_from_parts; + use crate::routing::gossip::REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS; use super::STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS; use bitcoin::hashes::sha256d::Hash as Sha256dHash; use bitcoin::hashes::Hash; use bitcoin::network::constants::Network; use bitcoin::blockdata::constants::genesis_block; - use bitcoin::blockdata::script::{Builder, Script}; + use bitcoin::blockdata::script::Script; use bitcoin::blockdata::transaction::TxOut; - use bitcoin::blockdata::opcodes; use hex; use bitcoin::secp256k1::{PublicKey, SecretKey}; use bitcoin::secp256k1::{All, Secp256k1}; - use io; + use crate::io; use bitcoin::secp256k1; - use prelude::*; - use sync::Arc; + use crate::prelude::*; + use crate::sync::Arc; fn create_network_graph() -> NetworkGraph> { let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); @@ -1872,6 +1979,7 @@ mod tests { } #[test] + #[cfg(feature = "std")] fn request_full_sync_finite_times() { let network_graph = create_network_graph(); let (secp_ctx, gossip_sync) = create_gossip_sync(&network_graph); @@ -1888,7 +1996,7 @@ mod tests { fn get_signed_node_announcement(f: F, node_key: &SecretKey, secp_ctx: &Secp256k1) -> NodeAnnouncement { let node_id = PublicKey::from_secret_key(&secp_ctx, node_key); let mut unsigned_announcement = UnsignedNodeAnnouncement { - features: NodeFeatures::known(), + features: channelmanager::provided_node_features(), timestamp: 100, node_id: node_id, rgb: [0; 3], @@ -1912,7 +2020,7 @@ mod tests { let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap(); let mut unsigned_announcement = UnsignedChannelAnnouncement { - features: ChannelFeatures::known(), + features: channelmanager::provided_channel_features(), chain_hash: genesis_block(Network::Testnet).header.block_hash(), short_channel_id: 0, node_id_1, @@ -1933,14 +2041,10 @@ mod tests { } fn get_channel_script(secp_ctx: &Secp256k1) -> Script { - let node_1_btckey = &SecretKey::from_slice(&[40; 32]).unwrap(); - let node_2_btckey = &SecretKey::from_slice(&[39; 32]).unwrap(); - Builder::new().push_opcode(opcodes::all::OP_PUSHNUM_2) - .push_slice(&PublicKey::from_secret_key(&secp_ctx, node_1_btckey).serialize()) - .push_slice(&PublicKey::from_secret_key(&secp_ctx, node_2_btckey).serialize()) - .push_opcode(opcodes::all::OP_PUSHNUM_2) - .push_opcode(opcodes::all::OP_CHECKMULTISIG).into_script() - .to_v0_p2wsh() + let node_1_btckey = SecretKey::from_slice(&[40; 32]).unwrap(); + let node_2_btckey = SecretKey::from_slice(&[39; 32]).unwrap(); + make_funding_redeemscript(&PublicKey::from_secret_key(secp_ctx, &node_1_btckey), + &PublicKey::from_secret_key(secp_ctx, &node_2_btckey)).to_v0_p2wsh() } fn get_signed_channel_update(f: F, node_key: &SecretKey, secp_ctx: &Secp256k1) -> ChannelUpdate { @@ -2055,7 +2159,7 @@ mod tests { // drop new one on the floor, since we can't see any changes. match gossip_sync.handle_channel_announcement(&valid_announcement) { Ok(_) => panic!(), - Err(e) => assert_eq!(e.err, "Already have knowledge of channel") + Err(e) => assert_eq!(e.err, "Already have non-chain-validated channel") }; // Test if an associated transaction were not on-chain (or not confirmed). @@ -2089,36 +2193,43 @@ mod tests { }; } - // If we receive announcement for the same channel (but TX is not confirmed), - // drop new one on the floor, since we can't see any changes. - *chain_source.utxo_ret.lock().unwrap() = Err(chain::AccessError::UnknownTx); + // If we receive announcement for the same channel, once we've validated it against the + // chain, we simply ignore all new (duplicate) announcements. + *chain_source.utxo_ret.lock().unwrap() = Ok(TxOut { value: 0, script_pubkey: good_script }); match gossip_sync.handle_channel_announcement(&valid_announcement) { Ok(_) => panic!(), - Err(e) => assert_eq!(e.err, "Channel announced without corresponding UTXO entry") + Err(e) => assert_eq!(e.err, "Already have chain-validated channel") }; - // But if it is confirmed, replace the channel - *chain_source.utxo_ret.lock().unwrap() = Ok(TxOut { value: 0, script_pubkey: good_script }); - let valid_announcement = get_signed_channel_announcement(|unsigned_announcement| { - unsigned_announcement.features = ChannelFeatures::empty(); - unsigned_announcement.short_channel_id += 2; - }, node_1_privkey, node_2_privkey, &secp_ctx); - match gossip_sync.handle_channel_announcement(&valid_announcement) { - Ok(res) => assert!(res), - _ => panic!() - }; + #[cfg(feature = "std")] { - match network_graph.read_only().channels().get(&valid_announcement.contents.short_channel_id) { - Some(channel_entry) => { - assert_eq!(channel_entry.features, ChannelFeatures::empty()); - }, + use std::time::{SystemTime, UNIX_EPOCH}; + + let tracking_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs(); + // Mark a node as permanently failed so it's tracked as removed. + gossip_sync.network_graph().node_failed_permanent(&PublicKey::from_secret_key(&secp_ctx, node_1_privkey)); + + // Return error and ignore valid channel announcement if one of the nodes has been tracked as removed. + let valid_announcement = get_signed_channel_announcement(|unsigned_announcement| { + unsigned_announcement.short_channel_id += 3; + }, node_1_privkey, node_2_privkey, &secp_ctx); + match gossip_sync.handle_channel_announcement(&valid_announcement) { + Ok(_) => panic!(), + Err(e) => assert_eq!(e.err, "Channel with SCID 3 or one of its nodes was removed from our network graph recently") + } + + gossip_sync.network_graph().remove_stale_channels_and_tracking_with_time(tracking_time + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS); + + // The above channel announcement should be handled as per normal now. + match gossip_sync.handle_channel_announcement(&valid_announcement) { + Ok(res) => assert!(res), _ => panic!() - }; + } } // Don't relay valid channels with excess data let valid_announcement = get_signed_channel_announcement(|unsigned_announcement| { - unsigned_announcement.short_channel_id += 3; + unsigned_announcement.short_channel_id += 4; unsigned_announcement.excess_data.resize(MAX_EXCESS_BYTES_FOR_RELAY + 1, 0); }, node_1_privkey, node_2_privkey, &secp_ctx); match gossip_sync.handle_channel_announcement(&valid_announcement) { @@ -2253,6 +2364,7 @@ mod tests { let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap(); let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap(); + let node_2_id = PublicKey::from_secret_key(&secp_ctx, node_2_privkey); { // There is no nodes in the table at the beginning. @@ -2274,7 +2386,7 @@ mod tests { network_graph.handle_event(&Event::PaymentPathFailed { payment_id: None, payment_hash: PaymentHash([0; 32]), - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: true, path: vec![], network_update: Some(NetworkUpdate::ChannelUpdateMessage { @@ -2301,7 +2413,7 @@ mod tests { network_graph.handle_event(&Event::PaymentPathFailed { payment_id: None, payment_hash: PaymentHash([0; 32]), - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: true, path: vec![], network_update: Some(NetworkUpdate::ChannelFailure { @@ -2326,7 +2438,7 @@ mod tests { network_graph.handle_event(&Event::PaymentPathFailed { payment_id: None, payment_hash: PaymentHash([0; 32]), - rejected_by_dest: false, + payment_failed_permanently: false, all_paths_failed: true, path: vec![], network_update: Some(NetworkUpdate::ChannelFailure { @@ -2342,12 +2454,64 @@ mod tests { assert_eq!(network_graph.read_only().channels().len(), 0); // Nodes are also deleted because there are no associated channels anymore assert_eq!(network_graph.read_only().nodes().len(), 0); - // TODO: Test NetworkUpdate::NodeFailure, which is not implemented yet. + + { + // Get a new network graph since we don't want to track removed nodes in this test with "std" + let network_graph = NetworkGraph::new(genesis_hash, &logger); + + // Announce a channel to test permanent node failure + let valid_channel_announcement = get_signed_channel_announcement(|_| {}, node_1_privkey, node_2_privkey, &secp_ctx); + let short_channel_id = valid_channel_announcement.contents.short_channel_id; + let chain_source: Option<&test_utils::TestChainSource> = None; + assert!(network_graph.update_channel_from_announcement(&valid_channel_announcement, &chain_source).is_ok()); + assert!(network_graph.read_only().channels().get(&short_channel_id).is_some()); + + // Non-permanent node failure does not delete any nodes or channels + network_graph.handle_event(&Event::PaymentPathFailed { + payment_id: None, + payment_hash: PaymentHash([0; 32]), + payment_failed_permanently: false, + all_paths_failed: true, + path: vec![], + network_update: Some(NetworkUpdate::NodeFailure { + node_id: node_2_id, + is_permanent: false, + }), + short_channel_id: None, + retry: None, + error_code: None, + error_data: None, + }); + + assert!(network_graph.read_only().channels().get(&short_channel_id).is_some()); + assert!(network_graph.read_only().nodes().get(&NodeId::from_pubkey(&node_2_id)).is_some()); + + // Permanent node failure deletes node and its channels + network_graph.handle_event(&Event::PaymentPathFailed { + payment_id: None, + payment_hash: PaymentHash([0; 32]), + payment_failed_permanently: false, + all_paths_failed: true, + path: vec![], + network_update: Some(NetworkUpdate::NodeFailure { + node_id: node_2_id, + is_permanent: true, + }), + short_channel_id: None, + retry: None, + error_code: None, + error_data: None, + }); + + assert_eq!(network_graph.read_only().nodes().len(), 0); + // Channels are also deleted because the associated node has been deleted + assert_eq!(network_graph.read_only().channels().len(), 0); + } } #[test] fn test_channel_timeouts() { - // Test the removal of channels with `remove_stale_channels`. + // Test the removal of channels with `remove_stale_channels_and_tracking`. let logger = test_utils::TestLogger::new(); let chain_source = test_utils::TestChainSource::new(Network::Testnet); let genesis_hash = genesis_block(Network::Testnet).header.block_hash(); @@ -2364,32 +2528,120 @@ mod tests { assert!(network_graph.update_channel_from_announcement(&valid_channel_announcement, &chain_source).is_ok()); assert!(network_graph.read_only().channels().get(&short_channel_id).is_some()); + // Submit two channel updates for each channel direction (update.flags bit). let valid_channel_update = get_signed_channel_update(|_| {}, node_1_privkey, &secp_ctx); assert!(gossip_sync.handle_channel_update(&valid_channel_update).is_ok()); assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_some()); - network_graph.remove_stale_channels_with_time(100 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); + let valid_channel_update_2 = get_signed_channel_update(|update| {update.flags |=1;}, node_2_privkey, &secp_ctx); + gossip_sync.handle_channel_update(&valid_channel_update_2).unwrap(); + assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().two_to_one.is_some()); + + network_graph.remove_stale_channels_and_tracking_with_time(100 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); assert_eq!(network_graph.read_only().channels().len(), 1); assert_eq!(network_graph.read_only().nodes().len(), 2); - network_graph.remove_stale_channels_with_time(101 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); + network_graph.remove_stale_channels_and_tracking_with_time(101 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); + #[cfg(not(feature = "std"))] { + // Make sure removed channels are tracked. + assert_eq!(network_graph.removed_channels.lock().unwrap().len(), 1); + } + network_graph.remove_stale_channels_and_tracking_with_time(101 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS + + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS); + #[cfg(feature = "std")] { // In std mode, a further check is performed before fully removing the channel - // the channel_announcement must have been received at least two weeks ago. We - // fudge that here by indicating the time has jumped two weeks. Note that the - // directional channel information will have been removed already.. + // fudge that here by indicating the time has jumped two weeks. assert_eq!(network_graph.read_only().channels().len(), 1); assert_eq!(network_graph.read_only().nodes().len(), 2); - assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_none()); + // Note that the directional channel information will have been removed already.. + // We want to check that this will work even if *one* of the channel updates is recent, + // so we should add it with a recent timestamp. + assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_none()); use std::time::{SystemTime, UNIX_EPOCH}; let announcement_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs(); - network_graph.remove_stale_channels_with_time(announcement_time + 1 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); + let valid_channel_update = get_signed_channel_update(|unsigned_channel_update| { + unsigned_channel_update.timestamp = (announcement_time + 1 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS) as u32; + }, node_1_privkey, &secp_ctx); + assert!(gossip_sync.handle_channel_update(&valid_channel_update).is_ok()); + assert!(network_graph.read_only().channels().get(&short_channel_id).unwrap().one_to_two.is_some()); + network_graph.remove_stale_channels_and_tracking_with_time(announcement_time + 1 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS); + // Make sure removed channels are tracked. + assert_eq!(network_graph.removed_channels.lock().unwrap().len(), 1); + // Provide a later time so that sufficient time has passed + network_graph.remove_stale_channels_and_tracking_with_time(announcement_time + 1 + STALE_CHANNEL_UPDATE_AGE_LIMIT_SECS + + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS); } assert_eq!(network_graph.read_only().channels().len(), 0); assert_eq!(network_graph.read_only().nodes().len(), 0); + assert!(network_graph.removed_channels.lock().unwrap().is_empty()); + + #[cfg(feature = "std")] + { + use std::time::{SystemTime, UNIX_EPOCH}; + + let tracking_time = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs(); + + // Clear tracked nodes and channels for clean slate + network_graph.removed_channels.lock().unwrap().clear(); + network_graph.removed_nodes.lock().unwrap().clear(); + + // Add a channel and nodes from channel announcement. So our network graph will + // now only consist of two nodes and one channel between them. + assert!(network_graph.update_channel_from_announcement( + &valid_channel_announcement, &chain_source).is_ok()); + + // Mark the channel as permanently failed. This will also remove the two nodes + // and all of the entries will be tracked as removed. + network_graph.channel_failed(short_channel_id, true); + + // Should not remove from tracking if insufficient time has passed + network_graph.remove_stale_channels_and_tracking_with_time( + tracking_time + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS - 1); + assert_eq!(network_graph.removed_channels.lock().unwrap().len(), 1); + + // Provide a later time so that sufficient time has passed + network_graph.remove_stale_channels_and_tracking_with_time( + tracking_time + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS); + assert!(network_graph.removed_channels.lock().unwrap().is_empty()); + assert!(network_graph.removed_nodes.lock().unwrap().is_empty()); + } + + #[cfg(not(feature = "std"))] + { + // When we don't have access to the system clock, the time we started tracking removal will only + // be that provided by the first call to `remove_stale_channels_and_tracking_with_time`. Hence, + // only if sufficient time has passed after that first call, will the next call remove it from + // tracking. + let removal_time = 1664619654; + + // Clear removed nodes and channels for clean slate + network_graph.removed_channels.lock().unwrap().clear(); + network_graph.removed_nodes.lock().unwrap().clear(); + + // Add a channel and nodes from channel announcement. So our network graph will + // now only consist of two nodes and one channel between them. + assert!(network_graph.update_channel_from_announcement( + &valid_channel_announcement, &chain_source).is_ok()); + + // Mark the channel as permanently failed. This will also remove the two nodes + // and all of the entries will be tracked as removed. + network_graph.channel_failed(short_channel_id, true); + + // The first time we call the following, the channel will have a removal time assigned. + network_graph.remove_stale_channels_and_tracking_with_time(removal_time); + assert_eq!(network_graph.removed_channels.lock().unwrap().len(), 1); + + // Provide a later time so that sufficient time has passed + network_graph.remove_stale_channels_and_tracking_with_time( + removal_time + REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS); + assert!(network_graph.removed_channels.lock().unwrap().is_empty()); + assert!(network_graph.removed_nodes.lock().unwrap().is_empty()); + } } #[test] @@ -2400,8 +2652,8 @@ mod tests { let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap(); // Channels were not announced yet. - let channels_with_announcements = gossip_sync.get_next_channel_announcements(0, 1); - assert_eq!(channels_with_announcements.len(), 0); + let channels_with_announcements = gossip_sync.get_next_channel_announcement(0); + assert!(channels_with_announcements.is_none()); let short_channel_id; { @@ -2415,17 +2667,15 @@ mod tests { } // Contains initial channel announcement now. - let channels_with_announcements = gossip_sync.get_next_channel_announcements(short_channel_id, 1); - assert_eq!(channels_with_announcements.len(), 1); - if let Some(channel_announcements) = channels_with_announcements.first() { - let &(_, ref update_1, ref update_2) = channel_announcements; + let channels_with_announcements = gossip_sync.get_next_channel_announcement(short_channel_id); + if let Some(channel_announcements) = channels_with_announcements { + let (_, ref update_1, ref update_2) = channel_announcements; assert_eq!(update_1, &None); assert_eq!(update_2, &None); } else { panic!(); } - { // Valid channel update let valid_channel_update = get_signed_channel_update(|unsigned_channel_update| { @@ -2438,10 +2688,9 @@ mod tests { } // Now contains an initial announcement and an update. - let channels_with_announcements = gossip_sync.get_next_channel_announcements(short_channel_id, 1); - assert_eq!(channels_with_announcements.len(), 1); - if let Some(channel_announcements) = channels_with_announcements.first() { - let &(_, ref update_1, ref update_2) = channel_announcements; + let channels_with_announcements = gossip_sync.get_next_channel_announcement(short_channel_id); + if let Some(channel_announcements) = channels_with_announcements { + let (_, ref update_1, ref update_2) = channel_announcements; assert_ne!(update_1, &None); assert_eq!(update_2, &None); } else { @@ -2461,10 +2710,9 @@ mod tests { } // Test that announcements with excess data won't be returned - let channels_with_announcements = gossip_sync.get_next_channel_announcements(short_channel_id, 1); - assert_eq!(channels_with_announcements.len(), 1); - if let Some(channel_announcements) = channels_with_announcements.first() { - let &(_, ref update_1, ref update_2) = channel_announcements; + let channels_with_announcements = gossip_sync.get_next_channel_announcement(short_channel_id); + if let Some(channel_announcements) = channels_with_announcements { + let (_, ref update_1, ref update_2) = channel_announcements; assert_eq!(update_1, &None); assert_eq!(update_2, &None); } else { @@ -2472,8 +2720,8 @@ mod tests { } // Further starting point have no channels after it - let channels_with_announcements = gossip_sync.get_next_channel_announcements(short_channel_id + 1000, 1); - assert_eq!(channels_with_announcements.len(), 0); + let channels_with_announcements = gossip_sync.get_next_channel_announcement(short_channel_id + 1000); + assert!(channels_with_announcements.is_none()); } #[test] @@ -2485,8 +2733,8 @@ mod tests { let node_id_1 = PublicKey::from_secret_key(&secp_ctx, node_1_privkey); // No nodes yet. - let next_announcements = gossip_sync.get_next_node_announcements(None, 10); - assert_eq!(next_announcements.len(), 0); + let next_announcements = gossip_sync.get_next_node_announcement(None); + assert!(next_announcements.is_none()); { // Announce a channel to add 2 nodes @@ -2497,10 +2745,9 @@ mod tests { }; } - // Nodes were never announced - let next_announcements = gossip_sync.get_next_node_announcements(None, 3); - assert_eq!(next_announcements.len(), 0); + let next_announcements = gossip_sync.get_next_node_announcement(None); + assert!(next_announcements.is_none()); { let valid_announcement = get_signed_node_announcement(|_| {}, node_1_privkey, &secp_ctx); @@ -2516,12 +2763,12 @@ mod tests { }; } - let next_announcements = gossip_sync.get_next_node_announcements(None, 3); - assert_eq!(next_announcements.len(), 2); + let next_announcements = gossip_sync.get_next_node_announcement(None); + assert!(next_announcements.is_some()); // Skip the first node. - let next_announcements = gossip_sync.get_next_node_announcements(Some(&node_id_1), 2); - assert_eq!(next_announcements.len(), 1); + let next_announcements = gossip_sync.get_next_node_announcement(Some(&node_id_1)); + assert!(next_announcements.is_some()); { // Later announcement which should not be relayed (excess data) prevent us from sharing a node @@ -2535,8 +2782,8 @@ mod tests { }; } - let next_announcements = gossip_sync.get_next_node_announcements(Some(&node_id_1), 2); - assert_eq!(next_announcements.len(), 0); + let next_announcements = gossip_sync.get_next_node_announcement(Some(&node_id_1)); + assert!(next_announcements.is_none()); } #[test] @@ -2587,6 +2834,7 @@ mod tests { #[cfg(feature = "std")] fn calling_sync_routing_table() { use std::time::{SystemTime, UNIX_EPOCH}; + use crate::ln::msgs::Init; let network_graph = create_network_graph(); let (secp_ctx, gossip_sync) = create_gossip_sync(&network_graph); @@ -2597,16 +2845,18 @@ mod tests { // It should ignore if gossip_queries feature is not enabled { - let init_msg = Init { features: InitFeatures::known().clear_gossip_queries(), remote_network_address: None }; - gossip_sync.peer_connected(&node_id_1, &init_msg); + let init_msg = Init { features: InitFeatures::empty(), remote_network_address: None }; + gossip_sync.peer_connected(&node_id_1, &init_msg).unwrap(); let events = gossip_sync.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 0); } // It should send a gossip_timestamp_filter with the correct information { - let init_msg = Init { features: InitFeatures::known(), remote_network_address: None }; - gossip_sync.peer_connected(&node_id_1, &init_msg); + let mut features = InitFeatures::empty(); + features.set_gossip_queries_optional(); + let init_msg = Init { features, remote_network_address: None }; + gossip_sync.peer_connected(&node_id_1, &init_msg).unwrap(); let events = gossip_sync.get_and_clear_pending_msg_events(); assert_eq!(events.len(), 1); match &events[0] { @@ -2955,10 +3205,10 @@ mod tests { #[test] fn channel_info_is_readable() { - let chanmon_cfgs = ::ln::functional_test_utils::create_chanmon_cfgs(2); - let node_cfgs = ::ln::functional_test_utils::create_node_cfgs(2, &chanmon_cfgs); - let node_chanmgrs = ::ln::functional_test_utils::create_node_chanmgrs(2, &node_cfgs, &[None, None, None, None]); - let nodes = ::ln::functional_test_utils::create_network(2, &node_cfgs, &node_chanmgrs); + let chanmon_cfgs = crate::ln::functional_test_utils::create_chanmon_cfgs(2); + let node_cfgs = crate::ln::functional_test_utils::create_node_cfgs(2, &chanmon_cfgs); + let node_chanmgrs = crate::ln::functional_test_utils::create_node_chanmgrs(2, &node_cfgs, &[None, None, None, None]); + let nodes = crate::ln::functional_test_utils::create_network(2, &node_cfgs, &node_chanmgrs); // 1. Test encoding/decoding of ChannelUpdateInfo let chan_update_info = ChannelUpdateInfo { @@ -2975,7 +3225,7 @@ mod tests { assert!(chan_update_info.write(&mut encoded_chan_update_info).is_ok()); // First make sure we can read ChannelUpdateInfos we just wrote - let read_chan_update_info: ChannelUpdateInfo = ::util::ser::Readable::read(&mut encoded_chan_update_info.as_slice()).unwrap(); + let read_chan_update_info: ChannelUpdateInfo = crate::util::ser::Readable::read(&mut encoded_chan_update_info.as_slice()).unwrap(); assert_eq!(chan_update_info, read_chan_update_info); // Check the serialization hasn't changed. @@ -2985,17 +3235,17 @@ mod tests { // Check we fail if htlc_maximum_msat is not present in either the ChannelUpdateInfo itself // or the ChannelUpdate enclosed with `last_update_message`. let legacy_chan_update_info_with_some_and_fail_update: Vec = hex::decode("b40004000000170201010402002a060800000000000004d2080909000000000000162e0a0d0c00040000000902040000000a0c8181d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f00083a840000034d013413a70000009000000000000f42400000271000000014").unwrap(); - let read_chan_update_info_res: Result = ::util::ser::Readable::read(&mut legacy_chan_update_info_with_some_and_fail_update.as_slice()); + let read_chan_update_info_res: Result = crate::util::ser::Readable::read(&mut legacy_chan_update_info_with_some_and_fail_update.as_slice()); assert!(read_chan_update_info_res.is_err()); let legacy_chan_update_info_with_none: Vec = hex::decode("2c0004000000170201010402002a060800000000000004d20801000a0d0c00040000000902040000000a0c0100").unwrap(); - let read_chan_update_info_res: Result = ::util::ser::Readable::read(&mut legacy_chan_update_info_with_none.as_slice()); + let read_chan_update_info_res: Result = crate::util::ser::Readable::read(&mut legacy_chan_update_info_with_none.as_slice()); assert!(read_chan_update_info_res.is_err()); - + // 2. Test encoding/decoding of ChannelInfo // Check we can encode/decode ChannelInfo without ChannelUpdateInfo fields present. let chan_info_none_updates = ChannelInfo { - features: ChannelFeatures::known(), + features: channelmanager::provided_channel_features(), node_one: NodeId::from_pubkey(&nodes[0].node.get_our_node_id()), one_to_two: None, node_two: NodeId::from_pubkey(&nodes[1].node.get_our_node_id()), @@ -3008,12 +3258,12 @@ mod tests { let mut encoded_chan_info: Vec = Vec::new(); assert!(chan_info_none_updates.write(&mut encoded_chan_info).is_ok()); - let read_chan_info: ChannelInfo = ::util::ser::Readable::read(&mut encoded_chan_info.as_slice()).unwrap(); + let read_chan_info: ChannelInfo = crate::util::ser::Readable::read(&mut encoded_chan_info.as_slice()).unwrap(); assert_eq!(chan_info_none_updates, read_chan_info); // Check we can encode/decode ChannelInfo with ChannelUpdateInfo fields present. let chan_info_some_updates = ChannelInfo { - features: ChannelFeatures::known(), + features: channelmanager::provided_channel_features(), node_one: NodeId::from_pubkey(&nodes[0].node.get_our_node_id()), one_to_two: Some(chan_update_info.clone()), node_two: NodeId::from_pubkey(&nodes[1].node.get_our_node_id()), @@ -3026,7 +3276,7 @@ mod tests { let mut encoded_chan_info: Vec = Vec::new(); assert!(chan_info_some_updates.write(&mut encoded_chan_info).is_ok()); - let read_chan_info: ChannelInfo = ::util::ser::Readable::read(&mut encoded_chan_info.as_slice()).unwrap(); + let read_chan_info: ChannelInfo = crate::util::ser::Readable::read(&mut encoded_chan_info.as_slice()).unwrap(); assert_eq!(chan_info_some_updates, read_chan_info); // Check the serialization hasn't changed. @@ -3036,13 +3286,13 @@ mod tests { // Check we can decode legacy ChannelInfo, even if the `two_to_one` / `one_to_two` / // `last_update_message` fields fail to decode due to missing htlc_maximum_msat. let legacy_chan_info_with_some_and_fail_update = hex::decode("fd01ca00020000010800000000000156660221027f921585f2ac0c7c70e36110adecfd8fd14b8a99bfb3d000a283fcac358fce8804b6b6b40004000000170201010402002a060800000000000004d2080909000000000000162e0a0d0c00040000000902040000000a0c8181d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f00083a840000034d013413a70000009000000000000f4240000027100000001406210355f8d2238a322d16b602bd0ceaad5b01019fb055971eaadcc9b29226a4da6c2308b6b6b40004000000170201010402002a060800000000000004d2080909000000000000162e0a0d0c00040000000902040000000a0c8181d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f00083a840000034d013413a70000009000000000000f424000002710000000140a01000c0100").unwrap(); - let read_chan_info: ChannelInfo = ::util::ser::Readable::read(&mut legacy_chan_info_with_some_and_fail_update.as_slice()).unwrap(); + let read_chan_info: ChannelInfo = crate::util::ser::Readable::read(&mut legacy_chan_info_with_some_and_fail_update.as_slice()).unwrap(); assert_eq!(read_chan_info.announcement_received_time, 87654); assert_eq!(read_chan_info.one_to_two, None); assert_eq!(read_chan_info.two_to_one, None); let legacy_chan_info_with_none: Vec = hex::decode("ba00020000010800000000000156660221027f921585f2ac0c7c70e36110adecfd8fd14b8a99bfb3d000a283fcac358fce88042e2e2c0004000000170201010402002a060800000000000004d20801000a0d0c00040000000902040000000a0c010006210355f8d2238a322d16b602bd0ceaad5b01019fb055971eaadcc9b29226a4da6c23082e2e2c0004000000170201010402002a060800000000000004d20801000a0d0c00040000000902040000000a0c01000a01000c0100").unwrap(); - let read_chan_info: ChannelInfo = ::util::ser::Readable::read(&mut legacy_chan_info_with_none.as_slice()).unwrap(); + let read_chan_info: ChannelInfo = crate::util::ser::Readable::read(&mut legacy_chan_info_with_none.as_slice()).unwrap(); assert_eq!(read_chan_info.announcement_received_time, 87654); assert_eq!(read_chan_info.one_to_two, None); assert_eq!(read_chan_info.two_to_one, None); @@ -3053,9 +3303,9 @@ mod tests { use std::convert::TryFrom; // 1. Check we can read a valid NodeAnnouncementInfo and fail on an invalid one - let valid_netaddr = ::ln::msgs::NetAddress::Hostname { hostname: ::util::ser::Hostname::try_from("A".to_string()).unwrap(), port: 1234 }; + let valid_netaddr = crate::ln::msgs::NetAddress::Hostname { hostname: crate::util::ser::Hostname::try_from("A".to_string()).unwrap(), port: 1234 }; let valid_node_ann_info = NodeAnnouncementInfo { - features: NodeFeatures::known(), + features: channelmanager::provided_node_features(), last_update: 0, rgb: [0u8; 3], alias: NodeAlias([0u8; 32]), @@ -3065,11 +3315,11 @@ mod tests { let mut encoded_valid_node_ann_info = Vec::new(); assert!(valid_node_ann_info.write(&mut encoded_valid_node_ann_info).is_ok()); - let read_valid_node_ann_info: NodeAnnouncementInfo = ::util::ser::Readable::read(&mut encoded_valid_node_ann_info.as_slice()).unwrap(); + let read_valid_node_ann_info: NodeAnnouncementInfo = crate::util::ser::Readable::read(&mut encoded_valid_node_ann_info.as_slice()).unwrap(); assert_eq!(read_valid_node_ann_info, valid_node_ann_info); let encoded_invalid_node_ann_info = hex::decode("3f0009000788a000080a51a20204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014004d2").unwrap(); - let read_invalid_node_ann_info_res: Result = ::util::ser::Readable::read(&mut encoded_invalid_node_ann_info.as_slice()); + let read_invalid_node_ann_info_res: Result = crate::util::ser::Readable::read(&mut encoded_invalid_node_ann_info.as_slice()); assert!(read_invalid_node_ann_info_res.is_err()); // 2. Check we can read a NodeInfo anyways, but set the NodeAnnouncementInfo to None if invalid @@ -3081,11 +3331,11 @@ mod tests { let mut encoded_valid_node_info = Vec::new(); assert!(valid_node_info.write(&mut encoded_valid_node_info).is_ok()); - let read_valid_node_info: NodeInfo = ::util::ser::Readable::read(&mut encoded_valid_node_info.as_slice()).unwrap(); + let read_valid_node_info: NodeInfo = crate::util::ser::Readable::read(&mut encoded_valid_node_info.as_slice()).unwrap(); assert_eq!(read_valid_node_info, valid_node_info); let encoded_invalid_node_info_hex = hex::decode("4402403f0009000788a000080a51a20204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014004d20400").unwrap(); - let read_invalid_node_info: NodeInfo = ::util::ser::Readable::read(&mut encoded_invalid_node_info_hex.as_slice()).unwrap(); + let read_invalid_node_info: NodeInfo = crate::util::ser::Readable::read(&mut encoded_invalid_node_info_hex.as_slice()).unwrap(); assert_eq!(read_invalid_node_info.announcement_info, None); } } @@ -3099,8 +3349,8 @@ mod benches { #[bench] fn read_network_graph(bench: &mut Bencher) { - let logger = ::util::test_utils::TestLogger::new(); - let mut d = ::routing::router::test_utils::get_route_file().unwrap(); + let logger = crate::util::test_utils::TestLogger::new(); + let mut d = crate::routing::router::bench_utils::get_route_file().unwrap(); let mut v = Vec::new(); d.read_to_end(&mut v).unwrap(); bench.iter(|| { @@ -3110,8 +3360,8 @@ mod benches { #[bench] fn write_network_graph(bench: &mut Bencher) { - let logger = ::util::test_utils::TestLogger::new(); - let mut d = ::routing::router::test_utils::get_route_file().unwrap(); + let logger = crate::util::test_utils::TestLogger::new(); + let mut d = crate::routing::router::bench_utils::get_route_file().unwrap(); let net_graph = NetworkGraph::read(&mut d, &logger).unwrap(); bench.iter(|| { let _ = net_graph.encode();