Rename eth2_libp2p to lighthouse_network (#2702)

## Description

The `eth2_libp2p` crate was originally named and designed to incorporate a simple libp2p integration into lighthouse. Since its origins the crates purpose has expanded dramatically. It now houses a lot more sophistication that is specific to lighthouse and no longer just a libp2p integration. 

As of this writing it currently houses the following high-level lighthouse-specific logic:
- Lighthouse's implementation of the eth2 RPC protocol and specific encodings/decodings
- Integration and handling of ENRs with respect to libp2p and eth2
- Lighthouse's discovery logic, its integration with discv5 and logic about searching and handling peers. 
- Lighthouse's peer manager - This is a large module handling various aspects of Lighthouse's network, such as peer scoring, handling pings and metadata, connection maintenance and recording, etc.
- Lighthouse's peer database - This is a collection of information stored for each individual peer which is specific to lighthouse. We store connection state, sync state, last seen ips and scores etc. The data stored for each peer is designed for various elements of the lighthouse code base such as syncing and the http api.
- Gossipsub scoring - This stores a collection of gossipsub 1.1 scoring mechanisms that are continuously analyssed and updated based on the ethereum 2 networks and how Lighthouse performs on these networks.
- Lighthouse specific types for managing gossipsub topics, sync status and ENR fields
- Lighthouse's network HTTP API metrics - A collection of metrics for lighthouse network monitoring
- Lighthouse's custom configuration of all networking protocols, RPC, gossipsub, discovery, identify and libp2p. 

Therefore it makes sense to rename the crate to be more akin to its current purposes, simply that it manages the majority of Lighthouse's network stack. This PR renames this crate to `lighthouse_network`

Co-authored-by: Paul Hauner <paul@paulhauner.com>

beacon_node/network/Cargo.toml

@@ -17,7 +17,7 @@ environment = { path = "../../lighthouse/environment" }
 [dependencies]
 beacon_chain =  { path = "../beacon_chain" }
 store =  { path = "../store" }
-eth2_libp2p =  { path = "../eth2_libp2p" }
+lighthouse_network =  { path = "../lighthouse_network" }
 hashset_delay = { path = "../../common/hashset_delay" }
 types = { path = "../../consensus/types" }
 slot_clock = { path = "../../common/slot_clock" }

beacon_node/network/src/beacon_processor/mod.rs

@@ -40,12 +40,12 @@
 
 use crate::{metrics, service::NetworkMessage, sync::SyncMessage};
 use beacon_chain::{BeaconChain, BeaconChainTypes, BlockError, GossipVerifiedBlock};
-use eth2_libp2p::{
+use futures::stream::{Stream, StreamExt};
+use futures::task::Poll;
+use lighthouse_network::{
     rpc::{BlocksByRangeRequest, BlocksByRootRequest, StatusMessage},
     Client, MessageId, NetworkGlobals, PeerId, PeerRequestId,
 };
-use futures::stream::{Stream, StreamExt};
-use futures::task::Poll;
 use slog::{crit, debug, error, trace, warn, Logger};
 use std::cmp;
 use std::collections::VecDeque;

beacon_node/network/src/beacon_processor/tests.rs

@@ -9,7 +9,7 @@ use beacon_chain::test_utils::{
 };
 use beacon_chain::{BeaconChain, MAXIMUM_GOSSIP_CLOCK_DISPARITY};
 use environment::{null_logger, Environment, EnvironmentBuilder};
-use eth2_libp2p::{
+use lighthouse_network::{
     discv5::enr::{CombinedKey, EnrBuilder},
     rpc::methods::{MetaData, MetaDataV2},
     types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield},

beacon_node/network/src/beacon_processor/work_reprocessing_queue.rs

@@ -13,10 +13,10 @@
 use super::MAX_SCHEDULED_WORK_QUEUE_LEN;
 use crate::metrics;
 use beacon_chain::{BeaconChainTypes, GossipVerifiedBlock, MAXIMUM_GOSSIP_CLOCK_DISPARITY};
-use eth2_libp2p::{MessageId, PeerId};
 use fnv::FnvHashMap;
 use futures::task::Poll;
 use futures::{Stream, StreamExt};
+use lighthouse_network::{MessageId, PeerId};
 use slog::{crit, debug, error, warn, Logger};
 use slot_clock::SlotClock;
 use std::collections::{HashMap, HashSet};

beacon_node/network/src/beacon_processor/worker/gossip_methods.rs

@@ -7,7 +7,7 @@ use beacon_chain::{
     validator_monitor::get_block_delay_ms,
     BeaconChainError, BeaconChainTypes, BlockError, ForkChoiceError, GossipVerifiedBlock,
 };
-use eth2_libp2p::{Client, MessageAcceptance, MessageId, PeerAction, PeerId, ReportSource};
+use lighthouse_network::{Client, MessageAcceptance, MessageId, PeerAction, PeerId, ReportSource};
 use slog::{crit, debug, error, info, trace, warn};
 use slot_clock::SlotClock;
 use ssz::Encode;

beacon_node/network/src/beacon_processor/worker/rpc_methods.rs

@@ -3,10 +3,10 @@ use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
 use crate::sync::SyncMessage;
 use beacon_chain::{BeaconChainError, BeaconChainTypes, HistoricalBlockError, WhenSlotSkipped};
-use eth2_libp2p::rpc::StatusMessage;
-use eth2_libp2p::rpc::*;
-use eth2_libp2p::{PeerId, PeerRequestId, ReportSource, Response, SyncInfo};
 use itertools::process_results;
+use lighthouse_network::rpc::StatusMessage;
+use lighthouse_network::rpc::*;
+use lighthouse_network::{PeerId, PeerRequestId, ReportSource, Response, SyncInfo};
 use slog::{debug, error, warn};
 use slot_clock::SlotClock;
 use types::{Epoch, EthSpec, Hash256, Slot};

beacon_node/network/src/beacon_processor/worker/sync_methods.rs

@@ -7,7 +7,7 @@ use crate::sync::{BatchProcessResult, ChainId};
 use beacon_chain::{
     BeaconChainError, BeaconChainTypes, BlockError, ChainSegmentResult, HistoricalBlockError,
 };
-use eth2_libp2p::PeerId;
+use lighthouse_network::PeerId;
 use slog::{crit, debug, error, info, trace, warn};
 use tokio::sync::mpsc;
 use types::{Epoch, Hash256, SignedBeaconBlock};

beacon_node/network/src/error.rs

@@ -3,6 +3,6 @@ use error_chain::error_chain;
 
 error_chain! {
    links  {
-       Libp2p(eth2_libp2p::error::Error, eth2_libp2p::error::ErrorKind);
+       Libp2p(lighthouse_network::error::Error, lighthouse_network::error::ErrorKind);
    }
 }

beacon_node/network/src/lib.rs

@@ -17,5 +17,5 @@ mod subnet_service;
 #[allow(clippy::mutable_key_type)] // PeerId in hashmaps are no longer permitted by clippy
 mod sync;
 
-pub use eth2_libp2p::NetworkConfig;
+pub use lighthouse_network::NetworkConfig;
 pub use service::{NetworkMessage, NetworkService};

beacon_node/network/src/metrics.rs

@@ -2,12 +2,12 @@ use beacon_chain::{
     attestation_verification::Error as AttnError,
     sync_committee_verification::Error as SyncCommitteeError,
 };
-use eth2_libp2p::PubsubMessage;
-use eth2_libp2p::{
-    types::GossipKind, BandwidthSinks, GossipTopic, Gossipsub, NetworkGlobals, TopicHash,
-};
 use fnv::FnvHashMap;
 pub use lighthouse_metrics::*;
+use lighthouse_network::PubsubMessage;
+use lighthouse_network::{
+    types::GossipKind, BandwidthSinks, GossipTopic, Gossipsub, NetworkGlobals, TopicHash,
+};
 use std::{collections::HashMap, sync::Arc};
 use strum::AsStaticRef;
 use types::{

beacon_node/network/src/persisted_dht.rs

@@ -1,4 +1,4 @@
-use eth2_libp2p::Enr;
+use lighthouse_network::Enr;
 use std::sync::Arc;
 use store::{DBColumn, Error as StoreError, HotColdDB, ItemStore, StoreItem};
 use types::{EthSpec, Hash256};
@@ -60,7 +60,7 @@ impl StoreItem for PersistedDht {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use eth2_libp2p::Enr;
+    use lighthouse_network::Enr;
     use sloggers::{null::NullLoggerBuilder, Build};
     use std::str::FromStr;
     use store::config::StoreConfig;

beacon_node/network/src/router/mod.rs

@@ -10,11 +10,11 @@ mod processor;
 use crate::error;
 use crate::service::NetworkMessage;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::{
+use futures::prelude::*;
+use lighthouse_network::{
     rpc::RequestId, MessageId, NetworkGlobals, PeerId, PeerRequestId, PubsubMessage, Request,
     Response,
 };
-use futures::prelude::*;
 use processor::Processor;
 use slog::{debug, o, trace};
 use std::sync::Arc;

beacon_node/network/src/router/processor.rs

@@ -4,8 +4,10 @@ use crate::beacon_processor::{
 use crate::service::NetworkMessage;
 use crate::sync::SyncMessage;
 use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
-use eth2_libp2p::rpc::*;
-use eth2_libp2p::{Client, MessageId, NetworkGlobals, PeerId, PeerRequestId, Request, Response};
+use lighthouse_network::rpc::*;
+use lighthouse_network::{
+    Client, MessageId, NetworkGlobals, PeerId, PeerRequestId, Request, Response,
+};
 use slog::{debug, error, o, trace, warn};
 use std::cmp;
 use std::sync::Arc;

beacon_node/network/src/service.rs

@@ -7,17 +7,17 @@ use crate::{
     NetworkConfig,
 };
 use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
-use eth2_libp2p::{
+use futures::future::OptionFuture;
+use futures::prelude::*;
+use lighthouse_network::{
     rpc::{GoodbyeReason, RPCResponseErrorCode, RequestId},
     Libp2pEvent, PeerAction, PeerRequestId, PubsubMessage, ReportSource, Request, Response, Subnet,
 };
-use eth2_libp2p::{
+use lighthouse_network::{
     types::{GossipEncoding, GossipTopic},
     BehaviourEvent, MessageId, NetworkGlobals, PeerId,
 };
-use eth2_libp2p::{MessageAcceptance, Service as LibP2PService};
-use futures::future::OptionFuture;
-use futures::prelude::*;
+use lighthouse_network::{MessageAcceptance, Service as LibP2PService};
 use slog::{crit, debug, error, info, o, trace, warn};
 use std::{net::SocketAddr, pin::Pin, sync::Arc, time::Duration};
 use store::HotColdDB;
@@ -102,7 +102,7 @@ pub enum NetworkMessage<T: EthSpec> {
     },
 }
 
-/// Service that handles communication between internal services and the `eth2_libp2p` network service.
+/// Service that handles communication between internal services and the `lighthouse_network` network service.
 pub struct NetworkService<T: BeaconChainTypes> {
     /// A reference to the underlying beacon chain.
     beacon_chain: Arc<BeaconChain<T>>,
@@ -469,7 +469,7 @@ fn spawn_service<T: BeaconChainTypes>(
                                 return;
                             }
                             let mut subscribed_topics: Vec<GossipTopic> = vec![];
-                            for topic_kind in eth2_libp2p::types::CORE_TOPICS.iter() {
+                            for topic_kind in lighthouse_network::types::CORE_TOPICS.iter() {
                                 for fork_digest in service.required_gossip_fork_digests() {
                                     let topic = GossipTopic::new(topic_kind.clone(), GossipEncoding::default(), fork_digest);
                                     if service.libp2p.swarm.behaviour_mut().subscribe(topic.clone()) {

beacon_node/network/src/service/tests.rs

@@ -4,7 +4,7 @@ mod tests {
     use crate::persisted_dht::load_dht;
     use crate::{NetworkConfig, NetworkService};
     use beacon_chain::test_utils::BeaconChainHarness;
-    use eth2_libp2p::Enr;
+    use lighthouse_network::Enr;
     use slog::{o, Drain, Level, Logger};
     use sloggers::{null::NullLoggerBuilder, Build};
     use std::str::FromStr;

beacon_node/network/src/status.rs

@@ -1,6 +1,6 @@
 use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
 
-use eth2_libp2p::rpc::StatusMessage;
+use lighthouse_network::rpc::StatusMessage;
 /// Trait to produce a `StatusMessage` representing the state of the given `beacon_chain`.
 ///
 /// NOTE: The purpose of this is simply to obtain a `StatusMessage` from the `BeaconChain` without

beacon_node/network/src/subnet_service/attestation_subnets.rs

@@ -14,8 +14,8 @@ use rand::seq::SliceRandom;
 use slog::{debug, error, o, trace, warn};
 
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::{NetworkConfig, Subnet, SubnetDiscovery};
 use hashset_delay::HashSetDelay;
+use lighthouse_network::{NetworkConfig, Subnet, SubnetDiscovery};
 use slot_clock::SlotClock;
 use types::{Attestation, EthSpec, Slot, SubnetId, ValidatorSubscription};
 

beacon_node/network/src/subnet_service/mod.rs

@@ -1,7 +1,7 @@
 pub mod attestation_subnets;
 pub mod sync_subnets;
 
-use eth2_libp2p::{Subnet, SubnetDiscovery};
+use lighthouse_network::{Subnet, SubnetDiscovery};
 
 pub use attestation_subnets::AttestationService;
 pub use sync_subnets::SyncCommitteeService;

beacon_node/network/src/subnet_service/sync_subnets.rs

@@ -12,8 +12,8 @@ use slog::{debug, error, o, trace, warn};
 
 use super::SubnetServiceMessage;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::{NetworkConfig, Subnet, SubnetDiscovery};
 use hashset_delay::HashSetDelay;
+use lighthouse_network::{NetworkConfig, Subnet, SubnetDiscovery};
 use slot_clock::SlotClock;
 use types::{Epoch, EthSpec, SyncCommitteeSubscription, SyncSubnetId};
 

beacon_node/network/src/subnet_service/tests/mod.rs

@@ -4,10 +4,10 @@ use beacon_chain::{
     eth1_chain::CachingEth1Backend,
     BeaconChain,
 };
-use eth2_libp2p::NetworkConfig;
 use futures::prelude::*;
 use genesis::{generate_deterministic_keypairs, interop_genesis_state};
 use lazy_static::lazy_static;
+use lighthouse_network::NetworkConfig;
 use slog::Logger;
 use sloggers::{null::NullLoggerBuilder, Build};
 use slot_clock::{SlotClock, SystemTimeSlotClock};

beacon_node/network/src/sync/backfill_sync/mod.rs

@@ -14,8 +14,8 @@ use crate::sync::manager::BatchProcessResult;
 use crate::sync::network_context::SyncNetworkContext;
 use crate::sync::range_sync::{BatchConfig, BatchId, BatchInfo, BatchState};
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::types::{BackFillState, NetworkGlobals};
-use eth2_libp2p::{PeerAction, PeerId};
+use lighthouse_network::types::{BackFillState, NetworkGlobals};
+use lighthouse_network::{PeerAction, PeerId};
 use rand::seq::SliceRandom;
 use slog::{crit, debug, error, info, warn};
 use std::collections::{

beacon_node/network/src/sync/manager.rs

@@ -42,11 +42,11 @@ use crate::beacon_processor::{ProcessId, WorkEvent as BeaconWorkEvent};
 use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
 use beacon_chain::{BeaconChain, BeaconChainTypes, BlockError};
-use eth2_libp2p::rpc::{methods::MAX_REQUEST_BLOCKS, BlocksByRootRequest, GoodbyeReason};
-use eth2_libp2p::types::{NetworkGlobals, SyncState};
-use eth2_libp2p::SyncInfo;
-use eth2_libp2p::{PeerAction, PeerId};
 use fnv::FnvHashMap;
+use lighthouse_network::rpc::{methods::MAX_REQUEST_BLOCKS, BlocksByRootRequest, GoodbyeReason};
+use lighthouse_network::types::{NetworkGlobals, SyncState};
+use lighthouse_network::SyncInfo;
+use lighthouse_network::{PeerAction, PeerId};
 use lru_cache::LRUCache;
 use slog::{crit, debug, error, info, trace, warn, Logger};
 use smallvec::SmallVec;

beacon_node/network/src/sync/network_context.rs

@@ -7,9 +7,11 @@ use super::RequestId as SyncRequestId;
 use crate::service::NetworkMessage;
 use crate::status::ToStatusMessage;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::rpc::{BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, RequestId};
-use eth2_libp2p::{Client, NetworkGlobals, PeerAction, PeerId, ReportSource, Request};
 use fnv::FnvHashMap;
+use lighthouse_network::rpc::{
+    BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, RequestId,
+};
+use lighthouse_network::{Client, NetworkGlobals, PeerAction, PeerId, ReportSource, Request};
 use slog::{debug, trace, warn};
 use std::sync::Arc;
 use tokio::sync::mpsc;

beacon_node/network/src/sync/peer_sync_info.rs

@@ -1,6 +1,6 @@
 use super::manager::SLOT_IMPORT_TOLERANCE;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::{SyncInfo, SyncStatus as PeerSyncStatus};
+use lighthouse_network::{SyncInfo, SyncStatus as PeerSyncStatus};
 use std::cmp::Ordering;
 
 /// The type of peer relative to our current state.

beacon_node/network/src/sync/range_sync/batch.rs

@@ -1,6 +1,6 @@
 use crate::sync::RequestId;
-use eth2_libp2p::rpc::methods::BlocksByRangeRequest;
-use eth2_libp2p::PeerId;
+use lighthouse_network::rpc::methods::BlocksByRangeRequest;
+use lighthouse_network::PeerId;
 use ssz::Encode;
 use std::collections::HashSet;
 use std::hash::{Hash, Hasher};

beacon_node/network/src/sync/range_sync/chain.rs

@@ -3,8 +3,8 @@ use crate::beacon_processor::ProcessId;
 use crate::beacon_processor::WorkEvent as BeaconWorkEvent;
 use crate::sync::{network_context::SyncNetworkContext, BatchProcessResult, RequestId};
 use beacon_chain::BeaconChainTypes;
-use eth2_libp2p::{PeerAction, PeerId};
 use fnv::FnvHashMap;
+use lighthouse_network::{PeerAction, PeerId};
 use rand::seq::SliceRandom;
 use slog::{crit, debug, o, warn};
 use std::collections::{btree_map::Entry, BTreeMap, HashSet};

beacon_node/network/src/sync/range_sync/chain_collection.rs

@@ -9,9 +9,9 @@ use crate::beacon_processor::WorkEvent as BeaconWorkEvent;
 use crate::metrics;
 use crate::sync::network_context::SyncNetworkContext;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::PeerId;
-use eth2_libp2p::SyncInfo;
 use fnv::FnvHashMap;
+use lighthouse_network::PeerId;
+use lighthouse_network::SyncInfo;
 use slog::{crit, debug, error};
 use smallvec::SmallVec;
 use std::collections::hash_map::Entry;

beacon_node/network/src/sync/range_sync/range.rs

@@ -47,8 +47,8 @@ use crate::status::ToStatusMessage;
 use crate::sync::network_context::SyncNetworkContext;
 use crate::sync::{BatchProcessResult, RequestId};
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::PeerId;
-use eth2_libp2p::SyncInfo;
+use lighthouse_network::PeerId;
+use lighthouse_network::SyncInfo;
 use slog::{crit, debug, error, trace};
 use std::collections::HashMap;
 use std::sync::Arc;

beacon_node/network/src/sync/range_sync/sync_type.rs

@@ -2,7 +2,7 @@
 //! of a remote.
 
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_libp2p::SyncInfo;
+use lighthouse_network::SyncInfo;
 use std::sync::Arc;
 
 /// The type of Range sync that should be done relative to our current state.