Silky smooth discovery (#1274)

* Initial structural re-write

* Improving discovery update and correcting attestation service logic

* Rework discovery.mod

* Handling lifetimes of query futures

* Discovery update first draft

* format fixes

* Stabalise discv5 update

* Formatting corrections

* Limit FindPeers queries and bug correction

* Update to stable release discv5

* Remove unnecessary pin

* formatting

beacon_node/eth2_libp2p/src/peer_manager/client.rs

@@ -0,0 +1,151 @@
+//! Known Ethereum 2.0 clients and their fingerprints.
+//!
+//! Currently using identify to fingerprint.
+
+use libp2p::identify::IdentifyInfo;
+use serde::Serialize;
+
+/// Various client and protocol information related to a node.
+#[derive(Clone, Debug, Serialize)]
+pub struct Client {
+    /// The client's name (Ex: lighthouse, prism, nimbus, etc)
+    pub kind: ClientKind,
+    /// The client's version.
+    pub version: String,
+    /// The OS version of the client.
+    pub os_version: String,
+    /// The libp2p protocol version.
+    pub protocol_version: String,
+    /// Identify agent string
+    pub agent_string: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub enum ClientKind {
+    /// A lighthouse node (the best kind).
+    Lighthouse,
+    /// A Nimbus node.
+    Nimbus,
+    /// A Teku node.
+    Teku,
+    /// A Prysm node.
+    Prysm,
+    /// An unknown client.
+    Unknown,
+}
+
+impl Default for Client {
+    fn default() -> Self {
+        Client {
+            kind: ClientKind::Unknown,
+            version: "unknown".into(),
+            os_version: "unknown".into(),
+            protocol_version: "unknown".into(),
+            agent_string: None,
+        }
+    }
+}
+
+impl Client {
+    /// Builds a `Client` from `IdentifyInfo`.
+    pub fn from_identify_info(info: &IdentifyInfo) -> Self {
+        let (kind, version, os_version) = client_from_agent_version(&info.agent_version);
+
+        Client {
+            kind,
+            version,
+            os_version,
+            protocol_version: info.protocol_version.clone(),
+            agent_string: Some(info.agent_version.clone()),
+        }
+    }
+}
+
+impl std::fmt::Display for Client {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.kind {
+            ClientKind::Lighthouse => write!(
+                f,
+                "Lighthouse: version: {}, os_version: {}",
+                self.version, self.os_version
+            ),
+            ClientKind::Teku => write!(
+                f,
+                "Teku: version: {}, os_version: {}",
+                self.version, self.os_version
+            ),
+            ClientKind::Nimbus => write!(
+                f,
+                "Nimbus: version: {}, os_version: {}",
+                self.version, self.os_version
+            ),
+            ClientKind::Prysm => write!(
+                f,
+                "Prysm: version: {}, os_version: {}",
+                self.version, self.os_version
+            ),
+            ClientKind::Unknown => {
+                if let Some(agent_string) = &self.agent_string {
+                    write!(f, "Unknown: {}", agent_string)
+                } else {
+                    write!(f, "Unknown")
+                }
+            }
+        }
+    }
+}
+
+// helper function to identify clients from their agent_version. Returns the client
+// kind and it's associated version and the OS kind.
+fn client_from_agent_version(agent_version: &str) -> (ClientKind, String, String) {
+    let mut agent_split = agent_version.split('/');
+    match agent_split.next() {
+        Some("Lighthouse") => {
+            let kind = ClientKind::Lighthouse;
+            let mut version = String::from("unknown");
+            let mut os_version = version.clone();
+            if let Some(agent_version) = agent_split.next() {
+                version = agent_version.into();
+                if let Some(agent_os_version) = agent_split.next() {
+                    os_version = agent_os_version.into();
+                }
+            }
+            (kind, version, os_version)
+        }
+        Some("teku") => {
+            let kind = ClientKind::Teku;
+            let mut version = String::from("unknown");
+            let mut os_version = version.clone();
+            if agent_split.next().is_some() {
+                if let Some(agent_version) = agent_split.next() {
+                    version = agent_version.into();
+                    if let Some(agent_os_version) = agent_split.next() {
+                        os_version = agent_os_version.into();
+                    }
+                }
+            }
+            (kind, version, os_version)
+        }
+        Some("github.com") => {
+            let kind = ClientKind::Prysm;
+            let unknown = String::from("unknown");
+            (kind, unknown.clone(), unknown)
+        }
+        Some("nim-libp2p") => {
+            let kind = ClientKind::Nimbus;
+            let mut version = String::from("unknown");
+            let mut os_version = version.clone();
+            if let Some(agent_version) = agent_split.next() {
+                version = agent_version.into();
+                if let Some(agent_os_version) = agent_split.next() {
+                    os_version = agent_os_version.into();
+                }
+            }
+            (kind, version, os_version)
+        }
+        _ => {
+            let unknown = String::from("unknown");
+            (ClientKind::Unknown, unknown.clone(), unknown)
+        }
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/discovery/enr.rs

@@ -0,0 +1,169 @@
+//! Helper functions and an extension trait for Ethereum 2 ENRs.
+
+pub use discv5::enr::{self, CombinedKey, EnrBuilder};
+
+use super::enr_ext::CombinedKeyExt;
+use super::ENR_FILENAME;
+use crate::types::{Enr, EnrBitfield};
+use crate::NetworkConfig;
+use libp2p::core::identity::Keypair;
+use slog::{debug, warn};
+use ssz::{Decode, Encode};
+use ssz_types::BitVector;
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::Path;
+use std::str::FromStr;
+use types::{EnrForkId, EthSpec};
+
+/// The ENR field specifying the fork id.
+pub const ETH2_ENR_KEY: &'static str = "eth2";
+/// The ENR field specifying the subnet bitfield.
+pub const BITFIELD_ENR_KEY: &'static str = "attnets";
+
+/// Extension trait for ENR's within Eth2.
+pub trait Eth2Enr {
+    /// The subnet bitfield associated with the ENR.
+    fn bitfield<TSpec: EthSpec>(&self) -> Result<EnrBitfield<TSpec>, &'static str>;
+
+    fn eth2(&self) -> Result<EnrForkId, &'static str>;
+}
+
+impl Eth2Enr for Enr {
+    fn bitfield<TSpec: EthSpec>(&self) -> Result<EnrBitfield<TSpec>, &'static str> {
+        let bitfield_bytes = self
+            .get(BITFIELD_ENR_KEY)
+            .ok_or_else(|| "ENR bitfield non-existent")?;
+
+        BitVector::<TSpec::SubnetBitfieldLength>::from_ssz_bytes(bitfield_bytes)
+            .map_err(|_| "Could not decode the ENR SSZ bitfield")
+    }
+
+    fn eth2(&self) -> Result<EnrForkId, &'static str> {
+        let eth2_bytes = self
+            .get(ETH2_ENR_KEY)
+            .ok_or_else(|| "ENR has no eth2 field")?;
+
+        EnrForkId::from_ssz_bytes(eth2_bytes).map_err(|_| "Could not decode EnrForkId")
+    }
+}
+
+/// Loads an ENR from file if it exists and matches the current NodeId and sequence number. If none
+/// exists, generates a new one.
+///
+/// If an ENR exists, with the same NodeId, this function checks to see if the loaded ENR from
+/// disk is suitable to use, otherwise we increment our newly generated ENR's sequence number.
+pub fn build_or_load_enr<T: EthSpec>(
+    local_key: Keypair,
+    config: &NetworkConfig,
+    enr_fork_id: EnrForkId,
+    log: &slog::Logger,
+) -> Result<Enr, String> {
+    // Build the local ENR.
+    // Note: Discovery should update the ENR record's IP to the external IP as seen by the
+    // majority of our peers, if the CLI doesn't expressly forbid it.
+    let enr_key = CombinedKey::from_libp2p(&local_key)?;
+    let mut local_enr = build_enr::<T>(&enr_key, config, enr_fork_id)?;
+
+    let enr_f = config.network_dir.join(ENR_FILENAME);
+    if let Ok(mut enr_file) = File::open(enr_f.clone()) {
+        let mut enr_string = String::new();
+        match enr_file.read_to_string(&mut enr_string) {
+            Err(_) => debug!(log, "Could not read ENR from file"),
+            Ok(_) => {
+                match Enr::from_str(&enr_string) {
+                    Ok(disk_enr) => {
+                        // if the same node id, then we may need to update our sequence number
+                        if local_enr.node_id() == disk_enr.node_id() {
+                            if compare_enr(&local_enr, &disk_enr) {
+                                debug!(log, "ENR loaded from disk"; "file" => format!("{:?}", enr_f));
+                                // the stored ENR has the same configuration, use it
+                                return Ok(disk_enr);
+                            }
+
+                            // same node id, different configuration - update the sequence number
+                            let new_seq_no = disk_enr.seq().checked_add(1).ok_or_else(|| "ENR sequence number on file is too large. Remove it to generate a new NodeId")?;
+                            local_enr.set_seq(new_seq_no, &enr_key).map_err(|e| {
+                                format!("Could not update ENR sequence number: {:?}", e)
+                            })?;
+                            debug!(log, "ENR sequence number increased"; "seq" =>  new_seq_no);
+                        }
+                    }
+                    Err(e) => {
+                        warn!(log, "ENR from file could not be decoded"; "error" => format!("{:?}", e));
+                    }
+                }
+            }
+        }
+    }
+
+    save_enr_to_disk(&config.network_dir, &local_enr, log);
+
+    Ok(local_enr)
+}
+
+/// Builds a lighthouse ENR given a `NetworkConfig`.
+pub fn build_enr<T: EthSpec>(
+    enr_key: &CombinedKey,
+    config: &NetworkConfig,
+    enr_fork_id: EnrForkId,
+) -> Result<Enr, String> {
+    let mut builder = EnrBuilder::new("v4");
+    if let Some(enr_address) = config.enr_address {
+        builder.ip(enr_address);
+    }
+    if let Some(udp_port) = config.enr_udp_port {
+        builder.udp(udp_port);
+    }
+    // we always give it our listening tcp port
+    // TODO: Add uPnP support to map udp and tcp ports
+    let tcp_port = config.enr_tcp_port.unwrap_or_else(|| config.libp2p_port);
+    builder.tcp(tcp_port);
+
+    // set the `eth2` field on our ENR
+    builder.add_value(ETH2_ENR_KEY.into(), enr_fork_id.as_ssz_bytes());
+
+    // set the "attnets" field on our ENR
+    let bitfield = BitVector::<T::SubnetBitfieldLength>::new();
+
+    builder.add_value(BITFIELD_ENR_KEY.into(), bitfield.as_ssz_bytes());
+
+    builder
+        .tcp(config.libp2p_port)
+        .build(enr_key)
+        .map_err(|e| format!("Could not build Local ENR: {:?}", e))
+}
+
+/// Defines the conditions under which we use the locally built ENR or the one stored on disk.
+/// If this function returns true, we use the `disk_enr`.
+fn compare_enr(local_enr: &Enr, disk_enr: &Enr) -> bool {
+    // take preference over disk_enr address if one is not specified
+    (local_enr.ip().is_none() || local_enr.ip() == disk_enr.ip())
+        // tcp ports must match
+        && local_enr.tcp() == disk_enr.tcp()
+        // must match on the same fork
+        && local_enr.get(ETH2_ENR_KEY) == disk_enr.get(ETH2_ENR_KEY)
+        // take preference over disk udp port if one is not specified
+        && (local_enr.udp().is_none() || local_enr.udp() == disk_enr.udp())
+        // we need the BITFIELD_ENR_KEY key to match, otherwise we use a new ENR. This will likely only
+        // be true for non-validating nodes
+        && local_enr.get(BITFIELD_ENR_KEY) == disk_enr.get(BITFIELD_ENR_KEY)
+}
+
+/// Saves an ENR to disk
+pub fn save_enr_to_disk(dir: &Path, enr: &Enr, log: &slog::Logger) {
+    let _ = std::fs::create_dir_all(dir);
+    match File::create(dir.join(Path::new(ENR_FILENAME)))
+        .and_then(|mut f| f.write_all(&enr.to_base64().as_bytes()))
+    {
+        Ok(_) => {
+            debug!(log, "ENR written to disk");
+        }
+        Err(e) => {
+            warn!(
+                log,
+                "Could not write ENR to file"; "file" => format!("{:?}{:?}",dir, ENR_FILENAME),  "error" => format!("{}", e)
+            );
+        }
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/discovery/enr_ext.rs

@@ -0,0 +1,190 @@
+//! ENR extension trait to support libp2p integration.
+use crate::{Enr, Multiaddr, PeerId};
+use discv5::enr::{CombinedKey, CombinedPublicKey};
+use libp2p::core::{identity::Keypair, identity::PublicKey, multiaddr::Protocol};
+use tiny_keccak::{Hasher, Keccak};
+
+/// Extend ENR for libp2p types.
+pub trait EnrExt {
+    /// The libp2p `PeerId` for the record.
+    fn peer_id(&self) -> PeerId;
+
+    /// Returns a list of multiaddrs if the ENR has an `ip` and either a `tcp` or `udp` key **or** an `ip6` and either a `tcp6` or `udp6`.
+    /// The vector remains empty if these fields are not defined.
+    fn multiaddr(&self) -> Vec<Multiaddr>;
+}
+
+/// Extend ENR CombinedPublicKey for libp2p types.
+pub trait CombinedKeyPublicExt {
+    /// Converts the publickey into a peer id, without consuming the key.
+    fn into_peer_id(&self) -> PeerId;
+}
+
+/// Extend ENR CombinedKey for conversion to libp2p keys.
+pub trait CombinedKeyExt {
+    /// Converts a libp2p key into an ENR combined key.
+    fn from_libp2p(key: &libp2p::core::identity::Keypair) -> Result<CombinedKey, &'static str>;
+}
+
+impl EnrExt for Enr {
+    /// The libp2p `PeerId` for the record.
+    fn peer_id(&self) -> PeerId {
+        self.public_key().into_peer_id()
+    }
+
+    /// Returns a list of multiaddrs if the ENR has an `ip` and either a `tcp` or `udp` key **or** an `ip6` and either a `tcp6` or `udp6`.
+    /// The vector remains empty if these fields are not defined.
+    ///
+    /// Note: Only available with the `libp2p` feature flag.
+    fn multiaddr(&self) -> Vec<Multiaddr> {
+        let mut multiaddrs: Vec<Multiaddr> = Vec::new();
+        if let Some(ip) = self.ip() {
+            if let Some(udp) = self.udp() {
+                let mut multiaddr: Multiaddr = ip.into();
+                multiaddr.push(Protocol::Udp(udp));
+                multiaddrs.push(multiaddr);
+            }
+
+            if let Some(tcp) = self.tcp() {
+                let mut multiaddr: Multiaddr = ip.into();
+                multiaddr.push(Protocol::Tcp(tcp));
+                multiaddrs.push(multiaddr);
+            }
+        }
+        if let Some(ip6) = self.ip6() {
+            if let Some(udp6) = self.udp6() {
+                let mut multiaddr: Multiaddr = ip6.into();
+                multiaddr.push(Protocol::Udp(udp6));
+                multiaddrs.push(multiaddr);
+            }
+
+            if let Some(tcp6) = self.tcp6() {
+                let mut multiaddr: Multiaddr = ip6.into();
+                multiaddr.push(Protocol::Tcp(tcp6));
+                multiaddrs.push(multiaddr);
+            }
+        }
+        multiaddrs
+    }
+}
+
+impl CombinedKeyPublicExt for CombinedPublicKey {
+    /// Converts the publickey into a peer id, without consuming the key.
+    ///
+    /// This is only available with the `libp2p` feature flag.
+    fn into_peer_id(&self) -> PeerId {
+        match self {
+            Self::Secp256k1(pk) => {
+                let pk_bytes = pk.serialize_compressed();
+                let libp2p_pk = libp2p::core::PublicKey::Secp256k1(
+                    libp2p::core::identity::secp256k1::PublicKey::decode(&pk_bytes)
+                        .expect("valid public key"),
+                );
+                PeerId::from_public_key(libp2p_pk)
+            }
+            Self::Ed25519(pk) => {
+                let pk_bytes = pk.to_bytes();
+                let libp2p_pk = libp2p::core::PublicKey::Ed25519(
+                    libp2p::core::identity::ed25519::PublicKey::decode(&pk_bytes)
+                        .expect("valid public key"),
+                );
+                PeerId::from_public_key(libp2p_pk)
+            }
+        }
+    }
+}
+
+impl CombinedKeyExt for CombinedKey {
+    fn from_libp2p(key: &libp2p::core::identity::Keypair) -> Result<CombinedKey, &'static str> {
+        match key {
+            Keypair::Secp256k1(key) => {
+                let secret = discv5::enr::secp256k1::SecretKey::parse(&key.secret().to_bytes())
+                    .expect("libp2p key must be valid");
+                Ok(CombinedKey::Secp256k1(secret))
+            }
+            Keypair::Ed25519(key) => {
+                let ed_keypair =
+                    discv5::enr::ed25519_dalek::SecretKey::from_bytes(&key.encode()[..32])
+                        .expect("libp2p key must be valid");
+                Ok(CombinedKey::from(ed_keypair))
+            }
+            _ => Err("ENR: Unsupported libp2p key type"),
+        }
+    }
+}
+
+// helper function to convert a peer_id to a node_id. This is only possible for secp256k1/ed25519 libp2p
+// peer_ids
+pub fn peer_id_to_node_id(peer_id: &PeerId) -> Result<discv5::enr::NodeId, String> {
+    // A libp2p peer id byte representation should be 2 length bytes + 4 protobuf bytes + compressed pk bytes
+    // if generated from a PublicKey with Identity multihash.
+    let pk_bytes = &peer_id.as_bytes()[2..];
+
+    match PublicKey::from_protobuf_encoding(pk_bytes).map_err(|e| {
+        format!(
+            " Cannot parse libp2p public key public key from peer id: {}",
+            e
+        )
+    })? {
+        PublicKey::Secp256k1(pk) => {
+            let uncompressed_key_bytes = &pk.encode_uncompressed()[1..];
+            let mut output = [0_u8; 32];
+            let mut hasher = Keccak::v256();
+            hasher.update(&uncompressed_key_bytes);
+            hasher.finalize(&mut output);
+            return Ok(discv5::enr::NodeId::parse(&output).expect("Must be correct length"));
+        }
+        PublicKey::Ed25519(pk) => {
+            let uncompressed_key_bytes = pk.encode();
+            let mut output = [0_u8; 32];
+            let mut hasher = Keccak::v256();
+            hasher.update(&uncompressed_key_bytes);
+            hasher.finalize(&mut output);
+            return Ok(discv5::enr::NodeId::parse(&output).expect("Must be correct length"));
+        }
+        _ => return Err("Unsupported public key".into()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_secp256k1_peer_id_conversion() {
+        let sk_hex = "df94a73d528434ce2309abb19c16aedb535322797dbd59c157b1e04095900f48";
+        let sk_bytes = hex::decode(sk_hex).unwrap();
+        let secret_key = discv5::enr::secp256k1::SecretKey::parse_slice(&sk_bytes).unwrap();
+
+        let libp2p_sk = libp2p::identity::secp256k1::SecretKey::from_bytes(sk_bytes).unwrap();
+        let secp256k1_kp: libp2p::identity::secp256k1::Keypair = libp2p_sk.into();
+        let libp2p_kp = Keypair::Secp256k1(secp256k1_kp);
+        let peer_id = libp2p_kp.public().into_peer_id();
+
+        let enr = discv5::enr::EnrBuilder::new("v4")
+            .build(&secret_key)
+            .unwrap();
+        let node_id = peer_id_to_node_id(&peer_id).unwrap();
+
+        assert_eq!(enr.node_id(), node_id);
+    }
+
+    #[test]
+    fn test_ed25519_peer_conversion() {
+        let sk_hex = "4dea8a5072119927e9d243a7d953f2f4bc95b70f110978e2f9bc7a9000e4b261";
+        let sk_bytes = hex::decode(sk_hex).unwrap();
+        let secret = discv5::enr::ed25519_dalek::SecretKey::from_bytes(&sk_bytes).unwrap();
+        let public = discv5::enr::ed25519_dalek::PublicKey::from(&secret);
+        let keypair = discv5::enr::ed25519_dalek::Keypair { public, secret };
+
+        let libp2p_sk = libp2p::identity::ed25519::SecretKey::from_bytes(sk_bytes).unwrap();
+        let ed25519_kp: libp2p::identity::ed25519::Keypair = libp2p_sk.into();
+        let libp2p_kp = Keypair::Ed25519(ed25519_kp);
+        let peer_id = libp2p_kp.public().into_peer_id();
+
+        let enr = discv5::enr::EnrBuilder::new("v4").build(&keypair).unwrap();
+        let node_id = peer_id_to_node_id(&peer_id).unwrap();
+
+        assert_eq!(enr.node_id(), node_id);
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/discovery/mod.rs

@@ -0,0 +1,632 @@
+///! This manages the discovery and management of peers.
+pub(crate) mod enr;
+pub mod enr_ext;
+
+// Allow external use of the lighthouse ENR builder
+pub use enr::{build_enr, CombinedKey, Eth2Enr};
+pub use enr_ext::{CombinedKeyExt, EnrExt};
+pub use libp2p::core::identity::Keypair;
+
+use crate::metrics;
+use crate::{error, Enr, NetworkConfig, NetworkGlobals};
+use discv5::{enr::NodeId, Discv5, Discv5Event};
+use enr::{BITFIELD_ENR_KEY, ETH2_ENR_KEY};
+use futures::prelude::*;
+use libp2p::core::PeerId;
+// use libp2p::multiaddr::Protocol;
+use futures::stream::FuturesUnordered;
+use lru::LruCache;
+use slog::{crit, debug, info, trace, warn};
+use ssz::{Decode, Encode};
+use ssz_types::BitVector;
+use std::{
+    collections::VecDeque,
+    net::SocketAddr,
+    path::Path,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+    time::Instant,
+};
+use tokio::sync::mpsc;
+use types::{EnrForkId, EthSpec, SubnetId};
+
+mod subnet_predicate;
+use subnet_predicate::subnet_predicate;
+
+/// Local ENR storage filename.
+pub const ENR_FILENAME: &str = "enr.dat";
+/// Target number of peers we'd like to have connected to a given long-lived subnet.
+const TARGET_SUBNET_PEERS: usize = 3;
+/// Number of times to attempt a discovery request
+const MAX_DISCOVERY_RETRY: usize = 3;
+/// The maximum number of concurrent discovery queries.
+const MAX_CONCURRENT_QUERIES: usize = 1;
+/// The number of closest peers to search for when doing a regular peer search.
+///
+/// We could reduce this constant to speed up queries however at the cost of security. It will
+/// make it easier to peers to eclipse this node. Kademlia suggests a value of 16.
+const FIND_NODE_QUERY_CLOSEST_PEERS: usize = 16;
+
+/// The events emitted by polling discovery.
+pub enum DiscoveryEvent {
+    /// A query has completed. The first parameter is the `min_ttl` of the peers if it is specified
+    /// and the second parameter are the discovered peers.
+    QueryResult(Option<Instant>, Box<Vec<Enr>>),
+    /// This indicates that our local UDP socketaddr has been updated and we should inform libp2p.
+    SocketUpdated(SocketAddr),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum QueryType {
+    /// We are searching for subnet peers.
+    Subnet {
+        subnet_id: SubnetId,
+        min_ttl: Option<Instant>,
+        retries: usize,
+    },
+    /// We are searching for more peers without ENR or time constraints.
+    FindPeers,
+}
+
+impl QueryType {
+    /// Returns true if this query has expired.
+    pub fn expired(&self) -> bool {
+        match self {
+            Self::FindPeers => false,
+            Self::Subnet { min_ttl, .. } => {
+                if let Some(ttl) = min_ttl {
+                    ttl > &Instant::now()
+                } else {
+                    true
+                }
+            }
+        }
+    }
+
+    /// Returns the min_ttl of the query if one exists
+    ///
+    /// This is required for returning to the peer manager. The peer manager will update newly
+    /// connected peers with this `min_ttl`
+    pub fn min_ttl(&self) -> Option<Instant> {
+        match self {
+            Self::FindPeers => None,
+            Self::Subnet { min_ttl, .. } => min_ttl.clone(),
+        }
+    }
+}
+
+/// The result of a query.
+struct QueryResult(QueryType, Result<Vec<Enr>, discv5::QueryError>);
+
+// Awaiting the event stream future
+enum EventStream {
+    /// Awaiting an event stream to be generated. This is required due to the poll nature of
+    /// `Discovery`
+    Awaiting(
+        Pin<
+            Box<
+                dyn Future<Output = Result<mpsc::Receiver<Discv5Event>, discv5::Discv5Error>>
+                    + Send,
+            >,
+        >,
+    ),
+    /// The future has completed.
+    Present(mpsc::Receiver<Discv5Event>),
+    // The future has failed, there are no events from discv5.
+    Failed,
+}
+
+pub struct Discovery<TSpec: EthSpec> {
+    /// A collection of seen live ENRs for quick lookup and to map peer-id's to ENRs.
+    cached_enrs: LruCache<PeerId, Enr>,
+
+    /// The directory where the ENR is stored.
+    enr_dir: String,
+
+    /// The handle for the underlying discv5 Server.
+    ///
+    /// This is behind a Reference counter to allow for futures to be spawned and polled with a
+    /// static lifetime.
+    discv5: Discv5,
+
+    /// A collection of network constants that can be read from other threads.
+    network_globals: Arc<NetworkGlobals<TSpec>>,
+
+    /// Indicates if we are actively searching for peers. We only allow a single FindPeers query at
+    /// a time, regardless of the query concurrency.
+    find_peer_active: bool,
+
+    /// A queue of discovery queries to be processed.
+    queued_queries: VecDeque<QueryType>,
+
+    /// Active discovery queries.
+    active_queries: FuturesUnordered<std::pin::Pin<Box<dyn Future<Output = QueryResult> + Send>>>,
+
+    /// The discv5 event stream.
+    event_stream: EventStream,
+
+    /// Logger for the discovery behaviour.
+    log: slog::Logger,
+}
+
+impl<TSpec: EthSpec> Discovery<TSpec> {
+    /// NOTE: Creating discovery requires running within a tokio execution environment.
+    pub fn new(
+        local_key: &Keypair,
+        config: &NetworkConfig,
+        network_globals: Arc<NetworkGlobals<TSpec>>,
+        log: &slog::Logger,
+    ) -> error::Result<Self> {
+        let log = log.clone();
+
+        let enr_dir = match config.network_dir.to_str() {
+            Some(path) => String::from(path),
+            None => String::from(""),
+        };
+
+        let local_enr = network_globals.local_enr.read().clone();
+
+        info!(log, "ENR Initialised"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> format!("{}",local_enr.node_id()), "ip" => format!("{:?}", local_enr.ip()), "udp"=> format!("{:?}", local_enr.udp()), "tcp" => format!("{:?}", local_enr.tcp()));
+
+        let listen_socket = SocketAddr::new(config.listen_address, config.discovery_port);
+
+        // convert the keypair into an ENR key
+        let enr_key: CombinedKey = CombinedKey::from_libp2p(&local_key)?;
+
+        let mut discv5 = Discv5::new(local_enr, enr_key, config.discv5_config.clone())
+            .map_err(|e| format!("Discv5 service failed. Error: {:?}", e))?;
+
+        // Add bootnodes to routing table
+        for bootnode_enr in config.boot_nodes.clone() {
+            debug!(
+                log,
+                "Adding node to routing table";
+                "node_id" => format!("{}", bootnode_enr.node_id()),
+                "peer_id" => format!("{}", bootnode_enr.peer_id()),
+                "ip" => format!("{:?}", bootnode_enr.ip()),
+                "udp" => format!("{:?}", bootnode_enr.udp()),
+                "tcp" => format!("{:?}", bootnode_enr.tcp())
+            );
+            let _ = discv5.add_enr(bootnode_enr).map_err(|e| {
+                warn!(
+                    log,
+                    "Could not add peer to the local routing table";
+                    "error" => format!("{}", e)
+                )
+            });
+        }
+
+        // start the discv5 service.
+        discv5.start(listen_socket);
+        debug!(log, "Discovery service started");
+
+        // obtain the event stream
+        let event_stream = EventStream::Awaiting(Box::pin(discv5.event_stream()));
+
+        Ok(Self {
+            cached_enrs: LruCache::new(50),
+            network_globals,
+            find_peer_active: false,
+            queued_queries: VecDeque::with_capacity(10),
+            active_queries: FuturesUnordered::new(),
+            discv5,
+            event_stream,
+            log,
+            enr_dir,
+        })
+    }
+
+    /// Return the nodes local ENR.
+    pub fn local_enr(&self) -> Enr {
+        self.discv5.local_enr()
+    }
+
+    /// This adds a new `FindPeers` query to the queue if one doesn't already exist.
+    pub fn discover_peers(&mut self) {
+        // If there is not already a find peer's query queued, add one
+        let query = QueryType::FindPeers;
+        if !self.queued_queries.contains(&query) {
+            trace!(self.log, "Queuing a peer discovery request");
+            self.queued_queries.push_back(query);
+            // update the metrics
+            metrics::set_gauge(&metrics::DISCOVERY_QUEUE, self.queued_queries.len() as i64);
+        }
+    }
+
+    /// Processes a request to search for more peers on a subnet.
+    pub fn discover_subnet_peers(&mut self, subnet_id: SubnetId, min_ttl: Option<Instant>) {
+        self.add_subnet_query(subnet_id, min_ttl, 0);
+    }
+
+    /// Adds a subnet query if one doesn't exist. If a subnet query already exists, this
+    /// updates the min_ttl field.
+    fn add_subnet_query(&mut self, subnet_id: SubnetId, min_ttl: Option<Instant>, retries: usize) {
+        // remove the entry and complete the query if greater than the maximum search count
+        if retries >= MAX_DISCOVERY_RETRY {
+            debug!(
+                self.log,
+                "Subnet peer discovery did not find sufficient peers. Reached max retry limit"
+            );
+            return;
+        }
+
+        // Search through any queued requests and update the timeout if a query for this subnet
+        // already exists
+        let mut found = false;
+        for query in self.queued_queries.iter_mut() {
+            if let QueryType::Subnet {
+                subnet_id: ref mut q_subnet_id,
+                min_ttl: ref mut q_min_ttl,
+                retries: ref mut q_retries,
+            } = query
+            {
+                if *q_subnet_id == subnet_id {
+                    if *q_min_ttl < min_ttl {
+                        *q_min_ttl = min_ttl;
+                    }
+                    // update the number of retries
+                    *q_retries = retries;
+                    // mimic an `Iter::Find()` and short-circuit the loop
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if !found {
+            // Set up the query and add it to the queue
+            let query = QueryType::Subnet {
+                subnet_id,
+                min_ttl,
+                retries,
+            };
+            // update the metrics and insert into the queue.
+            metrics::set_gauge(&metrics::DISCOVERY_QUEUE, self.queued_queries.len() as i64);
+            self.queued_queries.push_back(query);
+        }
+    }
+
+    /// Add an ENR to the routing table of the discovery mechanism.
+    pub fn add_enr(&mut self, enr: Enr) {
+        // add the enr to seen caches
+        self.cached_enrs.put(enr.peer_id(), enr.clone());
+
+        if let Err(e) = self.discv5.add_enr(enr) {
+            warn!(
+                self.log,
+                "Could not add peer to the local routing table";
+                "error" => format!("{}", e)
+            )
+        }
+    }
+
+    /// Returns an iterator over all enr entries in the DHT.
+    pub fn table_entries_enr(&mut self) -> Vec<Enr> {
+        self.discv5.table_entries_enr()
+    }
+
+    /// Returns the ENR of a known peer if it exists.
+    pub fn enr_of_peer(&mut self, peer_id: &PeerId) -> Option<Enr> {
+        // first search the local cache
+        if let Some(enr) = self.cached_enrs.get(peer_id) {
+            return Some(enr.clone());
+        }
+        // not in the local cache, look in the routing table
+        if let Ok(node_id) = enr_ext::peer_id_to_node_id(peer_id) {
+            self.discv5.find_enr(&node_id)
+        } else {
+            None
+        }
+    }
+
+    /// Adds/Removes a subnet from the ENR Bitfield
+    pub fn update_enr_bitfield(&mut self, subnet_id: SubnetId, value: bool) -> Result<(), String> {
+        let id = *subnet_id as usize;
+
+        let local_enr = self.discv5.local_enr();
+        let mut current_bitfield = local_enr.bitfield::<TSpec>()?;
+
+        if id >= current_bitfield.len() {
+            return Err(format!(
+                "Subnet id: {} is outside the ENR bitfield length: {}",
+                id,
+                current_bitfield.len()
+            ));
+        }
+
+        if current_bitfield
+            .get(id)
+            .map_err(|_| String::from("Subnet ID out of bounds"))?
+            == value
+        {
+            return Err(format!(
+                "Subnet id: {} already in the local ENR already has value: {}",
+                id, value
+            ));
+        }
+
+        // set the subnet bitfield in the ENR
+        current_bitfield
+            .set(id, value)
+            .map_err(|_| String::from("Subnet ID out of bounds, could not set subnet ID"))?;
+
+        // insert the bitfield into the ENR record
+        let _ = self
+            .discv5
+            .enr_insert(BITFIELD_ENR_KEY, current_bitfield.as_ssz_bytes());
+
+        // replace the global version
+        *self.network_globals.local_enr.write() = self.discv5.local_enr().clone();
+        Ok(())
+    }
+
+    /// Updates the `eth2` field of our local ENR.
+    pub fn update_eth2_enr(&mut self, enr_fork_id: EnrForkId) {
+        // to avoid having a reference to the spec constant, for the logging we assume
+        // FAR_FUTURE_EPOCH is u64::max_value()
+        let next_fork_epoch_log = if enr_fork_id.next_fork_epoch == u64::max_value() {
+            String::from("No other fork")
+        } else {
+            format!("{:?}", enr_fork_id.next_fork_epoch)
+        };
+
+        info!(self.log, "Updating the ENR fork version";
+            "fork_digest" => format!("{:?}", enr_fork_id.fork_digest),
+            "next_fork_version" => format!("{:?}", enr_fork_id.next_fork_version),
+            "next_fork_epoch" => next_fork_epoch_log,
+        );
+
+        let _ = self
+            .discv5
+            .enr_insert(ETH2_ENR_KEY.into(), enr_fork_id.as_ssz_bytes())
+            .map_err(|e| {
+                warn!(
+                    self.log,
+                    "Could not update eth2 ENR field";
+                    "error" => format!("{:?}", e)
+                )
+            });
+
+        // replace the global version with discovery version
+        *self.network_globals.local_enr.write() = self.discv5.local_enr().clone();
+    }
+
+    /* Internal Functions */
+
+    /// Consume the discovery queue and initiate queries when applicable.
+    ///
+    /// This also sanitizes the queue removing out-dated queries.
+    fn process_queue(&mut self) {
+        // Sanitize the queue, removing any out-dated subnet queries
+        self.queued_queries.retain(|query| !query.expired());
+
+        // Check that we are within our query concurrency limit
+        while !self.at_capacity() && !self.queued_queries.is_empty() {
+            // consume and process the query queue
+            match self.queued_queries.pop_front() {
+                Some(QueryType::FindPeers) => {
+                    // Only permit one FindPeers query at a time
+                    if self.find_peer_active {
+                        self.queued_queries.push_back(QueryType::FindPeers);
+                        continue;
+                    }
+                    // This is a regular request to find additional peers
+                    debug!(self.log, "Searching for new peers");
+                    self.find_peer_active = true;
+                    self.start_query(QueryType::FindPeers, FIND_NODE_QUERY_CLOSEST_PEERS);
+                }
+                Some(QueryType::Subnet {
+                    subnet_id,
+                    min_ttl,
+                    retries,
+                }) => {
+                    // This query is for searching for peers of a particular subnet
+                    self.start_subnet_query(subnet_id, min_ttl, retries);
+                }
+                None => {} // Queue is empty
+            }
+        }
+    }
+
+    // Returns a boolean indicating if we are currently processing the maximum number of
+    // concurrent queries or not.
+    fn at_capacity(&self) -> bool {
+        if self.active_queries.len() >= MAX_CONCURRENT_QUERIES {
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Runs a discovery request for a given subnet_id if one already exists.
+    fn start_subnet_query(
+        &mut self,
+        subnet_id: SubnetId,
+        min_ttl: Option<Instant>,
+        retries: usize,
+    ) {
+        // Determine if we have sufficient peers, which may make this discovery unnecessary.
+        let peers_on_subnet = self
+            .network_globals
+            .peers
+            .read()
+            .peers_on_subnet(subnet_id)
+            .count();
+
+        if peers_on_subnet > TARGET_SUBNET_PEERS {
+            trace!(self.log, "Discovery ignored";
+                "reason" => "Already connected to desired peers",
+                "connected_peers_on_subnet" => peers_on_subnet,
+                "target_subnet_peers" => TARGET_SUBNET_PEERS,
+            );
+            return;
+        }
+
+        let target_peers = TARGET_SUBNET_PEERS - peers_on_subnet;
+        debug!(self.log, "Searching for peers for subnet";
+            "subnet_id" => *subnet_id,
+            "connected_peers_on_subnet" => peers_on_subnet,
+            "target_subnet_peers" => TARGET_SUBNET_PEERS,
+            "peers_to_find" => target_peers,
+            "attempt" => retries,
+        );
+
+        // start the query, and update the queries map if necessary
+        let query = QueryType::Subnet {
+            subnet_id,
+            min_ttl,
+            retries,
+        };
+        self.start_query(query, target_peers);
+    }
+
+    /// Search for a specified number of new peers using the underlying discovery mechanism.
+    ///
+    /// This can optionally search for peers for a given predicate. Regardless of the predicate
+    /// given, this will only search for peers on the same enr_fork_id as specified in the local
+    /// ENR.
+    fn start_query(&mut self, query: QueryType, target_peers: usize) {
+        // Generate a random target node id.
+        let random_node = NodeId::random();
+
+        let enr_fork_id = match self.local_enr().eth2() {
+            Ok(v) => v,
+            Err(e) => {
+                crit!(self.log, "Local ENR has no fork id"; "error" => e);
+                return;
+            }
+        };
+        // predicate for finding nodes with a matching fork
+        let eth2_fork_predicate = move |enr: &Enr| enr.eth2() == Ok(enr_fork_id.clone());
+
+        // General predicate
+        let predicate: Box<dyn Fn(&Enr) -> bool + Send> = match &query {
+            QueryType::FindPeers => Box::new(eth2_fork_predicate),
+            QueryType::Subnet { subnet_id, .. } => {
+                // build the subnet predicate as a combination of the eth2_fork_predicate and the
+                // subnet predicate
+                let subnet_predicate = subnet_predicate::<TSpec>(subnet_id.clone(), &self.log);
+                Box::new(move |enr: &Enr| eth2_fork_predicate(enr) && subnet_predicate(enr))
+            }
+        };
+
+        // Build the future
+        let query_future = self
+            .discv5
+            .find_node_predicate(random_node, predicate, target_peers)
+            .map(|v| QueryResult(query, v));
+
+        // Add the future to active queries, to be executed.
+        self.active_queries.push(Box::pin(query_future));
+    }
+
+    /// Drives the queries returning any results from completed queries.
+    fn poll_queries(&mut self, cx: &mut Context) -> Option<(Option<Instant>, Vec<Enr>)> {
+        while let Poll::Ready(Some(query_future)) = self.active_queries.poll_next_unpin(cx) {
+            match query_future.0 {
+                QueryType::FindPeers => {
+                    self.find_peer_active = false;
+                    match query_future.1 {
+                        Ok(r) if r.is_empty() => {
+                            debug!(self.log, "Discovery query yielded no results.");
+                        }
+                        Ok(r) => {
+                            debug!(self.log, "Discovery query completed"; "peers_found" => r.len());
+                            return Some((None, r));
+                        }
+                        Err(e) => {
+                            warn!(self.log, "Discovery query failed"; "error" => e.to_string());
+                        }
+                    }
+                }
+                QueryType::Subnet {
+                    subnet_id,
+                    min_ttl,
+                    retries,
+                } => {
+                    match query_future.1 {
+                        Ok(r) if r.is_empty() => {
+                            debug!(self.log, "Subnet discovery query yielded no results."; "subnet_id" => *subnet_id, "retries" => retries);
+                        }
+                        Ok(r) => {
+                            debug!(self.log, "Peer subnet discovery request completed"; "peers_found" => r.len(), "subnet_id" => *subnet_id);
+                            // A subnet query has completed. Add back to the queue, incrementing retries.
+                            self.add_subnet_query(subnet_id, min_ttl, retries + 1);
+                            // Report the results back to the peer manager.
+                            return Some((query_future.0.min_ttl(), r));
+                        }
+                        Err(e) => {
+                            warn!(self.log,"Subnet Discovery query failed"; "subnet_id" => *subnet_id, "error" => e.to_string());
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    // Main execution loop to be driven by the peer manager.
+    pub fn poll(&mut self, cx: &mut Context) -> Poll<DiscoveryEvent> {
+        // Process the query queue
+        self.process_queue();
+
+        // Drive the queries and return any results from completed queries
+        if let Some((min_ttl, result)) = self.poll_queries(cx) {
+            // cache the found ENR's
+            for enr in result.iter().cloned() {
+                self.cached_enrs.put(enr.peer_id(), enr);
+            }
+            // return the result to the peer manager
+            return Poll::Ready(DiscoveryEvent::QueryResult(min_ttl, Box::new(result)));
+        }
+
+        // Process the server event stream
+        match self.event_stream {
+            EventStream::Awaiting(ref mut fut) => {
+                // Still awaiting the event stream, poll it
+                if let Poll::Ready(event_stream) = fut.poll_unpin(cx) {
+                    match event_stream {
+                        Ok(stream) => self.event_stream = EventStream::Present(stream),
+                        Err(e) => {
+                            slog::crit!(self.log, "Discv5 event stream failed"; "error" => e.to_string());
+                            self.event_stream = EventStream::Failed;
+                        }
+                    }
+                }
+            }
+            EventStream::Failed => {} // ignore checking the stream
+            EventStream::Present(ref mut stream) => {
+                while let Ok(event) = stream.try_recv() {
+                    match event {
+                        // We filter out unwanted discv5 events here and only propagate useful results to
+                        // the peer manager.
+                        Discv5Event::Discovered(_enr) => {
+                            // Peers that get discovered during a query but are not contactable or
+                            // don't match a predicate can end up here. For debugging purposes we
+                            // log these to see if we are unnecessarily dropping discovered peers
+                            /*
+                            if enr.eth2() == self.local_enr().eth2() {
+                                trace!(self.log, "Peer found in process of query"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
+                            } else {
+                                // this is temporary warning for debugging the DHT
+                                warn!(self.log, "Found peer during discovery not on correct fork"; "peer_id" => format!("{}", enr.peer_id()), "tcp_socket" => enr.tcp_socket());
+                            }
+                            */
+                        }
+                        Discv5Event::SocketUpdated(socket) => {
+                            info!(self.log, "Address updated"; "ip" => format!("{}",socket.ip()), "udp_port" => format!("{}", socket.port()));
+                            metrics::inc_counter(&metrics::ADDRESS_UPDATE_COUNT);
+                            // Discv5 will have updated our local ENR. We save the updated version
+                            // to disk.
+                            let enr = self.discv5.local_enr();
+                            enr::save_enr_to_disk(Path::new(&self.enr_dir), &enr, &self.log);
+                            return Poll::Ready(DiscoveryEvent::SocketUpdated(socket));
+                        }
+                        _ => {} // Ignore all other discv5 server events
+                    }
+                }
+            }
+        }
+        Poll::Pending
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/discovery/subnet_predicate.rs

@@ -0,0 +1,33 @@
+///! The subnet predicate used for searching for a particular subnet.
+use super::*;
+
+/// Returns the predicate for a given subnet.
+pub fn subnet_predicate<TSpec>(
+    subnet_id: SubnetId,
+    log: &slog::Logger,
+) -> impl Fn(&Enr) -> bool + Send
+where
+    TSpec: EthSpec,
+{
+    let log_clone = log.clone();
+
+    move |enr: &Enr| {
+        if let Some(bitfield_bytes) = enr.get(BITFIELD_ENR_KEY) {
+            let bitfield = match BitVector::<TSpec::SubnetBitfieldLength>::from_ssz_bytes(
+                bitfield_bytes,
+            ) {
+                Ok(v) => v,
+                Err(e) => {
+                    warn!(log_clone, "Could not decode ENR bitfield for peer"; "peer_id" => format!("{}", enr.peer_id()), "error" => format!("{:?}", e));
+                    return false;
+                }
+            };
+
+            return bitfield.get(*subnet_id as usize).unwrap_or_else(|_| {
+                                   debug!(log_clone, "Peer found but not on desired subnet"; "peer_id" => format!("{}", enr.peer_id()));
+                false
+            });
+        }
+        false
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/mod.rs

@@ -0,0 +1,677 @@
+//! Implementation of a Lighthouse's peer management system.
+
+pub use self::peerdb::*;
+use crate::rpc::{MetaData, Protocol, RPCError, RPCResponseErrorCode};
+use crate::{error, metrics};
+use crate::{Enr, EnrExt, NetworkConfig, NetworkGlobals, PeerId};
+use futures::prelude::*;
+use futures::Stream;
+use hashset_delay::HashSetDelay;
+use libp2p::core::multiaddr::Protocol as MProtocol;
+use libp2p::identify::IdentifyInfo;
+use slog::{crit, debug, error};
+use smallvec::SmallVec;
+use std::{
+    net::SocketAddr,
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+    time::{Duration, Instant},
+};
+use types::{EthSpec, SubnetId};
+
+pub use libp2p::core::{identity::Keypair, Multiaddr};
+
+pub mod client;
+pub mod discovery;
+mod peer_info;
+mod peer_sync_status;
+mod peerdb;
+
+use discovery::{Discovery, DiscoveryEvent};
+
+pub use peer_info::{PeerConnectionStatus::*, PeerInfo};
+pub use peer_sync_status::{PeerSyncStatus, SyncInfo};
+/// The minimum reputation before a peer is disconnected.
+// Most likely this needs tweaking.
+const _MIN_REP_BEFORE_BAN: Rep = 10;
+/// The time in seconds between re-status's peers.
+const STATUS_INTERVAL: u64 = 300;
+/// The time in seconds between PING events. We do not send a ping if the other peer as PING'd us within
+/// this time frame (Seconds)
+const PING_INTERVAL: u64 = 30;
+
+/// The heartbeat performs regular updates such as updating reputations and performing discovery
+/// requests. This defines the interval in seconds.  
+const HEARTBEAT_INTERVAL: u64 = 30;
+
+/// The main struct that handles peer's reputation and connection status.
+pub struct PeerManager<TSpec: EthSpec> {
+    /// Storage of network globals to access the `PeerDB`.
+    network_globals: Arc<NetworkGlobals<TSpec>>,
+    /// A queue of events that the `PeerManager` is waiting to produce.
+    events: SmallVec<[PeerManagerEvent; 16]>,
+    /// A collection of peers awaiting to be Ping'd.
+    ping_peers: HashSetDelay<PeerId>,
+    /// A collection of peers awaiting to be Status'd.
+    status_peers: HashSetDelay<PeerId>,
+    /// The target number of peers we would like to connect to.
+    target_peers: usize,
+    /// The discovery service.
+    discovery: Discovery<TSpec>,
+    /// The heartbeat interval to perform routine maintenance.
+    heartbeat: tokio::time::Interval,
+    /// The logger associated with the `PeerManager`.
+    log: slog::Logger,
+}
+
+/// A collection of actions a peer can perform which will adjust its reputation.
+/// Each variant has an associated reputation change.
+// To easily assess the behaviour of reputation changes the number of variants should stay low, and
+// somewhat generic.
+pub enum PeerAction {
+    /// We should not communicate more with this peer.
+    /// This action will cause the peer to get banned.
+    Fatal,
+    /// An error occurred with this peer but it is not necessarily malicious.
+    /// We have high tolerance for this actions: several occurrences are needed for a peer to get
+    /// kicked.
+    /// NOTE: ~15 occurrences will get the peer banned
+    HighToleranceError,
+    /// An error occurred with this peer but it is not necessarily malicious.
+    /// We have high tolerance for this actions: several occurrences are needed for a peer to get
+    /// kicked.
+    /// NOTE: ~10 occurrences will get the peer banned
+    MidToleranceError,
+    /// This peer's action is not malicious but will not be tolerated. A few occurrences will cause
+    /// the peer to get kicked.
+    /// NOTE: ~5 occurrences will get the peer banned
+    LowToleranceError,
+    /// Received an expected message.
+    _ValidMessage,
+}
+
+impl PeerAction {
+    fn rep_change(&self) -> RepChange {
+        match self {
+            PeerAction::Fatal => RepChange::worst(),
+            PeerAction::LowToleranceError => RepChange::bad(60),
+            PeerAction::MidToleranceError => RepChange::bad(25),
+            PeerAction::HighToleranceError => RepChange::bad(15),
+            PeerAction::_ValidMessage => RepChange::good(20),
+        }
+    }
+}
+
+/// The events that the `PeerManager` outputs (requests).
+pub enum PeerManagerEvent {
+    /// Dial a PeerId.
+    Dial(PeerId),
+    /// Inform libp2p that our external socket addr has been updated.
+    SocketUpdated(Multiaddr),
+    /// Sends a STATUS to a peer.
+    Status(PeerId),
+    /// Sends a PING to a peer.
+    Ping(PeerId),
+    /// Request METADATA from a peer.
+    MetaData(PeerId),
+    /// The peer should be disconnected.
+    DisconnectPeer(PeerId),
+}
+
+impl<TSpec: EthSpec> PeerManager<TSpec> {
+    // NOTE: Must be run inside a tokio executor.
+    pub fn new(
+        local_key: &Keypair,
+        config: &NetworkConfig,
+        network_globals: Arc<NetworkGlobals<TSpec>>,
+        log: &slog::Logger,
+    ) -> error::Result<Self> {
+        // start the discovery service
+        let mut discovery = Discovery::new(local_key, config, network_globals.clone(), log)?;
+
+        // start searching for peers
+        discovery.discover_peers();
+
+        let heartbeat = tokio::time::interval(tokio::time::Duration::from_secs(HEARTBEAT_INTERVAL));
+
+        Ok(PeerManager {
+            network_globals,
+            events: SmallVec::new(),
+            ping_peers: HashSetDelay::new(Duration::from_secs(PING_INTERVAL)),
+            status_peers: HashSetDelay::new(Duration::from_secs(STATUS_INTERVAL)),
+            target_peers: config.max_peers, //TODO: Add support for target peers and max peers
+            discovery,
+            heartbeat,
+            log: log.clone(),
+        })
+    }
+
+    /* Public accessible functions */
+
+    /* Discovery Requests */
+
+    /// Provides a reference to the underlying discovery service.
+    pub fn discovery(&self) -> &Discovery<TSpec> {
+        &self.discovery
+    }
+
+    /// Provides a mutable reference to the underlying discovery service.
+    pub fn discovery_mut(&mut self) -> &mut Discovery<TSpec> {
+        &mut self.discovery
+    }
+
+    /// A request to find peers on a given subnet.
+    pub fn discover_subnet_peers(&mut self, subnet_id: SubnetId, min_ttl: Option<Instant>) {
+        // Extend the time to maintain peers if required.
+        if let Some(min_ttl) = min_ttl {
+            self.network_globals
+                .peers
+                .write()
+                .extend_peers_on_subnet(subnet_id, min_ttl);
+        }
+
+        // request the subnet query from discovery
+        self.discovery.discover_subnet_peers(subnet_id, min_ttl);
+    }
+
+    /// A STATUS message has been received from a peer. This resets the status timer.
+    pub fn peer_statusd(&mut self, peer_id: &PeerId) {
+        self.status_peers.insert(peer_id.clone());
+    }
+
+    /// Updates the state of the peer as disconnected.
+    pub fn notify_disconnect(&mut self, peer_id: &PeerId) {
+        //self.update_reputations();
+        self.network_globals.peers.write().disconnect(peer_id);
+
+        // remove the ping and status timer for the peer
+        self.ping_peers.remove(peer_id);
+        self.status_peers.remove(peer_id);
+        metrics::inc_counter(&metrics::PEER_DISCONNECT_EVENT_COUNT);
+        metrics::set_gauge(
+            &metrics::PEERS_CONNECTED,
+            self.network_globals.connected_peers() as i64,
+        );
+    }
+
+    /// Sets a peer as connected as long as their reputation allows it
+    /// Informs if the peer was accepted
+    pub fn connect_ingoing(&mut self, peer_id: &PeerId) -> bool {
+        self.connect_peer(peer_id, ConnectingType::IngoingConnected)
+    }
+
+    /// Sets a peer as connected as long as their reputation allows it
+    /// Informs if the peer was accepted
+    pub fn connect_outgoing(&mut self, peer_id: &PeerId) -> bool {
+        self.connect_peer(peer_id, ConnectingType::OutgoingConnected)
+    }
+
+    /// Updates the database informing that a peer is being dialed.
+    pub fn dialing_peer(&mut self, peer_id: &PeerId) -> bool {
+        self.connect_peer(peer_id, ConnectingType::Dialing)
+    }
+
+    /// Updates the database informing that a peer is being disconnected.
+    pub fn _disconnecting_peer(&mut self, _peer_id: &PeerId) -> bool {
+        // TODO: implement
+        true
+    }
+
+    /// Reports a peer for some action.
+    ///
+    /// If the peer doesn't exist, log a warning and insert defaults.
+    pub fn report_peer(&mut self, peer_id: &PeerId, action: PeerAction) {
+        //TODO: Check these. There are double disconnects for example
+        // self.update_reputations();
+        self.network_globals
+            .peers
+            .write()
+            .add_reputation(peer_id, action.rep_change());
+        // self.update_reputations();
+    }
+
+    /// Updates `PeerInfo` with `identify` information.
+    pub fn identify(&mut self, peer_id: &PeerId, info: &IdentifyInfo) {
+        if let Some(peer_info) = self.network_globals.peers.write().peer_info_mut(peer_id) {
+            peer_info.client = client::Client::from_identify_info(info);
+            peer_info.listening_addresses = info.listen_addrs.clone();
+        } else {
+            crit!(self.log, "Received an Identify response from an unknown peer"; "peer_id" => peer_id.to_string());
+        }
+    }
+
+    pub fn handle_rpc_error(&mut self, peer_id: &PeerId, protocol: Protocol, err: &RPCError) {
+        let client = self.network_globals.client(peer_id);
+        debug!(self.log, "RPCError"; "protocol" => protocol.to_string(), "err" => err.to_string(), "client" => client.to_string());
+
+        // Map this error to a `PeerAction` (if any)
+        let peer_action = match err {
+            RPCError::IncompleteStream => {
+                // They closed early, this could mean poor connection
+                PeerAction::MidToleranceError
+            }
+            RPCError::InternalError(_) | RPCError::HandlerRejected => {
+                // Our fault. Do nothing
+                return;
+            }
+            RPCError::InvalidData => {
+                // Peer is not complying with the protocol. This is considered a malicious action
+                PeerAction::Fatal
+            }
+            RPCError::IoError(_e) => {
+                // this could their fault or ours, so we tolerate this
+                PeerAction::HighToleranceError
+            }
+            RPCError::ErrorResponse(code, _) => match code {
+                RPCResponseErrorCode::Unknown => PeerAction::HighToleranceError,
+                RPCResponseErrorCode::ServerError => PeerAction::MidToleranceError,
+                RPCResponseErrorCode::InvalidRequest => PeerAction::LowToleranceError,
+            },
+            RPCError::SSZDecodeError(_) => PeerAction::Fatal,
+            RPCError::UnsupportedProtocol => {
+                // Not supporting a protocol shouldn't be considered a malicious action, but
+                // it is an action that in some cases will make the peer unfit to continue
+                // communicating.
+                // TODO: To avoid punishing a peer repeatedly for not supporting a protocol, this
+                // information could be stored and used to prevent sending requests for the given
+                // protocol to this peer. Similarly, to avoid blacklisting a peer for a protocol
+                // forever, if stored this information should expire.
+                match protocol {
+                    Protocol::Ping => PeerAction::Fatal,
+                    Protocol::BlocksByRange => return,
+                    Protocol::BlocksByRoot => return,
+                    Protocol::Goodbye => return,
+                    Protocol::MetaData => PeerAction::LowToleranceError,
+                    Protocol::Status => PeerAction::LowToleranceError,
+                }
+            }
+            RPCError::StreamTimeout => match protocol {
+                Protocol::Ping => PeerAction::LowToleranceError,
+                Protocol::BlocksByRange => PeerAction::MidToleranceError,
+                Protocol::BlocksByRoot => PeerAction::MidToleranceError,
+                Protocol::Goodbye => return,
+                Protocol::MetaData => return,
+                Protocol::Status => return,
+            },
+            RPCError::NegotiationTimeout => PeerAction::HighToleranceError,
+        };
+
+        self.report_peer(peer_id, peer_action);
+    }
+
+    /// A ping request has been received.
+    // NOTE: The behaviour responds with a PONG automatically
+    // TODO: Update last seen
+    pub fn ping_request(&mut self, peer_id: &PeerId, seq: u64) {
+        if let Some(peer_info) = self.network_globals.peers.read().peer_info(peer_id) {
+            // received a ping
+            // reset the to-ping timer for this peer
+            debug!(self.log, "Received a ping request"; "peer_id" => peer_id.to_string(), "seq_no" => seq);
+            self.ping_peers.insert(peer_id.clone());
+
+            // if the sequence number is unknown send an update the meta data of the peer.
+            if let Some(meta_data) = &peer_info.meta_data {
+                if meta_data.seq_number < seq {
+                    debug!(self.log, "Requesting new metadata from peer";
+                        "peer_id" => peer_id.to_string(), "known_seq_no" => meta_data.seq_number, "ping_seq_no" => seq);
+                    self.events
+                        .push(PeerManagerEvent::MetaData(peer_id.clone()));
+                }
+            } else {
+                // if we don't know the meta-data, request it
+                debug!(self.log, "Requesting first metadata from peer";
+                    "peer_id" => peer_id.to_string());
+                self.events
+                    .push(PeerManagerEvent::MetaData(peer_id.clone()));
+            }
+        } else {
+            crit!(self.log, "Received a PING from an unknown peer";
+                "peer_id" => peer_id.to_string());
+        }
+    }
+
+    /// A PONG has been returned from a peer.
+    // TODO: Update last seen
+    pub fn pong_response(&mut self, peer_id: &PeerId, seq: u64) {
+        if let Some(peer_info) = self.network_globals.peers.read().peer_info(peer_id) {
+            // received a pong
+
+            // if the sequence number is unknown send update the meta data of the peer.
+            if let Some(meta_data) = &peer_info.meta_data {
+                if meta_data.seq_number < seq {
+                    debug!(self.log, "Requesting new metadata from peer";
+                        "peer_id" => peer_id.to_string(), "known_seq_no" => meta_data.seq_number, "pong_seq_no" => seq);
+                    self.events
+                        .push(PeerManagerEvent::MetaData(peer_id.clone()));
+                }
+            } else {
+                // if we don't know the meta-data, request it
+                debug!(self.log, "Requesting first metadata from peer";
+                    "peer_id" => peer_id.to_string());
+                self.events
+                    .push(PeerManagerEvent::MetaData(peer_id.clone()));
+            }
+        } else {
+            crit!(self.log, "Received a PONG from an unknown peer"; "peer_id" => peer_id.to_string());
+        }
+    }
+
+    /// Received a metadata response from a peer.
+    // TODO: Update last seen
+    pub fn meta_data_response(&mut self, peer_id: &PeerId, meta_data: MetaData<TSpec>) {
+        if let Some(peer_info) = self.network_globals.peers.write().peer_info_mut(peer_id) {
+            if let Some(known_meta_data) = &peer_info.meta_data {
+                if known_meta_data.seq_number < meta_data.seq_number {
+                    debug!(self.log, "Updating peer's metadata";
+                        "peer_id" => peer_id.to_string(), "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
+                    peer_info.meta_data = Some(meta_data);
+                } else {
+                    debug!(self.log, "Received old metadata";
+                        "peer_id" => peer_id.to_string(), "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
+                }
+            } else {
+                // we have no meta-data for this peer, update
+                debug!(self.log, "Obtained peer's metadata";
+                    "peer_id" => peer_id.to_string(), "new_seq_no" => meta_data.seq_number);
+                peer_info.meta_data = Some(meta_data);
+            }
+        } else {
+            crit!(self.log, "Received METADATA from an unknown peer";
+                "peer_id" => peer_id.to_string());
+        }
+    }
+
+    // Handles the libp2p request to obtain multiaddrs for peer_id's in order to dial them.
+    pub fn addresses_of_peer(&mut self, peer_id: &PeerId) -> Vec<Multiaddr> {
+        if let Some(enr) = self.discovery.enr_of_peer(peer_id) {
+            // ENR's may have multiple Multiaddrs. The multi-addr associated with the UDP
+            // port is removed, which is assumed to be associated with the discv5 protocol (and
+            // therefore irrelevant for other libp2p components).
+            let mut out_list = enr.multiaddr();
+            out_list.retain(|addr| {
+                addr.iter()
+                    .find(|v| match v {
+                        MProtocol::Udp(_) => true,
+                        _ => false,
+                    })
+                    .is_none()
+            });
+
+            out_list
+        } else {
+            // PeerId is not known
+            Vec::new()
+        }
+    }
+
+    /* Internal functions */
+
+    // The underlying discovery server has updated our external IP address. We send this up to
+    // notify libp2p.
+    fn socket_updated(&mut self, socket: SocketAddr) {
+        // Build a multiaddr to report to libp2p
+        let mut multiaddr = Multiaddr::from(socket.ip());
+        // NOTE: This doesn't actually track the external TCP port. More sophisticated NAT handling
+        // should handle this.
+        multiaddr.push(MProtocol::Tcp(self.network_globals.listen_port_tcp()));
+        self.events.push(PeerManagerEvent::SocketUpdated(multiaddr));
+    }
+
+    /// Peers that have been returned by discovery requests are dialed here if they are suitable.
+    ///
+    /// NOTE: By dialing `PeerId`s and not multiaddrs, libp2p requests the multiaddr associated
+    /// with a new `PeerId` which involves a discovery routing table lookup. We could dial the
+    /// multiaddr here, however this could relate to duplicate PeerId's etc. If the lookup
+    /// proves resource constraining, we should switch to multiaddr dialling here.
+    fn peers_discovered(&mut self, peers: Vec<Enr>, min_ttl: Option<Instant>) {
+        for enr in peers {
+            let peer_id = enr.peer_id();
+
+            // if we need more peers, attempt a connection
+            if self.network_globals.connected_or_dialing_peers() < self.target_peers
+                && !self
+                    .network_globals
+                    .peers
+                    .read()
+                    .is_connected_or_dialing(&peer_id)
+                && !self.network_globals.peers.read().peer_banned(&peer_id)
+            {
+                debug!(self.log, "Dialing discovered peer"; "peer_id"=> peer_id.to_string());
+                // TODO: Update output
+                // This should be updated with the peer dialing. In fact created once the peer is
+                // dialed
+                if let Some(min_ttl) = min_ttl {
+                    self.network_globals
+                        .peers
+                        .write()
+                        .update_min_ttl(&peer_id, min_ttl);
+                }
+                self.events.push(PeerManagerEvent::Dial(peer_id));
+            }
+        }
+    }
+
+    /// Registers a peer as connected. The `ingoing` parameter determines if the peer is being
+    /// dialed or connecting to us.
+    ///
+    /// This is called by `connect_ingoing` and `connect_outgoing`.
+    ///
+    /// This informs if the peer was accepted in to the db or not.
+    // TODO: Drop peers if over max_peer limit
+    fn connect_peer(&mut self, peer_id: &PeerId, connection: ConnectingType) -> bool {
+        // TODO: remove after timed updates
+        //self.update_reputations();
+
+        {
+            let mut peerdb = self.network_globals.peers.write();
+            if peerdb.connection_status(peer_id).map(|c| c.is_banned()) == Some(true) {
+                // don't connect if the peer is banned
+                // TODO: Handle this case. If peer is banned this shouldn't be reached. It will put
+                // our connection/disconnection out of sync with libp2p
+                // return false;
+            }
+
+            match connection {
+                ConnectingType::Dialing => peerdb.dialing_peer(peer_id),
+                ConnectingType::IngoingConnected => peerdb.connect_outgoing(peer_id),
+                ConnectingType::OutgoingConnected => peerdb.connect_ingoing(peer_id),
+            }
+        }
+
+        // start a ping and status timer for the peer
+        self.ping_peers.insert(peer_id.clone());
+        self.status_peers.insert(peer_id.clone());
+
+        // increment prometheus metrics
+        metrics::inc_counter(&metrics::PEER_CONNECT_EVENT_COUNT);
+        metrics::set_gauge(
+            &metrics::PEERS_CONNECTED,
+            self.network_globals.connected_peers() as i64,
+        );
+
+        true
+    }
+
+    /// Notifies the peer manager that this peer is being dialed.
+    pub fn _dialing_peer(&mut self, peer_id: &PeerId) {
+        self.network_globals.peers.write().dialing_peer(peer_id);
+    }
+
+    /// Updates the reputation of known peers according to their connection
+    /// status and the time that has passed.
+    ///
+    /// **Disconnected peers** get a 1rep hit every hour they stay disconnected.
+    /// **Banned peers** get a 1rep gain for every hour to slowly allow them back again.
+    ///
+    /// A banned(disconnected) peer that gets its rep above(below) MIN_REP_BEFORE_BAN is
+    /// now considered a disconnected(banned) peer.
+    // TODO: Implement when reputation is added.
+    fn _update_reputations(&mut self) {
+        /*
+        // avoid locking the peerdb too often
+        // TODO: call this on a timer
+
+        let now = Instant::now();
+
+        // Check for peers that get banned, unbanned and that should be disconnected
+        let mut ban_queue = Vec::new();
+        let mut unban_queue = Vec::new();
+
+        /* Check how long have peers been in this state and update their reputations if needed */
+        let mut pdb = self.network_globals.peers.write();
+
+        for (id, info) in pdb._peers_mut() {
+            // Update reputations
+            match info.connection_status {
+                Connected { .. } => {
+                    // Connected peers gain reputation by sending useful messages
+                }
+                Disconnected { since } | Banned { since } => {
+                    // For disconnected peers, lower their reputation by 1 for every hour they
+                    // stay disconnected. This helps us slowly forget disconnected peers.
+                    // In the same way, slowly allow banned peers back again.
+                    let dc_hours = now
+                        .checked_duration_since(since)
+                        .unwrap_or_else(|| Duration::from_secs(0))
+                        .as_secs()
+                        / 3600;
+                    let last_dc_hours = self
+                        ._last_updated
+                        .checked_duration_since(since)
+                        .unwrap_or_else(|| Duration::from_secs(0))
+                        .as_secs()
+                        / 3600;
+                    if dc_hours > last_dc_hours {
+                        // this should be 1 most of the time
+                        let rep_dif = (dc_hours - last_dc_hours)
+                            .try_into()
+                            .unwrap_or(Rep::max_value());
+
+                        info.reputation = if info.connection_status.is_banned() {
+                            info.reputation.saturating_add(rep_dif)
+                        } else {
+                            info.reputation.saturating_sub(rep_dif)
+                        };
+                    }
+                }
+                Dialing { since } => {
+                    // A peer shouldn't be dialing for more than 2 minutes
+                    if since.elapsed().as_secs() > 120 {
+                        warn!(self.log,"Peer has been dialing for too long"; "peer_id" => id.to_string());
+                        // TODO: decide how to handle this
+                    }
+                }
+                Unknown => {} //TODO: Handle this case
+            }
+            // Check if the peer gets banned or unbanned and if it should be disconnected
+            if info.reputation < _MIN_REP_BEFORE_BAN && !info.connection_status.is_banned() {
+                // This peer gets banned. Check if we should request disconnection
+                ban_queue.push(id.clone());
+            } else if info.reputation >= _MIN_REP_BEFORE_BAN && info.connection_status.is_banned() {
+                // This peer gets unbanned
+                unban_queue.push(id.clone());
+            }
+        }
+
+        for id in ban_queue {
+            pdb.ban(&id);
+
+            self.events
+                .push(PeerManagerEvent::DisconnectPeer(id.clone()));
+        }
+
+        for id in unban_queue {
+            pdb.disconnect(&id);
+        }
+
+        self._last_updated = Instant::now();
+        */
+    }
+
+    /// The Peer manager's heartbeat maintains the peer count and maintains peer reputations.
+    ///
+    /// It will request discovery queries if the peer count has not reached the desired number of
+    /// peers.
+    ///
+    /// NOTE: Discovery will only add a new query if one isn't already queued.
+    fn heartbeat(&mut self) {
+        // TODO: Provide a back-off time for discovery queries. I.e Queue many initially, then only
+        // perform discoveries over a larger fixed interval. Perhaps one every 6 heartbeats
+        let peer_count = self.network_globals.connected_or_dialing_peers();
+        if peer_count < self.target_peers {
+            // If we need more peers, queue a discovery lookup.
+            self.discovery.discover_peers();
+        }
+
+        // TODO: If we have too many peers, remove peers that are not required for subnet
+        // validation.
+
+        // TODO: Perform peer reputation maintenance here
+    }
+}
+
+impl<TSpec: EthSpec> Stream for PeerManager<TSpec> {
+    type Item = PeerManagerEvent;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        // perform the heartbeat when necessary
+        while let Poll::Ready(Some(_)) = self.heartbeat.poll_next_unpin(cx) {
+            self.heartbeat();
+        }
+
+        // handle any discovery events
+        while let Poll::Ready(event) = self.discovery.poll(cx) {
+            match event {
+                DiscoveryEvent::SocketUpdated(socket_addr) => self.socket_updated(socket_addr),
+                DiscoveryEvent::QueryResult(min_ttl, peers) => {
+                    self.peers_discovered(*peers, min_ttl)
+                }
+            }
+        }
+
+        // poll the timeouts for pings and status'
+        loop {
+            match self.ping_peers.poll_next_unpin(cx) {
+                Poll::Ready(Some(Ok(peer_id))) => {
+                    self.ping_peers.insert(peer_id.clone());
+                    self.events.push(PeerManagerEvent::Ping(peer_id));
+                }
+                Poll::Ready(Some(Err(e))) => {
+                    error!(self.log, "Failed to check for peers to ping"; "error" => format!("{}",e))
+                }
+                Poll::Ready(None) | Poll::Pending => break,
+            }
+        }
+
+        loop {
+            match self.status_peers.poll_next_unpin(cx) {
+                Poll::Ready(Some(Ok(peer_id))) => {
+                    self.status_peers.insert(peer_id.clone());
+                    self.events.push(PeerManagerEvent::Status(peer_id))
+                }
+                Poll::Ready(Some(Err(e))) => {
+                    error!(self.log, "Failed to check for peers to ping"; "error" => format!("{}",e))
+                }
+                Poll::Ready(None) | Poll::Pending => break,
+            }
+        }
+
+        if !self.events.is_empty() {
+            return Poll::Ready(Some(self.events.remove(0)));
+        } else {
+            self.events.shrink_to_fit();
+        }
+
+        Poll::Pending
+    }
+}
+
+enum ConnectingType {
+    /// We are in the process of dialing this peer.
+    Dialing,
+    /// A peer has dialed us.
+    IngoingConnected,
+    /// We have successfully dialed a peer.
+    OutgoingConnected,
+}

beacon_node/eth2_libp2p/src/peer_manager/peer_info.rs

@@ -0,0 +1,223 @@
+use super::client::Client;
+use super::peerdb::{Rep, DEFAULT_REPUTATION};
+use super::PeerSyncStatus;
+use crate::rpc::MetaData;
+use crate::Multiaddr;
+use serde::{
+    ser::{SerializeStructVariant, Serializer},
+    Serialize,
+};
+use std::time::Instant;
+use types::{EthSpec, SubnetId};
+use PeerConnectionStatus::*;
+
+/// Information about a given connected peer.
+#[derive(Clone, Debug, Serialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct PeerInfo<T: EthSpec> {
+    /// The connection status of the peer
+    _status: PeerStatus,
+    /// The peers reputation
+    pub reputation: Rep,
+    /// Client managing this peer
+    pub client: Client,
+    /// Connection status of this peer
+    pub connection_status: PeerConnectionStatus,
+    /// The known listening addresses of this peer.
+    pub listening_addresses: Vec<Multiaddr>,
+    /// The current syncing state of the peer. The state may be determined after it's initial
+    /// connection.
+    pub sync_status: PeerSyncStatus,
+    /// The ENR subnet bitfield of the peer. This may be determined after it's initial
+    /// connection.
+    pub meta_data: Option<MetaData<T>>,
+    /// The time we would like to retain this peer. After this time, the peer is no longer
+    /// necessary.
+    #[serde(skip)]
+    pub min_ttl: Option<Instant>,
+}
+
+impl<TSpec: EthSpec> Default for PeerInfo<TSpec> {
+    fn default() -> PeerInfo<TSpec> {
+        PeerInfo {
+            _status: Default::default(),
+            reputation: DEFAULT_REPUTATION,
+            client: Client::default(),
+            connection_status: Default::default(),
+            listening_addresses: vec![],
+            sync_status: PeerSyncStatus::Unknown,
+            meta_data: None,
+            min_ttl: None,
+        }
+    }
+}
+
+impl<T: EthSpec> PeerInfo<T> {
+    /// Returns if the peer is subscribed to a given `SubnetId`
+    pub fn on_subnet(&self, subnet_id: SubnetId) -> bool {
+        if let Some(meta_data) = &self.meta_data {
+            return meta_data
+                .attnets
+                .get(*subnet_id as usize)
+                .unwrap_or_else(|_| false);
+        }
+        false
+    }
+}
+
+#[derive(Clone, Debug, Serialize)]
+/// The current health status of the peer.
+pub enum PeerStatus {
+    /// The peer is healthy.
+    Healthy,
+    /// The peer is clogged. It has not been responding to requests on time.
+    _Clogged,
+}
+
+impl Default for PeerStatus {
+    fn default() -> Self {
+        PeerStatus::Healthy
+    }
+}
+
+/// Connection Status of the peer.
+#[derive(Debug, Clone)]
+pub enum PeerConnectionStatus {
+    /// The peer is connected.
+    Connected {
+        /// number of ingoing connections.
+        n_in: u8,
+        /// number of outgoing connections.
+        n_out: u8,
+    },
+    /// The peer has disconnected.
+    Disconnected {
+        /// last time the peer was connected or discovered.
+        since: Instant,
+    },
+    /// The peer has been banned and is disconnected.
+    Banned {
+        /// moment when the peer was banned.
+        since: Instant,
+    },
+    /// We are currently dialing this peer.
+    Dialing {
+        /// time since we last communicated with the peer.
+        since: Instant,
+    },
+    /// The connection status has not been specified.
+    Unknown,
+}
+
+/// Serialization for http requests.
+impl Serialize for PeerConnectionStatus {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            Connected { n_in, n_out } => {
+                let mut s = serializer.serialize_struct_variant("", 0, "Connected", 2)?;
+                s.serialize_field("in", n_in)?;
+                s.serialize_field("out", n_out)?;
+                s.end()
+            }
+            Disconnected { since } => {
+                let mut s = serializer.serialize_struct_variant("", 1, "Disconnected", 1)?;
+                s.serialize_field("since", &since.elapsed().as_secs())?;
+                s.end()
+            }
+            Banned { since } => {
+                let mut s = serializer.serialize_struct_variant("", 2, "Banned", 1)?;
+                s.serialize_field("since", &since.elapsed().as_secs())?;
+                s.end()
+            }
+            Dialing { since } => {
+                let mut s = serializer.serialize_struct_variant("", 3, "Dialing", 1)?;
+                s.serialize_field("since", &since.elapsed().as_secs())?;
+                s.end()
+            }
+            Unknown => serializer.serialize_unit_variant("", 4, "Unknown"),
+        }
+    }
+}
+
+impl Default for PeerConnectionStatus {
+    fn default() -> Self {
+        PeerConnectionStatus::Unknown
+    }
+}
+
+impl PeerConnectionStatus {
+    /// Checks if the status is connected
+    pub fn is_connected(&self) -> bool {
+        match self {
+            PeerConnectionStatus::Connected { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Checks if the status is connected
+    pub fn is_dialing(&self) -> bool {
+        match self {
+            PeerConnectionStatus::Dialing { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Checks if the status is banned
+    pub fn is_banned(&self) -> bool {
+        match self {
+            PeerConnectionStatus::Banned { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Checks if the status is disconnected
+    pub fn is_disconnected(&self) -> bool {
+        match self {
+            Disconnected { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Modifies the status to Connected and increases the number of ingoing
+    /// connections by one
+    pub fn connect_ingoing(&mut self) {
+        match self {
+            Connected { n_in, .. } => *n_in += 1,
+            Disconnected { .. } | Banned { .. } | Dialing { .. } | Unknown => {
+                *self = Connected { n_in: 1, n_out: 0 }
+            }
+        }
+    }
+
+    /// Modifies the status to Connected and increases the number of outgoing
+    /// connections by one
+    pub fn connect_outgoing(&mut self) {
+        match self {
+            Connected { n_out, .. } => *n_out += 1,
+            Disconnected { .. } | Banned { .. } | Dialing { .. } | Unknown => {
+                *self = Connected { n_in: 0, n_out: 1 }
+            }
+        }
+    }
+
+    /// Modifies the status to Disconnected and sets the last seen instant to now
+    pub fn disconnect(&mut self) {
+        *self = Disconnected {
+            since: Instant::now(),
+        };
+    }
+
+    /// Modifies the status to Banned
+    pub fn ban(&mut self) {
+        *self = Banned {
+            since: Instant::now(),
+        };
+    }
+
+    pub fn connections(&self) -> (u8, u8) {
+        match self {
+            Connected { n_in, n_out } => (*n_in, *n_out),
+            _ => (0, 0),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/peer_sync_status.rs

@@ -0,0 +1,104 @@
+//! Handles individual sync status for peers.
+
+use serde::Serialize;
+use types::{Epoch, Hash256, Slot};
+
+#[derive(Clone, Debug, Serialize)]
+/// The current sync status of the peer.
+pub enum PeerSyncStatus {
+    /// At the current state as our node or ahead of us.
+    Synced { info: SyncInfo },
+    /// The peer has greater knowledge about the canonical chain than we do.
+    Advanced { info: SyncInfo },
+    /// Is behind our current head and not useful for block downloads.
+    Behind { info: SyncInfo },
+    /// Not currently known as a STATUS handshake has not occurred.
+    Unknown,
+}
+
+/// This is stored inside the PeerSyncStatus and is very similar to `PeerSyncInfo` in the
+/// `Network` crate.
+#[derive(Clone, Debug, Serialize)]
+pub struct SyncInfo {
+    pub status_head_slot: Slot,
+    pub status_head_root: Hash256,
+    pub status_finalized_epoch: Epoch,
+    pub status_finalized_root: Hash256,
+}
+
+impl PeerSyncStatus {
+    /// Returns true if the peer has advanced knowledge of the chain.
+    pub fn is_advanced(&self) -> bool {
+        match self {
+            PeerSyncStatus::Advanced { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the peer is up to date with the current chain.
+    pub fn is_synced(&self) -> bool {
+        match self {
+            PeerSyncStatus::Synced { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the peer is behind the current chain.
+    pub fn is_behind(&self) -> bool {
+        match self {
+            PeerSyncStatus::Behind { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Updates the sync state given a fully synced peer.
+    /// Returns true if the state has changed.
+    pub fn update_synced(&mut self, info: SyncInfo) -> bool {
+        let new_state = PeerSyncStatus::Synced { info };
+
+        match self {
+            PeerSyncStatus::Synced { .. } | PeerSyncStatus::Unknown => {
+                *self = new_state;
+                false // state was not updated
+            }
+            _ => {
+                *self = new_state;
+                true
+            }
+        }
+    }
+
+    /// Updates the sync state given a peer that is further ahead in the chain than us.
+    /// Returns true if the state has changed.
+    pub fn update_advanced(&mut self, info: SyncInfo) -> bool {
+        let new_state = PeerSyncStatus::Advanced { info };
+
+        match self {
+            PeerSyncStatus::Advanced { .. } | PeerSyncStatus::Unknown => {
+                *self = new_state;
+                false // state was not updated
+            }
+            _ => {
+                *self = new_state;
+                true
+            }
+        }
+    }
+
+    /// Updates the sync state given a peer that is behind us in the chain.
+    /// Returns true if the state has changed.
+    pub fn update_behind(&mut self, info: SyncInfo) -> bool {
+        let new_state = PeerSyncStatus::Behind { info };
+
+        match self {
+            PeerSyncStatus::Behind { .. } | PeerSyncStatus::Unknown => {
+                *self = new_state;
+                false // state was not updated
+            }
+            _ => {
+                *self = new_state;
+                true
+            }
+        }
+    }
+}

beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs

@@ -0,0 +1,581 @@
+use super::peer_info::{PeerConnectionStatus, PeerInfo};
+use super::peer_sync_status::PeerSyncStatus;
+use crate::rpc::methods::MetaData;
+use crate::PeerId;
+use slog::{crit, debug, trace, warn};
+use std::collections::{hash_map::Entry, HashMap};
+use std::time::Instant;
+use types::{EthSpec, SubnetId};
+
+/// A peer's reputation (perceived potential usefulness)
+pub type Rep = u8;
+
+/// Reputation change (positive or negative)
+pub struct RepChange {
+    is_good: bool,
+    diff: Rep,
+}
+
+/// Max number of disconnected nodes to remember
+const MAX_DC_PEERS: usize = 30;
+
+/// The default starting reputation for an unknown peer.
+pub const DEFAULT_REPUTATION: Rep = 50;
+
+/// Storage of known peers, their reputation and information
+pub struct PeerDB<TSpec: EthSpec> {
+    /// The collection of known connected peers, their status and reputation
+    peers: HashMap<PeerId, PeerInfo<TSpec>>,
+    /// Tracking of number of disconnected nodes
+    n_dc: usize,
+    /// PeerDB's logger
+    log: slog::Logger,
+}
+
+impl RepChange {
+    pub fn good(diff: Rep) -> Self {
+        RepChange {
+            is_good: true,
+            diff,
+        }
+    }
+    pub fn bad(diff: Rep) -> Self {
+        RepChange {
+            is_good: false,
+            diff,
+        }
+    }
+    pub const fn worst() -> Self {
+        RepChange {
+            is_good: false,
+            diff: Rep::max_value(),
+        }
+    }
+}
+
+impl<TSpec: EthSpec> PeerDB<TSpec> {
+    pub fn new(log: &slog::Logger) -> Self {
+        Self {
+            log: log.clone(),
+            n_dc: 0,
+            peers: HashMap::new(),
+        }
+    }
+
+    /* Getters */
+
+    /// Gives the reputation of a peer, or DEFAULT_REPUTATION if it is unknown.
+    pub fn reputation(&self, peer_id: &PeerId) -> Rep {
+        self.peers
+            .get(peer_id)
+            .map_or(DEFAULT_REPUTATION, |info| info.reputation)
+    }
+
+    /// Returns an iterator over all peers in the db.
+    pub fn peers(&self) -> impl Iterator<Item = (&PeerId, &PeerInfo<TSpec>)> {
+        self.peers.iter()
+    }
+
+    /// Returns an iterator over all peers in the db.
+    pub(super) fn _peers_mut(&mut self) -> impl Iterator<Item = (&PeerId, &mut PeerInfo<TSpec>)> {
+        self.peers.iter_mut()
+    }
+
+    /// Gives the ids of all known peers.
+    pub fn peer_ids(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers.keys()
+    }
+
+    /// Returns a peer's info, if known.
+    pub fn peer_info(&self, peer_id: &PeerId) -> Option<&PeerInfo<TSpec>> {
+        self.peers.get(peer_id)
+    }
+
+    /// Returns a mutable reference to a peer's info if known.
+    /// TODO: make pub(super) to ensure that peer management is unified
+    pub fn peer_info_mut(&mut self, peer_id: &PeerId) -> Option<&mut PeerInfo<TSpec>> {
+        self.peers.get_mut(peer_id)
+    }
+
+    /// Returns true if the peer is synced at least to our current head.
+    pub fn peer_synced(&self, peer_id: &PeerId) -> bool {
+        match self.peers.get(peer_id).map(|info| &info.sync_status) {
+            Some(PeerSyncStatus::Synced { .. }) => true,
+            Some(_) => false,
+            None => false,
+        }
+    }
+
+    /// Returns true if the Peer is banned.
+    pub fn peer_banned(&self, peer_id: &PeerId) -> bool {
+        match self.peers.get(peer_id).map(|info| &info.connection_status) {
+            Some(status) => status.is_banned(),
+            None => false,
+        }
+    }
+
+    /// Gives the ids of all known connected peers.
+    pub fn connected_peers(&self) -> impl Iterator<Item = (&PeerId, &PeerInfo<TSpec>)> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| info.connection_status.is_connected())
+    }
+
+    /// Gives the ids of all known connected peers.
+    pub fn connected_peer_ids(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| info.connection_status.is_connected())
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Connected or dialing peers
+    pub fn connected_or_dialing_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| {
+                info.connection_status.is_connected() || info.connection_status.is_dialing()
+            })
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Gives the `peer_id` of all known connected and synced peers.
+    pub fn synced_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| {
+                if info.sync_status.is_synced() || info.sync_status.is_advanced() {
+                    return info.connection_status.is_connected();
+                }
+                false
+            })
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Gives an iterator of all peers on a given subnet.
+    pub fn peers_on_subnet(&self, subnet_id: SubnetId) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(move |(_, info)| {
+                info.connection_status.is_connected() && info.on_subnet(subnet_id)
+            })
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Gives the ids of all known disconnected peers.
+    pub fn disconnected_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| info.connection_status.is_disconnected())
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Gives the ids of all known banned peers.
+    pub fn banned_peers(&self) -> impl Iterator<Item = &PeerId> {
+        self.peers
+            .iter()
+            .filter(|(_, info)| info.connection_status.is_banned())
+            .map(|(peer_id, _)| peer_id)
+    }
+
+    /// Returns a vector containing peers (their ids and info), sorted by
+    /// reputation from highest to lowest, and filtered using `is_status`
+    pub fn best_peers_by_status<F>(&self, is_status: F) -> Vec<(&PeerId, &PeerInfo<TSpec>)>
+    where
+        F: Fn(&PeerConnectionStatus) -> bool,
+    {
+        let mut by_status = self
+            .peers
+            .iter()
+            .filter(|(_, info)| is_status(&info.connection_status))
+            .collect::<Vec<_>>();
+        by_status.sort_by_key(|(_, info)| Rep::max_value() - info.reputation);
+        by_status
+    }
+
+    /// Returns the peer with highest reputation that satisfies `is_status`
+    pub fn best_by_status<F>(&self, is_status: F) -> Option<&PeerId>
+    where
+        F: Fn(&PeerConnectionStatus) -> bool,
+    {
+        self.peers
+            .iter()
+            .filter(|(_, info)| is_status(&info.connection_status))
+            .max_by_key(|(_, info)| info.reputation)
+            .map(|(id, _)| id)
+    }
+
+    /// Returns the peer's connection status. Returns unknown if the peer is not in the DB.
+    pub fn connection_status(&self, peer_id: &PeerId) -> Option<PeerConnectionStatus> {
+        self.peer_info(peer_id)
+            .map(|info| info.connection_status.clone())
+    }
+
+    /// Returns if the peer is already connected.
+    pub fn is_connected(&self, peer_id: &PeerId) -> bool {
+        if let Some(PeerConnectionStatus::Connected { .. }) = self.connection_status(peer_id) {
+            true
+        } else {
+            false
+        }
+    }
+
+    /// If we are connected or currently dialing the peer returns true.
+    pub fn is_connected_or_dialing(&self, peer_id: &PeerId) -> bool {
+        match self.connection_status(peer_id) {
+            Some(PeerConnectionStatus::Connected { .. })
+            | Some(PeerConnectionStatus::Dialing { .. }) => true,
+            _ => false,
+        }
+    }
+
+    /* Setters */
+
+    /// A peer is being dialed.
+    pub fn dialing_peer(&mut self, peer_id: &PeerId) {
+        let info = self.peers.entry(peer_id.clone()).or_default();
+
+        if info.connection_status.is_disconnected() {
+            self.n_dc = self.n_dc.saturating_sub(1);
+        }
+        info.connection_status = PeerConnectionStatus::Dialing {
+            since: Instant::now(),
+        };
+    }
+
+    /// Update min ttl of a peer.
+    pub fn update_min_ttl(&mut self, peer_id: &PeerId, min_ttl: Instant) {
+        let info = self.peers.entry(peer_id.clone()).or_default();
+
+        // only update if the ttl is longer
+        if info.min_ttl.is_none() || Some(min_ttl) > info.min_ttl {
+            info.min_ttl = Some(min_ttl);
+
+            let min_ttl_secs = min_ttl
+                .checked_duration_since(Instant::now())
+                .map(|duration| duration.as_secs())
+                .unwrap_or_else(|| 0);
+            debug!(self.log, "Updating the time a peer is required for"; "peer_id" => peer_id.to_string(), "future_min_ttl_secs" => min_ttl_secs);
+        }
+    }
+
+    /// Extends the ttl of all peers on the given subnet that have a shorter
+    /// min_ttl than what's given.
+    pub fn extend_peers_on_subnet(&mut self, subnet_id: SubnetId, min_ttl: Instant) {
+        let log = &self.log;
+        self.peers.iter_mut()
+            .filter(move |(_, info)| {
+                info.connection_status.is_connected() && info.on_subnet(subnet_id)
+            })
+            .for_each(|(peer_id,info)| {
+                if info.min_ttl.is_none() || Some(min_ttl) > info.min_ttl {
+                    info.min_ttl = Some(min_ttl);
+                }
+                let min_ttl_secs = min_ttl
+                    .checked_duration_since(Instant::now())
+                    .map(|duration| duration.as_secs())
+                    .unwrap_or_else(|| 0);
+                trace!(log, "Updating minimum duration a peer is required for"; "peer_id" => peer_id.to_string(), "min_ttl" => min_ttl_secs);
+            });
+    }
+
+    /// Sets a peer as connected with an ingoing connection.
+    pub fn connect_ingoing(&mut self, peer_id: &PeerId) {
+        let info = self.peers.entry(peer_id.clone()).or_default();
+
+        if info.connection_status.is_disconnected() {
+            self.n_dc = self.n_dc.saturating_sub(1);
+        }
+        info.connection_status.connect_ingoing();
+    }
+
+    /// Sets a peer as connected with an outgoing connection.
+    pub fn connect_outgoing(&mut self, peer_id: &PeerId) {
+        let info = self.peers.entry(peer_id.clone()).or_default();
+
+        if info.connection_status.is_disconnected() {
+            self.n_dc = self.n_dc.saturating_sub(1);
+        }
+        info.connection_status.connect_outgoing();
+    }
+
+    /// Sets the peer as disconnected. A banned peer remains banned
+    pub fn disconnect(&mut self, peer_id: &PeerId) {
+        let log_ref = &self.log;
+        let info = self.peers.entry(peer_id.clone()).or_insert_with(|| {
+            warn!(log_ref, "Disconnecting unknown peer";
+                "peer_id" => peer_id.to_string());
+            PeerInfo::default()
+        });
+        if !info.connection_status.is_disconnected() && !info.connection_status.is_banned() {
+            info.connection_status.disconnect();
+            self.n_dc += 1;
+        }
+        self.shrink_to_fit();
+    }
+
+    /// Drops the peers with the lowest reputation so that the number of
+    /// disconnected peers is less than MAX_DC_PEERS
+    pub fn shrink_to_fit(&mut self) {
+        // for caution, but the difference should never be > 1
+        while self.n_dc > MAX_DC_PEERS {
+            let to_drop = self
+                .peers
+                .iter()
+                .filter(|(_, info)| info.connection_status.is_disconnected())
+                .min_by_key(|(_, info)| info.reputation)
+                .map(|(id, _)| id.clone())
+                .unwrap(); // should be safe since n_dc > MAX_DC_PEERS > 0
+            self.peers.remove(&to_drop);
+            self.n_dc = self.n_dc.saturating_sub(1);
+        }
+    }
+
+    /// Sets a peer as banned
+    pub fn ban(&mut self, peer_id: &PeerId) {
+        let log_ref = &self.log;
+        let info = self.peers.entry(peer_id.clone()).or_insert_with(|| {
+            warn!(log_ref, "Banning unknown peer";
+                    "peer_id" => peer_id.to_string());
+            PeerInfo::default()
+        });
+        if info.connection_status.is_disconnected() {
+            self.n_dc = self.n_dc.saturating_sub(1);
+        }
+        info.connection_status.ban();
+    }
+
+    /// Add the meta data of a peer.
+    pub fn add_metadata(&mut self, peer_id: &PeerId, meta_data: MetaData<TSpec>) {
+        if let Some(peer_info) = self.peers.get_mut(peer_id) {
+            peer_info.meta_data = Some(meta_data);
+        } else {
+            warn!(self.log, "Tried to add meta data for a non-existant peer"; "peer_id" => peer_id.to_string());
+        }
+    }
+
+    /// Sets the reputation of peer.
+    #[allow(dead_code)]
+    pub(super) fn set_reputation(&mut self, peer_id: &PeerId, rep: Rep) {
+        if let Some(peer_info) = self.peers.get_mut(peer_id) {
+            peer_info.reputation = rep;
+        } else {
+            crit!(self.log, "Tried to modify reputation for an unknown peer"; "peer_id" => peer_id.to_string());
+        }
+    }
+
+    /// Sets the syncing status of a peer.
+    pub fn set_sync_status(&mut self, peer_id: &PeerId, sync_status: PeerSyncStatus) {
+        if let Some(peer_info) = self.peers.get_mut(peer_id) {
+            peer_info.sync_status = sync_status;
+        } else {
+            crit!(self.log, "Tried to the sync status for an unknown peer"; "peer_id" => peer_id.to_string());
+        }
+    }
+
+    /// Adds to a peer's reputation by `change`. If the reputation exceeds Rep's
+    /// upper (lower) bounds, it stays at the maximum (minimum) value.
+    pub(super) fn add_reputation(&mut self, peer_id: &PeerId, change: RepChange) {
+        let log_ref = &self.log;
+        let info = match self.peers.entry(peer_id.clone()) {
+            Entry::Vacant(_) => {
+                warn!(log_ref, "Peer is unknown, no reputation change made";
+                        "peer_id" => peer_id.to_string());
+                return;
+            }
+            Entry::Occupied(e) => e.into_mut(),
+        };
+
+        info.reputation = if change.is_good {
+            info.reputation.saturating_add(change.diff)
+        } else {
+            info.reputation.saturating_sub(change.diff)
+        };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use slog::{o, Drain};
+    use types::MinimalEthSpec;
+    type M = MinimalEthSpec;
+
+    pub fn build_log(level: slog::Level, enabled: bool) -> slog::Logger {
+        let decorator = slog_term::TermDecorator::new().build();
+        let drain = slog_term::FullFormat::new(decorator).build().fuse();
+        let drain = slog_async::Async::new(drain).build().fuse();
+
+        if enabled {
+            slog::Logger::root(drain.filter_level(level).fuse(), o!())
+        } else {
+            slog::Logger::root(drain.filter(|_| false).fuse(), o!())
+        }
+    }
+
+    fn get_db() -> PeerDB<M> {
+        let log = build_log(slog::Level::Debug, false);
+        PeerDB::new(&log)
+    }
+
+    #[test]
+    fn test_peer_connected_successfully() {
+        let mut pdb = get_db();
+        let random_peer = PeerId::random();
+
+        let (n_in, n_out) = (10, 20);
+        for _ in 0..n_in {
+            pdb.connect_ingoing(&random_peer);
+        }
+        for _ in 0..n_out {
+            pdb.connect_outgoing(&random_peer);
+        }
+
+        // the peer is known
+        let peer_info = pdb.peer_info(&random_peer);
+        assert!(peer_info.is_some());
+        // this is the only peer
+        assert_eq!(pdb.peers().count(), 1);
+        // the peer has the default reputation
+        assert_eq!(pdb.reputation(&random_peer), DEFAULT_REPUTATION);
+        // it should be connected, and therefore not counted as disconnected
+        assert_eq!(pdb.n_dc, 0);
+        assert!(peer_info.unwrap().connection_status.is_connected());
+        assert_eq!(
+            peer_info.unwrap().connection_status.connections(),
+            (n_in, n_out)
+        );
+    }
+
+    #[test]
+    fn test_set_reputation() {
+        let mut pdb = get_db();
+        let random_peer = PeerId::random();
+        pdb.connect_ingoing(&random_peer);
+
+        let mut rep = Rep::min_value();
+        pdb.set_reputation(&random_peer, rep);
+        assert_eq!(pdb.reputation(&random_peer), rep);
+
+        rep = Rep::max_value();
+        pdb.set_reputation(&random_peer, rep);
+        assert_eq!(pdb.reputation(&random_peer), rep);
+
+        rep = Rep::max_value() / 100;
+        pdb.set_reputation(&random_peer, rep);
+        assert_eq!(pdb.reputation(&random_peer), rep);
+    }
+
+    #[test]
+    fn test_reputation_change() {
+        let mut pdb = get_db();
+
+        // 0 change does not change de reputation
+        let random_peer = PeerId::random();
+        let change = RepChange::good(0);
+        pdb.connect_ingoing(&random_peer);
+        pdb.add_reputation(&random_peer, change);
+        assert_eq!(pdb.reputation(&random_peer), DEFAULT_REPUTATION);
+
+        // overflowing change is capped
+        let random_peer = PeerId::random();
+        let change = RepChange::worst();
+        pdb.connect_ingoing(&random_peer);
+        pdb.add_reputation(&random_peer, change);
+        assert_eq!(pdb.reputation(&random_peer), Rep::min_value());
+
+        let random_peer = PeerId::random();
+        let change = RepChange::good(Rep::max_value());
+        pdb.connect_ingoing(&random_peer);
+        pdb.add_reputation(&random_peer, change);
+        assert_eq!(pdb.reputation(&random_peer), Rep::max_value());
+    }
+
+    #[test]
+    fn test_disconnected_are_bounded() {
+        let mut pdb = get_db();
+
+        for _ in 0..MAX_DC_PEERS + 1 {
+            let p = PeerId::random();
+            pdb.connect_ingoing(&p);
+        }
+        assert_eq!(pdb.n_dc, 0);
+
+        for p in pdb.connected_peer_ids().cloned().collect::<Vec<_>>() {
+            pdb.disconnect(&p);
+        }
+
+        assert_eq!(pdb.n_dc, MAX_DC_PEERS);
+    }
+
+    #[test]
+    fn test_best_peers() {
+        let mut pdb = get_db();
+
+        let p0 = PeerId::random();
+        let p1 = PeerId::random();
+        let p2 = PeerId::random();
+        pdb.connect_ingoing(&p0);
+        pdb.connect_ingoing(&p1);
+        pdb.connect_ingoing(&p2);
+        pdb.set_reputation(&p0, 70);
+        pdb.set_reputation(&p1, 100);
+        pdb.set_reputation(&p2, 50);
+
+        let best_peers = pdb.best_peers_by_status(PeerConnectionStatus::is_connected);
+        assert!(vec![&p1, &p0, &p2]
+            .into_iter()
+            .eq(best_peers.into_iter().map(|p| p.0)));
+    }
+
+    #[test]
+    fn test_the_best_peer() {
+        let mut pdb = get_db();
+
+        let p0 = PeerId::random();
+        let p1 = PeerId::random();
+        let p2 = PeerId::random();
+        pdb.connect_ingoing(&p0);
+        pdb.connect_ingoing(&p1);
+        pdb.connect_ingoing(&p2);
+        pdb.set_reputation(&p0, 70);
+        pdb.set_reputation(&p1, 100);
+        pdb.set_reputation(&p2, 50);
+
+        let the_best = pdb.best_by_status(PeerConnectionStatus::is_connected);
+        assert!(the_best.is_some());
+        // Consistency check
+        let best_peers = pdb.best_peers_by_status(PeerConnectionStatus::is_connected);
+        assert_eq!(the_best, best_peers.into_iter().map(|p| p.0).next());
+    }
+
+    #[test]
+    fn test_disconnected_consistency() {
+        let mut pdb = get_db();
+
+        let random_peer = PeerId::random();
+
+        pdb.connect_ingoing(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+
+        pdb.connect_ingoing(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+        pdb.disconnect(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+
+        pdb.connect_outgoing(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+        pdb.disconnect(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+
+        pdb.ban(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+        pdb.disconnect(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+
+        pdb.disconnect(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+        pdb.disconnect(&random_peer);
+        assert_eq!(pdb.n_dc, pdb.disconnected_peers().count());
+    }
+}