Merge branch 'master' into spec-v0.12

beacon_node/eth2_libp2p/Cargo.toml

@@ -0,0 +1,55 @@
+[package]
+name = "eth2_libp2p"
+version = "0.1.2"
+authors = ["Age Manning <Age@AgeManning.com>"]
+edition = "2018"
+
+[dependencies]
+hex = "0.4.2"
+types = { path =  "../../consensus/types" }
+hashset_delay = { path = "../../common/hashset_delay" }
+eth2_ssz_types = { path =  "../../consensus/ssz_types" }
+serde = { version = "1.0.110", features = ["derive"] }
+serde_derive = "1.0.110"
+eth2_ssz = "0.1.2"
+eth2_ssz_derive = "0.1.0"
+slog = { version = "2.5.2", features = ["max_level_trace"] }
+version = { path = "../version" }
+tokio = { version = "0.2.21", features = ["time", "macros"] }
+futures = "0.3.5"
+error-chain = "0.12.2"
+dirs = "2.0.2"
+fnv = "1.0.7"
+unsigned-varint = { git = "https://github.com/sigp/unsigned-varint", branch = "latest-codecs", features = ["codec"] }
+lazy_static = "1.4.0"
+lighthouse_metrics = { path = "../../common/lighthouse_metrics" }
+smallvec = "1.4.0"
+lru = "0.5.1"
+parking_lot = "0.10.2"
+sha2 = "0.8.2"
+base64 = "0.12.1"
+snap = "1.0.0"
+void = "1.0.2"
+tokio-io-timeout = "0.4.0"
+tokio-util = { version = "0.3.1", features = ["codec", "compat"] }
+discv5 = { version = "0.1.0-alpha.5", features = ["libp2p"] }
+tiny-keccak = "2.0.2"
+environment = { path = "../../lighthouse/environment" }
+libp2p-tcp = { version = "0.19.1", default-features = false, features = ["tokio"] }
+
+[dependencies.libp2p]
+version = "0.19.1"
+default-features = false
+features = ["websocket", "identify", "mplex", "yamux", "noise", "gossipsub", "dns"]
+
+
+[dev-dependencies]
+tokio = { version = "0.2.21", features = ["full"] }
+slog-stdlog = "4.0.0"
+slog-term = "2.5.0"
+slog-async = "2.5.0"
+tempdir = "0.3.7"
+exit-future = "0.2.0"
+
+[features]
+libp2p-websocket = []

beacon_node/eth2_libp2p/src/behaviour/handler/delegate.rs

@@ -0,0 +1,361 @@
+use crate::rpc::*;
+use libp2p::{
+    core::either::{EitherError, EitherOutput},
+    core::upgrade::{EitherUpgrade, InboundUpgrade, OutboundUpgrade, SelectUpgrade, UpgradeError},
+    gossipsub::Gossipsub,
+    identify::Identify,
+    swarm::{
+        protocols_handler::{
+            KeepAlive, ProtocolsHandlerEvent, ProtocolsHandlerUpgrErr, SubstreamProtocol,
+        },
+        NegotiatedSubstream, NetworkBehaviour, ProtocolsHandler,
+    },
+};
+use std::task::{Context, Poll};
+use types::EthSpec;
+
+/* Auxiliary types for simplicity */
+type GossipHandler = <Gossipsub as NetworkBehaviour>::ProtocolsHandler;
+type RPCHandler<TSpec> = <RPC<TSpec> as NetworkBehaviour>::ProtocolsHandler;
+type IdentifyHandler = <Identify as NetworkBehaviour>::ProtocolsHandler;
+
+/// Handler that combines Lighthouse's Behaviours' handlers in a delegating manner.
+pub(super) struct DelegatingHandler<TSpec: EthSpec> {
+    /// Handler for the Gossipsub protocol.
+    gossip_handler: GossipHandler,
+    /// Handler for the RPC protocol.
+    rpc_handler: RPCHandler<TSpec>,
+    /// Handler for the Identify protocol.
+    identify_handler: IdentifyHandler,
+}
+
+impl<TSpec: EthSpec> DelegatingHandler<TSpec> {
+    pub fn new(gossipsub: &mut Gossipsub, rpc: &mut RPC<TSpec>, identify: &mut Identify) -> Self {
+        DelegatingHandler {
+            gossip_handler: gossipsub.new_handler(),
+            rpc_handler: rpc.new_handler(),
+            identify_handler: identify.new_handler(),
+        }
+    }
+
+    /// Gives mutable access to the rpc handler.
+    pub fn rpc_mut(&mut self) -> &mut RPCHandler<TSpec> {
+        &mut self.rpc_handler
+    }
+
+    /// Gives access to the rpc handler.
+    pub fn rpc(&self) -> &RPCHandler<TSpec> {
+        &self.rpc_handler
+    }
+
+    /// Gives access to identify's handler.
+    pub fn identify(&self) -> &IdentifyHandler {
+        &self.identify_handler
+    }
+}
+
+// TODO: this can all be created with macros
+
+/// Wrapper around the `ProtocolsHandler::InEvent` types of the handlers.
+/// Simply delegated to the corresponding behaviour's handler.
+#[derive(Debug, Clone)]
+pub enum DelegateIn<TSpec: EthSpec> {
+    Gossipsub(<GossipHandler as ProtocolsHandler>::InEvent),
+    RPC(<RPCHandler<TSpec> as ProtocolsHandler>::InEvent),
+    Identify(<IdentifyHandler as ProtocolsHandler>::InEvent),
+}
+
+/// Wrapper around the `ProtocolsHandler::OutEvent` types of the handlers.
+/// Simply delegated to the corresponding behaviour's handler.
+pub enum DelegateOut<TSpec: EthSpec> {
+    Gossipsub(<GossipHandler as ProtocolsHandler>::OutEvent),
+    RPC(<RPCHandler<TSpec> as ProtocolsHandler>::OutEvent),
+    Identify(<IdentifyHandler as ProtocolsHandler>::OutEvent),
+}
+
+/// Wrapper around the `ProtocolsHandler::Error` types of the handlers.
+/// Simply delegated to the corresponding behaviour's handler.
+#[derive(Debug)]
+pub enum DelegateError<TSpec: EthSpec> {
+    Gossipsub(<GossipHandler as ProtocolsHandler>::Error),
+    RPC(<RPCHandler<TSpec> as ProtocolsHandler>::Error),
+    Identify(<IdentifyHandler as ProtocolsHandler>::Error),
+}
+
+impl<TSpec: EthSpec> std::error::Error for DelegateError<TSpec> {}
+
+impl<TSpec: EthSpec> std::fmt::Display for DelegateError<TSpec> {
+    fn fmt(
+        &self,
+        formater: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
+        match self {
+            DelegateError::Gossipsub(err) => err.fmt(formater),
+            DelegateError::RPC(err) => err.fmt(formater),
+            DelegateError::Identify(err) => err.fmt(formater),
+        }
+    }
+}
+
+pub type DelegateInProto<TSpec> = SelectUpgrade<
+    <GossipHandler as ProtocolsHandler>::InboundProtocol,
+    SelectUpgrade<
+        <RPCHandler<TSpec> as ProtocolsHandler>::InboundProtocol,
+        <IdentifyHandler as ProtocolsHandler>::InboundProtocol,
+    >,
+>;
+
+pub type DelegateOutProto<TSpec> = EitherUpgrade<
+    <GossipHandler as ProtocolsHandler>::OutboundProtocol,
+    EitherUpgrade<
+        <RPCHandler<TSpec> as ProtocolsHandler>::OutboundProtocol,
+        <IdentifyHandler as ProtocolsHandler>::OutboundProtocol,
+    >,
+>;
+
+// TODO: prob make this an enum
+pub type DelegateOutInfo<TSpec> = EitherOutput<
+    <GossipHandler as ProtocolsHandler>::OutboundOpenInfo,
+    EitherOutput<
+        <RPCHandler<TSpec> as ProtocolsHandler>::OutboundOpenInfo,
+        <IdentifyHandler as ProtocolsHandler>::OutboundOpenInfo,
+    >,
+>;
+
+impl<TSpec: EthSpec> ProtocolsHandler for DelegatingHandler<TSpec> {
+    type InEvent = DelegateIn<TSpec>;
+    type OutEvent = DelegateOut<TSpec>;
+    type Error = DelegateError<TSpec>;
+    type InboundProtocol = DelegateInProto<TSpec>;
+    type OutboundProtocol = DelegateOutProto<TSpec>;
+    type OutboundOpenInfo = DelegateOutInfo<TSpec>;
+
+    fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol> {
+        let gossip_proto = self.gossip_handler.listen_protocol();
+        let rpc_proto = self.rpc_handler.listen_protocol();
+        let identify_proto = self.identify_handler.listen_protocol();
+
+        let timeout = gossip_proto
+            .timeout()
+            .max(rpc_proto.timeout())
+            .max(identify_proto.timeout())
+            .clone();
+
+        let select = SelectUpgrade::new(
+            gossip_proto.into_upgrade().1,
+            SelectUpgrade::new(rpc_proto.into_upgrade().1, identify_proto.into_upgrade().1),
+        );
+
+        SubstreamProtocol::new(select).with_timeout(timeout)
+    }
+
+    fn inject_fully_negotiated_inbound(
+        &mut self,
+        out: <Self::InboundProtocol as InboundUpgrade<NegotiatedSubstream>>::Output,
+    ) {
+        match out {
+            // Gossipsub
+            EitherOutput::First(out) => self.gossip_handler.inject_fully_negotiated_inbound(out),
+            // RPC
+            EitherOutput::Second(EitherOutput::First(out)) => {
+                self.rpc_handler.inject_fully_negotiated_inbound(out)
+            }
+            // Identify
+            EitherOutput::Second(EitherOutput::Second(out)) => {
+                self.identify_handler.inject_fully_negotiated_inbound(out)
+            }
+        }
+    }
+
+    fn inject_fully_negotiated_outbound(
+        &mut self,
+        protocol: <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Output,
+        info: Self::OutboundOpenInfo,
+    ) {
+        match (protocol, info) {
+            // Gossipsub
+            (EitherOutput::First(protocol), EitherOutput::First(info)) => self
+                .gossip_handler
+                .inject_fully_negotiated_outbound(protocol, info),
+            // RPC
+            (
+                EitherOutput::Second(EitherOutput::First(protocol)),
+                EitherOutput::Second(EitherOutput::First(info)),
+            ) => self
+                .rpc_handler
+                .inject_fully_negotiated_outbound(protocol, info),
+            // Identify
+            (
+                EitherOutput::Second(EitherOutput::Second(protocol)),
+                EitherOutput::Second(EitherOutput::Second(info)),
+            ) => self
+                .identify_handler
+                .inject_fully_negotiated_outbound(protocol, info),
+            // Reaching here means we got a protocol and info for different behaviours
+            _ => unreachable!("output and protocol don't match"),
+        }
+    }
+
+    fn inject_event(&mut self, event: Self::InEvent) {
+        match event {
+            DelegateIn::Gossipsub(ev) => self.gossip_handler.inject_event(ev),
+            DelegateIn::RPC(ev) => self.rpc_handler.inject_event(ev),
+            DelegateIn::Identify(ev) => self.identify_handler.inject_event(ev),
+        }
+    }
+
+    fn inject_dial_upgrade_error(
+        &mut self,
+        info: Self::OutboundOpenInfo,
+        error: ProtocolsHandlerUpgrErr<
+            <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Error,
+        >,
+    ) {
+        // TODO: find how to clean up
+        match info {
+            // Gossipsub
+            EitherOutput::First(info) => match error {
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)) => {
+                    self.gossip_handler.inject_dial_upgrade_error(
+                        info,
+                        ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)),
+                    )
+                }
+                ProtocolsHandlerUpgrErr::Timer => self
+                    .gossip_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timer),
+                ProtocolsHandlerUpgrErr::Timeout => self
+                    .gossip_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timeout),
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(EitherError::A(err))) => {
+                    self.gossip_handler.inject_dial_upgrade_error(
+                        info,
+                        ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(err)),
+                    )
+                }
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(_)) => {
+                    unreachable!("info and error don't match")
+                }
+            },
+            // RPC
+            EitherOutput::Second(EitherOutput::First(info)) => match error {
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)) => {
+                    self.rpc_handler.inject_dial_upgrade_error(
+                        info,
+                        ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)),
+                    )
+                }
+                ProtocolsHandlerUpgrErr::Timer => self
+                    .rpc_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timer),
+                ProtocolsHandlerUpgrErr::Timeout => self
+                    .rpc_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timeout),
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(EitherError::B(
+                    EitherError::A(err),
+                ))) => self.rpc_handler.inject_dial_upgrade_error(
+                    info,
+                    ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(err)),
+                ),
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(_)) => {
+                    unreachable!("info and error don't match")
+                }
+            },
+            // Identify
+            EitherOutput::Second(EitherOutput::Second(info)) => match error {
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)) => {
+                    self.identify_handler.inject_dial_upgrade_error(
+                        info,
+                        ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Select(err)),
+                    )
+                }
+                ProtocolsHandlerUpgrErr::Timer => self
+                    .identify_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timer),
+                ProtocolsHandlerUpgrErr::Timeout => self
+                    .identify_handler
+                    .inject_dial_upgrade_error(info, ProtocolsHandlerUpgrErr::Timeout),
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(EitherError::B(
+                    EitherError::B(err),
+                ))) => self.identify_handler.inject_dial_upgrade_error(
+                    info,
+                    ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(err)),
+                ),
+                ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(_)) => {
+                    unreachable!("info and error don't match")
+                }
+            },
+        }
+    }
+
+    fn connection_keep_alive(&self) -> KeepAlive {
+        self.gossip_handler
+            .connection_keep_alive()
+            .max(self.rpc_handler.connection_keep_alive())
+            .max(self.identify_handler.connection_keep_alive())
+    }
+
+    fn poll(
+        &mut self,
+        cx: &mut Context,
+    ) -> Poll<
+        ProtocolsHandlerEvent<
+            Self::OutboundProtocol,
+            Self::OutboundOpenInfo,
+            Self::OutEvent,
+            Self::Error,
+        >,
+    > {
+        match self.gossip_handler.poll(cx) {
+            Poll::Ready(ProtocolsHandlerEvent::Custom(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Custom(DelegateOut::Gossipsub(event)));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::Close(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Close(DelegateError::Gossipsub(
+                    event,
+                )));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info }) => {
+                return Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
+                    protocol: protocol.map_upgrade(|u| EitherUpgrade::A(u)),
+                    info: EitherOutput::First(info),
+                });
+            }
+            Poll::Pending => (),
+        };
+
+        match self.rpc_handler.poll(cx) {
+            Poll::Ready(ProtocolsHandlerEvent::Custom(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Custom(DelegateOut::RPC(event)));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::Close(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Close(DelegateError::RPC(event)));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info }) => {
+                return Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
+                    protocol: protocol.map_upgrade(|u| EitherUpgrade::B(EitherUpgrade::A(u))),
+                    info: EitherOutput::Second(EitherOutput::First(info)),
+                });
+            }
+            Poll::Pending => (),
+        };
+
+        match self.identify_handler.poll(cx) {
+            Poll::Ready(ProtocolsHandlerEvent::Custom(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Custom(DelegateOut::Identify(event)));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::Close(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Close(DelegateError::Identify(event)));
+            }
+            Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info }) => {
+                return Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
+                    protocol: protocol.map_upgrade(|u| EitherUpgrade::B(EitherUpgrade::B(u))),
+                    info: EitherOutput::Second(EitherOutput::Second(info)),
+                });
+            }
+            Poll::Pending => (),
+        };
+
+        Poll::Pending
+    }
+}

beacon_node/eth2_libp2p/src/behaviour/handler/mod.rs

@@ -0,0 +1,139 @@
+use crate::rpc::*;
+use delegate::DelegatingHandler;
+pub(super) use delegate::{
+    DelegateError, DelegateIn, DelegateInProto, DelegateOut, DelegateOutInfo, DelegateOutProto,
+};
+use libp2p::{
+    core::upgrade::{InboundUpgrade, OutboundUpgrade},
+    gossipsub::Gossipsub,
+    identify::Identify,
+    swarm::protocols_handler::{
+        KeepAlive, ProtocolsHandlerEvent, ProtocolsHandlerUpgrErr, SubstreamProtocol,
+    },
+    swarm::{NegotiatedSubstream, ProtocolsHandler},
+};
+use std::task::{Context, Poll};
+use types::EthSpec;
+
+mod delegate;
+
+/// Handler that combines Lighthouse's Behaviours' handlers in a delegating manner.
+pub struct BehaviourHandler<TSpec: EthSpec> {
+    /// Handler combining all sub behaviour's handlers.
+    delegate: DelegatingHandler<TSpec>,
+    /// Flag indicating if the handler is shutting down.
+    shutting_down: bool,
+}
+
+impl<TSpec: EthSpec> BehaviourHandler<TSpec> {
+    pub fn new(gossipsub: &mut Gossipsub, rpc: &mut RPC<TSpec>, identify: &mut Identify) -> Self {
+        BehaviourHandler {
+            delegate: DelegatingHandler::new(gossipsub, rpc, identify),
+            shutting_down: false,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum BehaviourHandlerIn<TSpec: EthSpec> {
+    Delegate(DelegateIn<TSpec>),
+    /// Start the shutdown process.
+    Shutdown(Option<(RequestId, RPCRequest<TSpec>)>),
+}
+
+pub enum BehaviourHandlerOut<TSpec: EthSpec> {
+    Delegate(DelegateOut<TSpec>),
+    // TODO: replace custom with events to send
+    Custom,
+}
+
+impl<TSpec: EthSpec> ProtocolsHandler for BehaviourHandler<TSpec> {
+    type InEvent = BehaviourHandlerIn<TSpec>;
+    type OutEvent = BehaviourHandlerOut<TSpec>;
+    type Error = DelegateError<TSpec>;
+    type InboundProtocol = DelegateInProto<TSpec>;
+    type OutboundProtocol = DelegateOutProto<TSpec>;
+    type OutboundOpenInfo = DelegateOutInfo<TSpec>;
+
+    fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol> {
+        self.delegate.listen_protocol()
+    }
+
+    fn inject_fully_negotiated_inbound(
+        &mut self,
+        out: <Self::InboundProtocol as InboundUpgrade<NegotiatedSubstream>>::Output,
+    ) {
+        self.delegate.inject_fully_negotiated_inbound(out)
+    }
+
+    fn inject_fully_negotiated_outbound(
+        &mut self,
+        out: <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Output,
+        info: Self::OutboundOpenInfo,
+    ) {
+        self.delegate.inject_fully_negotiated_outbound(out, info)
+    }
+
+    fn inject_event(&mut self, event: Self::InEvent) {
+        match event {
+            BehaviourHandlerIn::Delegate(delegated_ev) => self.delegate.inject_event(delegated_ev),
+            /* Events comming from the behaviour */
+            BehaviourHandlerIn::Shutdown(last_message) => {
+                self.shutting_down = true;
+                self.delegate.rpc_mut().shutdown(last_message);
+            }
+        }
+    }
+
+    fn inject_dial_upgrade_error(
+        &mut self,
+        info: Self::OutboundOpenInfo,
+        err: ProtocolsHandlerUpgrErr<
+            <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Error,
+        >,
+    ) {
+        self.delegate.inject_dial_upgrade_error(info, err)
+    }
+
+    fn connection_keep_alive(&self) -> KeepAlive {
+        if self.shutting_down {
+            let rpc_keep_alive = self.delegate.rpc().connection_keep_alive();
+            let identify_keep_alive = self.delegate.identify().connection_keep_alive();
+            rpc_keep_alive.max(identify_keep_alive)
+        } else {
+            KeepAlive::Yes
+        }
+    }
+
+    fn poll(
+        &mut self,
+        cx: &mut Context,
+    ) -> Poll<
+        ProtocolsHandlerEvent<
+            Self::OutboundProtocol,
+            Self::OutboundOpenInfo,
+            Self::OutEvent,
+            Self::Error,
+        >,
+    > {
+        match self.delegate.poll(cx) {
+            Poll::Ready(ProtocolsHandlerEvent::Custom(event)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Custom(
+                    BehaviourHandlerOut::Delegate(event),
+                ))
+            }
+            Poll::Ready(ProtocolsHandlerEvent::Close(err)) => {
+                return Poll::Ready(ProtocolsHandlerEvent::Close(err))
+            }
+            Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info }) => {
+                return Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
+                    protocol,
+                    info,
+                });
+            }
+            Poll::Pending => (),
+        }
+
+        Poll::Pending
+    }
+}

beacon_node/eth2_libp2p/src/behaviour/mod.rs

@@ -0,0 +1,942 @@
+use crate::peer_manager::{PeerManager, PeerManagerEvent};
+use crate::rpc::*;
+use crate::types::{GossipEncoding, GossipKind, GossipTopic};
+use crate::Eth2Enr;
+use crate::{error, Enr, NetworkConfig, NetworkGlobals, PubsubMessage, TopicHash};
+use futures::prelude::*;
+use handler::{BehaviourHandler, BehaviourHandlerIn, BehaviourHandlerOut, DelegateIn, DelegateOut};
+use libp2p::{
+    core::{
+        connection::{ConnectedPoint, ConnectionId, ListenerId},
+        identity::Keypair,
+        Multiaddr,
+    },
+    gossipsub::{Gossipsub, GossipsubEvent, MessageId},
+    identify::{Identify, IdentifyEvent},
+    swarm::{
+        NetworkBehaviour, NetworkBehaviourAction as NBAction, NotifyHandler, PollParameters,
+        ProtocolsHandler,
+    },
+    PeerId,
+};
+use lru::LruCache;
+use slog::{crit, debug, o};
+use std::{
+    marker::PhantomData,
+    sync::Arc,
+    task::{Context, Poll},
+    time::Instant,
+};
+use types::{EnrForkId, EthSpec, SignedBeaconBlock, SubnetId};
+
+mod handler;
+
+const MAX_IDENTIFY_ADDRESSES: usize = 10;
+
+/// Builds the network behaviour that manages the core protocols of eth2.
+/// This core behaviour is managed by `Behaviour` which adds peer management to all core
+/// behaviours.
+pub struct Behaviour<TSpec: EthSpec> {
+    /// The routing pub-sub mechanism for eth2.
+    gossipsub: Gossipsub,
+    /// The Eth2 RPC specified in the wire-0 protocol.
+    eth2_rpc: RPC<TSpec>,
+    /// Keep regular connection to peers and disconnect if absent.
+    // TODO: Using id for initial interop. This will be removed by mainnet.
+    /// Provides IP addresses and peer information.
+    identify: Identify,
+    /// The peer manager that keeps track of peer's reputation and status.
+    peer_manager: PeerManager<TSpec>,
+    /// The events generated by this behaviour to be consumed in the swarm poll.
+    events: Vec<BehaviourEvent<TSpec>>,
+    /// Queue of peers to disconnect.
+    peers_to_dc: Vec<PeerId>,
+    /// The current meta data of the node, so respond to pings and get metadata
+    meta_data: MetaData<TSpec>,
+    /// A cache of recently seen gossip messages. This is used to filter out any possible
+    /// duplicates that may still be seen over gossipsub.
+    // TODO: Remove this
+    seen_gossip_messages: LruCache<MessageId, ()>,
+    /// A collections of variables accessible outside the network service.
+    network_globals: Arc<NetworkGlobals<TSpec>>,
+    /// Keeps track of the current EnrForkId for upgrading gossipsub topics.
+    // NOTE: This can be accessed via the network_globals ENR. However we keep it here for quick
+    // lookups for every gossipsub message send.
+    enr_fork_id: EnrForkId,
+    /// Logger for behaviour actions.
+    log: slog::Logger,
+}
+
+/// Calls the given function with the given args on all sub behaviours.
+macro_rules! delegate_to_behaviours {
+    ($self: ident, $fn: ident, $($arg: ident), *) => {
+        $self.gossipsub.$fn($($arg),*);
+        $self.eth2_rpc.$fn($($arg),*);
+        $self.identify.$fn($($arg),*);
+    };
+}
+
+impl<TSpec: EthSpec> NetworkBehaviour for Behaviour<TSpec> {
+    type ProtocolsHandler = BehaviourHandler<TSpec>;
+    type OutEvent = BehaviourEvent<TSpec>;
+
+    fn new_handler(&mut self) -> Self::ProtocolsHandler {
+        BehaviourHandler::new(&mut self.gossipsub, &mut self.eth2_rpc, &mut self.identify)
+    }
+
+    fn addresses_of_peer(&mut self, peer_id: &PeerId) -> Vec<Multiaddr> {
+        self.peer_manager.addresses_of_peer(peer_id)
+    }
+
+    fn inject_connected(&mut self, peer_id: &PeerId) {
+        delegate_to_behaviours!(self, inject_connected, peer_id);
+    }
+
+    fn inject_disconnected(&mut self, peer_id: &PeerId) {
+        delegate_to_behaviours!(self, inject_disconnected, peer_id);
+    }
+
+    fn inject_connection_established(
+        &mut self,
+        peer_id: &PeerId,
+        conn_id: &ConnectionId,
+        endpoint: &ConnectedPoint,
+    ) {
+        delegate_to_behaviours!(
+            self,
+            inject_connection_established,
+            peer_id,
+            conn_id,
+            endpoint
+        );
+    }
+
+    fn inject_connection_closed(
+        &mut self,
+        peer_id: &PeerId,
+        conn_id: &ConnectionId,
+        endpoint: &ConnectedPoint,
+    ) {
+        delegate_to_behaviours!(self, inject_connection_closed, peer_id, conn_id, endpoint);
+    }
+
+    fn inject_addr_reach_failure(
+        &mut self,
+        peer_id: Option<&PeerId>,
+        addr: &Multiaddr,
+        error: &dyn std::error::Error,
+    ) {
+        delegate_to_behaviours!(self, inject_addr_reach_failure, peer_id, addr, error);
+    }
+
+    fn inject_dial_failure(&mut self, peer_id: &PeerId) {
+        delegate_to_behaviours!(self, inject_dial_failure, peer_id);
+    }
+
+    fn inject_new_listen_addr(&mut self, addr: &Multiaddr) {
+        delegate_to_behaviours!(self, inject_new_listen_addr, addr);
+    }
+
+    fn inject_expired_listen_addr(&mut self, addr: &Multiaddr) {
+        delegate_to_behaviours!(self, inject_expired_listen_addr, addr);
+    }
+
+    fn inject_new_external_addr(&mut self, addr: &Multiaddr) {
+        delegate_to_behaviours!(self, inject_new_external_addr, addr);
+    }
+
+    fn inject_listener_error(&mut self, id: ListenerId, err: &(dyn std::error::Error + 'static)) {
+        delegate_to_behaviours!(self, inject_listener_error, id, err);
+    }
+    fn inject_listener_closed(&mut self, id: ListenerId, reason: Result<(), &std::io::Error>) {
+        delegate_to_behaviours!(self, inject_listener_closed, id, reason);
+    }
+
+    fn inject_event(
+        &mut self,
+        peer_id: PeerId,
+        conn_id: ConnectionId,
+        event: <Self::ProtocolsHandler as ProtocolsHandler>::OutEvent,
+    ) {
+        match event {
+            // Events comming from the handler, redirected to each behaviour
+            BehaviourHandlerOut::Delegate(delegate) => match delegate {
+                DelegateOut::Gossipsub(ev) => self.gossipsub.inject_event(peer_id, conn_id, ev),
+                DelegateOut::RPC(ev) => self.eth2_rpc.inject_event(peer_id, conn_id, ev),
+                DelegateOut::Identify(ev) => self.identify.inject_event(peer_id, conn_id, ev),
+            },
+            /* Custom events sent BY the handler */
+            BehaviourHandlerOut::Custom => {
+                // TODO: implement
+            }
+        }
+    }
+
+    fn poll(
+        &mut self,
+        cx: &mut Context,
+        poll_params: &mut impl PollParameters,
+    ) -> Poll<NBAction<<Self::ProtocolsHandler as ProtocolsHandler>::InEvent, Self::OutEvent>> {
+        // TODO: move where it's less distracting
+        macro_rules! poll_behaviour {
+            /* $behaviour:  The sub-behaviour being polled.
+             * $on_event_fn:  Function to call if we get an event from the sub-behaviour.
+             * $notify_handler_event_closure:  Closure mapping the received event type to
+             *     the one that the handler should get.
+             */
+            ($behaviour: ident, $on_event_fn: ident, $notify_handler_event_closure: expr) => {
+                loop {
+                    // poll the sub-behaviour
+                    match self.$behaviour.poll(cx, poll_params) {
+                        Poll::Ready(action) => match action {
+                            // call the designated function to handle the event from sub-behaviour
+                            NBAction::GenerateEvent(event) => self.$on_event_fn(event),
+                            NBAction::DialAddress { address } => {
+                                return Poll::Ready(NBAction::DialAddress { address })
+                            }
+                            NBAction::DialPeer { peer_id, condition } => {
+                                return Poll::Ready(NBAction::DialPeer { peer_id, condition })
+                            }
+                            NBAction::NotifyHandler {
+                                peer_id,
+                                handler,
+                                event,
+                            } => {
+                                return Poll::Ready(NBAction::NotifyHandler {
+                                    peer_id,
+                                    handler,
+                                    // call the closure mapping the received event to the needed one
+                                    // in order to notify the handler
+                                    event: BehaviourHandlerIn::Delegate(
+                                        $notify_handler_event_closure(event),
+                                    ),
+                                });
+                            }
+                            NBAction::ReportObservedAddr { address } => {
+                                return Poll::Ready(NBAction::ReportObservedAddr { address })
+                            }
+                        },
+                        Poll::Pending => break,
+                    }
+                }
+            };
+        }
+
+        poll_behaviour!(gossipsub, on_gossip_event, DelegateIn::Gossipsub);
+        poll_behaviour!(eth2_rpc, on_rpc_event, DelegateIn::RPC);
+        poll_behaviour!(identify, on_identify_event, DelegateIn::Identify);
+
+        self.custom_poll(cx)
+    }
+}
+
+/// Implements the combined behaviour for the libp2p service.
+impl<TSpec: EthSpec> Behaviour<TSpec> {
+    pub fn new(
+        local_key: &Keypair,
+        net_conf: &NetworkConfig,
+        network_globals: Arc<NetworkGlobals<TSpec>>,
+        log: &slog::Logger,
+    ) -> error::Result<Self> {
+        let local_peer_id = local_key.public().into_peer_id();
+        let behaviour_log = log.new(o!());
+
+        let identify = Identify::new(
+            "lighthouse/libp2p".into(),
+            version::version(),
+            local_key.public(),
+        );
+
+        let enr_fork_id = network_globals
+            .local_enr()
+            .eth2()
+            .expect("Local ENR must have a fork id");
+
+        let attnets = network_globals
+            .local_enr()
+            .bitfield::<TSpec>()
+            .expect("Local ENR must have subnet bitfield");
+
+        let meta_data = MetaData {
+            seq_number: 1,
+            attnets,
+        };
+
+        Ok(Behaviour {
+            eth2_rpc: RPC::new(log.clone()),
+            gossipsub: Gossipsub::new(local_peer_id, net_conf.gs_config.clone()),
+            identify,
+            peer_manager: PeerManager::new(local_key, net_conf, network_globals.clone(), log)?,
+            events: Vec::new(),
+            peers_to_dc: Vec::new(),
+            seen_gossip_messages: LruCache::new(100_000),
+            meta_data,
+            network_globals,
+            enr_fork_id,
+            log: behaviour_log,
+        })
+    }
+
+    /// Returns the local ENR of the node.
+    pub fn local_enr(&self) -> Enr {
+        self.network_globals.local_enr()
+    }
+
+    /// Obtain a reference to the gossipsub protocol.
+    pub fn gs(&self) -> &Gossipsub {
+        &self.gossipsub
+    }
+
+    /* Pubsub behaviour functions */
+
+    /// Subscribes to a gossipsub topic kind, letting the network service determine the
+    /// encoding and fork version.
+    pub fn subscribe_kind(&mut self, kind: GossipKind) -> bool {
+        let gossip_topic = GossipTopic::new(
+            kind,
+            GossipEncoding::default(),
+            self.enr_fork_id.fork_digest,
+        );
+        self.subscribe(gossip_topic)
+    }
+
+    /// Unsubscribes from a gossipsub topic kind, letting the network service determine the
+    /// encoding and fork version.
+    pub fn unsubscribe_kind(&mut self, kind: GossipKind) -> bool {
+        let gossip_topic = GossipTopic::new(
+            kind,
+            GossipEncoding::default(),
+            self.enr_fork_id.fork_digest,
+        );
+        self.unsubscribe(gossip_topic)
+    }
+
+    /// Subscribes to a specific subnet id;
+    pub fn subscribe_to_subnet(&mut self, subnet_id: SubnetId) -> bool {
+        let topic = GossipTopic::new(
+            subnet_id.into(),
+            GossipEncoding::default(),
+            self.enr_fork_id.fork_digest,
+        );
+        self.subscribe(topic)
+    }
+
+    /// Un-Subscribes from a specific subnet id;
+    pub fn unsubscribe_from_subnet(&mut self, subnet_id: SubnetId) -> bool {
+        let topic = GossipTopic::new(
+            subnet_id.into(),
+            GossipEncoding::default(),
+            self.enr_fork_id.fork_digest,
+        );
+        self.unsubscribe(topic)
+    }
+
+    /// Subscribes to a gossipsub topic.
+    fn subscribe(&mut self, topic: GossipTopic) -> bool {
+        // update the network globals
+        self.network_globals
+            .gossipsub_subscriptions
+            .write()
+            .insert(topic.clone());
+
+        let topic_str: String = topic.clone().into();
+        debug!(self.log, "Subscribed to topic"; "topic" => topic_str);
+        self.gossipsub.subscribe(topic.into())
+    }
+
+    /// Unsubscribe from a gossipsub topic.
+    fn unsubscribe(&mut self, topic: GossipTopic) -> bool {
+        // update the network globals
+        self.network_globals
+            .gossipsub_subscriptions
+            .write()
+            .remove(&topic);
+        // unsubscribe from the topic
+        self.gossipsub.unsubscribe(topic.into())
+    }
+
+    /// Publishes a list of messages on the pubsub (gossipsub) behaviour, choosing the encoding.
+    pub fn publish(&mut self, messages: Vec<PubsubMessage<TSpec>>) {
+        for message in messages {
+            for topic in message.topics(GossipEncoding::default(), self.enr_fork_id.fork_digest) {
+                match message.encode(GossipEncoding::default()) {
+                    Ok(message_data) => {
+                        self.gossipsub.publish(&topic.into(), message_data);
+                    }
+                    Err(e) => crit!(self.log, "Could not publish message"; "error" => e),
+                }
+            }
+        }
+    }
+
+    /// Forwards a message that is waiting in gossipsub's mcache. Messages are only propagated
+    /// once validated by the beacon chain.
+    pub fn propagate_message(&mut self, propagation_source: &PeerId, message_id: MessageId) {
+        self.gossipsub
+            .propagate_message(&message_id, propagation_source);
+    }
+
+    /* Eth2 RPC behaviour functions */
+
+    /// Send a request to a peer over RPC.
+    pub fn send_request(&mut self, peer_id: PeerId, request_id: RequestId, request: Request) {
+        self.eth2_rpc
+            .send_request(peer_id, request_id, request.into())
+    }
+
+    /// Send a successful response to a peer over RPC.
+    pub fn send_successful_response(
+        &mut self,
+        peer_id: PeerId,
+        id: PeerRequestId,
+        response: Response<TSpec>,
+    ) {
+        self.eth2_rpc.send_response(peer_id, id, response.into())
+    }
+
+    /// Inform the peer that their request produced an error.
+    pub fn _send_error_reponse(
+        &mut self,
+        peer_id: PeerId,
+        id: PeerRequestId,
+        error: RPCResponseErrorCode,
+        reason: String,
+    ) {
+        self.eth2_rpc.send_response(
+            peer_id,
+            id,
+            RPCCodedResponse::from_error_code(error, reason),
+        )
+    }
+
+    /* Peer management functions */
+
+    /// Notify discovery that the peer has been banned.
+    // TODO: Remove this and integrate all disconnection/banning logic inside the peer manager.
+    pub fn peer_banned(&mut self, _peer_id: PeerId) {}
+
+    /// Notify discovery that the peer has been unbanned.
+    // TODO: Remove this and integrate all disconnection/banning logic inside the peer manager.
+    pub fn peer_unbanned(&mut self, _peer_id: &PeerId) {}
+
+    /// Returns an iterator over all enr entries in the DHT.
+    pub fn enr_entries(&mut self) -> Vec<Enr> {
+        self.peer_manager.discovery_mut().table_entries_enr()
+    }
+
+    /// Add an ENR to the routing table of the discovery mechanism.
+    pub fn add_enr(&mut self, enr: Enr) {
+        self.peer_manager.discovery_mut().add_enr(enr);
+    }
+
+    /// Updates a subnet value to the ENR bitfield.
+    ///
+    /// The `value` is `true` if a subnet is being added and false otherwise.
+    pub fn update_enr_subnet(&mut self, subnet_id: SubnetId, value: bool) {
+        if let Err(e) = self
+            .peer_manager
+            .discovery_mut()
+            .update_enr_bitfield(subnet_id, value)
+        {
+            crit!(self.log, "Could not update ENR bitfield"; "error" => e);
+        }
+        // update the local meta data which informs our peers of the update during PINGS
+        self.update_metadata();
+    }
+
+    /// Attempts to discover new peers for a given subnet. The `min_ttl` gives the time at which we
+    /// would like to retain the peers for.
+    pub fn discover_subnet_peers(&mut self, subnet_id: SubnetId, min_ttl: Option<Instant>) {
+        self.peer_manager.discover_subnet_peers(subnet_id, min_ttl)
+    }
+
+    /// Updates the local ENR's "eth2" field with the latest EnrForkId.
+    pub fn update_fork_version(&mut self, enr_fork_id: EnrForkId) {
+        self.peer_manager
+            .discovery_mut()
+            .update_eth2_enr(enr_fork_id.clone());
+
+        // unsubscribe from all gossip topics and re-subscribe to their new fork counterparts
+        let subscribed_topics = self
+            .network_globals
+            .gossipsub_subscriptions
+            .read()
+            .iter()
+            .cloned()
+            .collect::<Vec<GossipTopic>>();
+
+        //  unsubscribe from all topics
+        for topic in &subscribed_topics {
+            self.unsubscribe(topic.clone());
+        }
+
+        // re-subscribe modifying the fork version
+        for mut topic in subscribed_topics {
+            *topic.digest() = enr_fork_id.fork_digest;
+            self.subscribe(topic);
+        }
+
+        // update the local reference
+        self.enr_fork_id = enr_fork_id;
+    }
+
+    /* Private internal functions */
+
+    /// Updates the current meta data of the node to match the local ENR.
+    fn update_metadata(&mut self) {
+        self.meta_data.seq_number += 1;
+        self.meta_data.attnets = self
+            .peer_manager
+            .discovery()
+            .local_enr()
+            .bitfield::<TSpec>()
+            .expect("Local discovery must have bitfield");
+    }
+
+    /// Sends a Ping request to the peer.
+    fn ping(&mut self, id: RequestId, peer_id: PeerId) {
+        let ping = crate::rpc::Ping {
+            data: self.meta_data.seq_number,
+        };
+        debug!(self.log, "Sending Ping"; "request_id" => id, "peer_id" => peer_id.to_string());
+
+        self.eth2_rpc
+            .send_request(peer_id, id, RPCRequest::Ping(ping));
+    }
+
+    /// Sends a Pong response to the peer.
+    fn pong(&mut self, id: PeerRequestId, peer_id: PeerId) {
+        let ping = crate::rpc::Ping {
+            data: self.meta_data.seq_number,
+        };
+        debug!(self.log, "Sending Pong"; "request_id" => id.1, "peer_id" => peer_id.to_string());
+        let event = RPCCodedResponse::Success(RPCResponse::Pong(ping));
+        self.eth2_rpc.send_response(peer_id, id, event);
+    }
+
+    /// Sends a METADATA request to a peer.
+    fn send_meta_data_request(&mut self, peer_id: PeerId) {
+        let event = RPCRequest::MetaData(PhantomData);
+        self.eth2_rpc
+            .send_request(peer_id, RequestId::Behaviour, event);
+    }
+
+    /// Sends a METADATA response to a peer.
+    fn send_meta_data_response(&mut self, id: PeerRequestId, peer_id: PeerId) {
+        let event = RPCCodedResponse::Success(RPCResponse::MetaData(self.meta_data.clone()));
+        self.eth2_rpc.send_response(peer_id, id, event);
+    }
+
+    /// Returns a reference to the peer manager to allow the swarm to notify the manager of peer
+    /// status
+    pub fn peer_manager(&mut self) -> &mut PeerManager<TSpec> {
+        &mut self.peer_manager
+    }
+
+    /* Address in the new behaviour. Connections are now maintained at the swarm level.
+    /// Notifies the behaviour that a peer has connected.
+    pub fn notify_peer_connect(&mut self, peer_id: PeerId, endpoint: ConnectedPoint) {
+        match endpoint {
+            ConnectedPoint::Dialer { .. } => self.peer_manager.connect_outgoing(&peer_id),
+            ConnectedPoint::Listener { .. } => self.peer_manager.connect_ingoing(&peer_id),
+        };
+
+        // Find ENR info about a peer if possible.
+        if let Some(enr) = self.discovery.enr_of_peer(&peer_id) {
+            let bitfield = match enr.bitfield::<TSpec>() {
+                Ok(v) => v,
+                Err(e) => {
+                    warn!(self.log, "Peer has invalid ENR bitfield";
+                                        "peer_id" => format!("{}", peer_id),
+                                        "error" => format!("{:?}", e));
+                    return;
+                }
+            };
+
+            // use this as a baseline, until we get the actual meta-data
+            let meta_data = MetaData {
+                seq_number: 0,
+                attnets: bitfield,
+            };
+            // TODO: Shift to the peer manager
+            self.network_globals
+                .peers
+                .write()
+                .add_metadata(&peer_id, meta_data);
+        }
+    }
+    */
+
+    fn on_gossip_event(&mut self, event: GossipsubEvent) {
+        match event {
+            GossipsubEvent::Message(propagation_source, id, gs_msg) => {
+                // Note: We are keeping track here of the peer that sent us the message, not the
+                // peer that originally published the message.
+                if self.seen_gossip_messages.put(id.clone(), ()).is_none() {
+                    match PubsubMessage::decode(&gs_msg.topics, &gs_msg.data) {
+                        Err(e) => {
+                            debug!(self.log, "Could not decode gossipsub message"; "error" => format!("{}", e))
+                        }
+                        Ok(msg) => {
+                            // if this message isn't a duplicate, notify the network
+                            self.events.push(BehaviourEvent::PubsubMessage {
+                                id,
+                                source: propagation_source,
+                                topics: gs_msg.topics,
+                                message: msg,
+                            });
+                        }
+                    }
+                } else {
+                    match PubsubMessage::<TSpec>::decode(&gs_msg.topics, &gs_msg.data) {
+                        Err(e) => {
+                            debug!(self.log, "Could not decode gossipsub message"; "error" => format!("{}", e))
+                        }
+                        Ok(msg) => {
+                            debug!(self.log, "A duplicate gossipsub message was received"; "message_source" => format!("{}", gs_msg.source), "propagated_peer" => format!("{}",propagation_source), "message" => format!("{}", msg));
+                        }
+                    }
+                }
+            }
+            GossipsubEvent::Subscribed { peer_id, topic } => {
+                self.events
+                    .push(BehaviourEvent::PeerSubscribed(peer_id, topic));
+            }
+            GossipsubEvent::Unsubscribed { .. } => {}
+        }
+    }
+
+    /// Queues the response to be sent upwards as long at it was requested outside the Behaviour.
+    fn propagate_response(&mut self, id: RequestId, peer_id: PeerId, response: Response<TSpec>) {
+        if !matches!(id, RequestId::Behaviour) {
+            self.events.push(BehaviourEvent::ResponseReceived {
+                peer_id,
+                id,
+                response,
+            });
+        }
+    }
+
+    /// Convenience function to propagate a request.
+    fn propagate_request(&mut self, id: PeerRequestId, peer_id: PeerId, request: Request) {
+        self.events.push(BehaviourEvent::RequestReceived {
+            peer_id,
+            id,
+            request,
+        });
+    }
+
+    fn on_rpc_event(&mut self, message: RPCMessage<TSpec>) {
+        let peer_id = message.peer_id;
+        let handler_id = message.conn_id;
+        // The METADATA and PING RPC responses are handled within the behaviour and not propagated
+        match message.event {
+            Err(handler_err) => {
+                match handler_err {
+                    HandlerErr::Inbound {
+                        id: _,
+                        proto,
+                        error,
+                    } => {
+                        if matches!(error, RPCError::HandlerRejected) {
+                            // this peer's request got canceled
+                            // TODO: cancel processing for this request
+                        }
+                        // Inform the peer manager of the error.
+                        // An inbound error here means we sent an error to the peer, or the stream
+                        // timed out.
+                        self.peer_manager.handle_rpc_error(&peer_id, proto, &error);
+                    }
+                    HandlerErr::Outbound { id, proto, error } => {
+                        // Inform the peer manager that a request we sent to the peer failed
+                        self.peer_manager.handle_rpc_error(&peer_id, proto, &error);
+                        // inform failures of requests comming outside the behaviour
+                        if !matches!(id, RequestId::Behaviour) {
+                            self.events
+                                .push(BehaviourEvent::RPCFailed { peer_id, id, error });
+                        }
+                    }
+                }
+            }
+            Ok(RPCReceived::Request(id, request)) => {
+                let peer_request_id = (handler_id, id);
+                match request {
+                    /* Behaviour managed protocols: Ping and Metadata */
+                    RPCRequest::Ping(ping) => {
+                        // inform the peer manager and send the response
+                        self.peer_manager.ping_request(&peer_id, ping.data);
+                        // send a ping response
+                        self.pong(peer_request_id, peer_id);
+                    }
+                    RPCRequest::MetaData(_) => {
+                        // send the requested meta-data
+                        self.send_meta_data_response((handler_id, id), peer_id);
+                        // TODO: inform the peer manager?
+                    }
+                    RPCRequest::Goodbye(reason) => {
+                        // let the peer manager know this peer is in the process of disconnecting
+                        self.peer_manager._disconnecting_peer(&peer_id);
+                        // queue for disconnection without a goodbye message
+                        debug!(self.log, "Received a Goodbye, queueing for disconnection";
+                            "peer_id" => peer_id.to_string());
+                        self.peers_to_dc.push(peer_id.clone());
+                        // TODO: do not propagate
+                        self.propagate_request(peer_request_id, peer_id, Request::Goodbye(reason));
+                    }
+                    /* Protocols propagated to the Network */
+                    RPCRequest::Status(msg) => {
+                        // inform the peer manager that we have received a status from a peer
+                        self.peer_manager.peer_statusd(&peer_id);
+                        // propagate the STATUS message upwards
+                        self.propagate_request(peer_request_id, peer_id, Request::Status(msg))
+                    }
+                    RPCRequest::BlocksByRange(req) => self.propagate_request(
+                        peer_request_id,
+                        peer_id,
+                        Request::BlocksByRange(req),
+                    ),
+                    RPCRequest::BlocksByRoot(req) => {
+                        self.propagate_request(peer_request_id, peer_id, Request::BlocksByRoot(req))
+                    }
+                }
+            }
+            Ok(RPCReceived::Response(id, resp)) => {
+                match resp {
+                    /* Behaviour managed protocols */
+                    RPCResponse::Pong(ping) => self.peer_manager.pong_response(&peer_id, ping.data),
+                    RPCResponse::MetaData(meta_data) => {
+                        self.peer_manager.meta_data_response(&peer_id, meta_data)
+                    }
+                    /* Network propagated protocols */
+                    RPCResponse::Status(msg) => {
+                        // inform the peer manager that we have received a status from a peer
+                        self.peer_manager.peer_statusd(&peer_id);
+                        // propagate the STATUS message upwards
+                        self.propagate_response(id, peer_id, Response::Status(msg));
+                    }
+                    RPCResponse::BlocksByRange(resp) => {
+                        self.propagate_response(id, peer_id, Response::BlocksByRange(Some(resp)))
+                    }
+                    RPCResponse::BlocksByRoot(resp) => {
+                        self.propagate_response(id, peer_id, Response::BlocksByRoot(Some(resp)))
+                    }
+                }
+            }
+            Ok(RPCReceived::EndOfStream(id, termination)) => {
+                let response = match termination {
+                    ResponseTermination::BlocksByRange => Response::BlocksByRange(None),
+                    ResponseTermination::BlocksByRoot => Response::BlocksByRoot(None),
+                };
+                self.propagate_response(id, peer_id, response);
+            }
+        }
+    }
+
+    /// Consumes the events list when polled.
+    fn custom_poll(
+        &mut self,
+        cx: &mut Context,
+    ) -> Poll<NBAction<BehaviourHandlerIn<TSpec>, BehaviourEvent<TSpec>>> {
+        // handle pending disconnections to perform
+        if !self.peers_to_dc.is_empty() {
+            return Poll::Ready(NBAction::NotifyHandler {
+                peer_id: self.peers_to_dc.remove(0),
+                handler: NotifyHandler::All,
+                event: BehaviourHandlerIn::Shutdown(None),
+            });
+        }
+
+        // check the peer manager for events
+        loop {
+            match self.peer_manager.poll_next_unpin(cx) {
+                Poll::Ready(Some(event)) => match event {
+                    PeerManagerEvent::Dial(peer_id) => {
+                        return Poll::Ready(NBAction::DialPeer {
+                            peer_id,
+                            condition: libp2p::swarm::DialPeerCondition::Disconnected,
+                        });
+                    }
+                    PeerManagerEvent::SocketUpdated(address) => {
+                        return Poll::Ready(NBAction::ReportObservedAddr { address });
+                    }
+                    PeerManagerEvent::Status(peer_id) => {
+                        // it's time to status. We don't keep a beacon chain reference here, so we inform
+                        // the network to send a status to this peer
+                        return Poll::Ready(NBAction::GenerateEvent(BehaviourEvent::StatusPeer(
+                            peer_id,
+                        )));
+                    }
+                    PeerManagerEvent::Ping(peer_id) => {
+                        // send a ping request to this peer
+                        self.ping(RequestId::Behaviour, peer_id);
+                    }
+                    PeerManagerEvent::MetaData(peer_id) => {
+                        self.send_meta_data_request(peer_id);
+                    }
+                    PeerManagerEvent::DisconnectPeer(peer_id) => {
+                        debug!(self.log, "PeerManager requested to disconnect a peer";
+                            "peer_id" => peer_id.to_string());
+                        // queue for disabling
+                        self.peers_to_dc.push(peer_id.clone());
+                        // send one goodbye
+                        return Poll::Ready(NBAction::NotifyHandler {
+                            peer_id,
+                            handler: NotifyHandler::Any,
+                            event: BehaviourHandlerIn::Shutdown(Some((
+                                RequestId::Behaviour,
+                                RPCRequest::Goodbye(GoodbyeReason::Fault),
+                            ))),
+                        });
+                    }
+                },
+                Poll::Pending => break,
+                Poll::Ready(None) => break, // peer manager ended
+            }
+        }
+
+        if !self.events.is_empty() {
+            return Poll::Ready(NBAction::GenerateEvent(self.events.remove(0)));
+        }
+
+        Poll::Pending
+    }
+
+    fn on_identify_event(&mut self, event: IdentifyEvent) {
+        match event {
+            IdentifyEvent::Received {
+                peer_id,
+                mut info,
+                observed_addr,
+            } => {
+                if info.listen_addrs.len() > MAX_IDENTIFY_ADDRESSES {
+                    debug!(
+                        self.log,
+                        "More than 10 addresses have been identified, truncating"
+                    );
+                    info.listen_addrs.truncate(MAX_IDENTIFY_ADDRESSES);
+                }
+                // send peer info to the peer manager.
+                self.peer_manager.identify(&peer_id, &info);
+
+                debug!(self.log, "Identified Peer"; "peer" => format!("{}", peer_id),
+                "protocol_version" => info.protocol_version,
+                "agent_version" => info.agent_version,
+                "listening_ addresses" => format!("{:?}", info.listen_addrs),
+                "observed_address" => format!("{:?}", observed_addr),
+                "protocols" => format!("{:?}", info.protocols)
+                );
+            }
+            IdentifyEvent::Sent { .. } => {}
+            IdentifyEvent::Error { .. } => {}
+        }
+    }
+}
+
+/* Public API types */
+
+/// The type of RPC requests the Behaviour informs it has received and allows for sending.
+///
+// NOTE: This is an application-level wrapper over the lower network leve requests that can be
+//       sent. The main difference is the absense of the Ping and Metadata protocols, which don't
+//       leave the Behaviour. For all protocols managed by RPC see `RPCRequest`.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Request {
+    /// A Status message.
+    Status(StatusMessage),
+    /// A Goobye message.
+    Goodbye(GoodbyeReason),
+    /// A blocks by range request.
+    BlocksByRange(BlocksByRangeRequest),
+    /// A request blocks root request.
+    BlocksByRoot(BlocksByRootRequest),
+}
+
+impl<TSpec: EthSpec> std::convert::From<Request> for RPCRequest<TSpec> {
+    fn from(req: Request) -> RPCRequest<TSpec> {
+        match req {
+            Request::BlocksByRoot(r) => RPCRequest::BlocksByRoot(r),
+            Request::BlocksByRange(r) => RPCRequest::BlocksByRange(r),
+            Request::Goodbye(r) => RPCRequest::Goodbye(r),
+            Request::Status(s) => RPCRequest::Status(s),
+        }
+    }
+}
+
+/// The type of RPC responses the Behaviour informs it has received, and allows for sending.
+///
+// NOTE: This is an application-level wrapper over the lower network level responses that can be
+//       sent. The main difference is the absense of Pong and Metadata, which don't leave the
+//       Behaviour. For all protocol reponses managed by RPC see `RPCResponse` and
+//       `RPCCodedResponse`.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Response<TSpec: EthSpec> {
+    /// A Status message.
+    Status(StatusMessage),
+    /// A response to a get BLOCKS_BY_RANGE request. A None response signals the end of the batch.
+    BlocksByRange(Option<Box<SignedBeaconBlock<TSpec>>>),
+    /// A response to a get BLOCKS_BY_ROOT request.
+    BlocksByRoot(Option<Box<SignedBeaconBlock<TSpec>>>),
+}
+
+impl<TSpec: EthSpec> std::convert::From<Response<TSpec>> for RPCCodedResponse<TSpec> {
+    fn from(resp: Response<TSpec>) -> RPCCodedResponse<TSpec> {
+        match resp {
+            Response::BlocksByRoot(r) => match r {
+                Some(b) => RPCCodedResponse::Success(RPCResponse::BlocksByRoot(b)),
+                None => RPCCodedResponse::StreamTermination(ResponseTermination::BlocksByRoot),
+            },
+            Response::BlocksByRange(r) => match r {
+                Some(b) => RPCCodedResponse::Success(RPCResponse::BlocksByRange(b)),
+                None => RPCCodedResponse::StreamTermination(ResponseTermination::BlocksByRange),
+            },
+            Response::Status(s) => RPCCodedResponse::Success(RPCResponse::Status(s)),
+        }
+    }
+}
+
+/// Identifier of requests sent by a peer.
+pub type PeerRequestId = (ConnectionId, SubstreamId);
+
+/// The types of events than can be obtained from polling the behaviour.
+#[derive(Debug)]
+pub enum BehaviourEvent<TSpec: EthSpec> {
+    /// An RPC Request that was sent failed.
+    RPCFailed {
+        /// The id of the failed request.
+        id: RequestId,
+        /// The peer to which this request was sent.
+        peer_id: PeerId,
+        /// The error that occurred.
+        error: RPCError,
+    },
+    RequestReceived {
+        /// The peer that sent the request.
+        peer_id: PeerId,
+        /// Identifier of the request. All responses to this request must use this id.
+        id: PeerRequestId,
+        /// Request the peer sent.
+        request: Request,
+    },
+    ResponseReceived {
+        /// Peer that sent the response.
+        peer_id: PeerId,
+        /// Id of the request to which the peer is responding.
+        id: RequestId,
+        /// Response the peer sent.
+        response: Response<TSpec>,
+    },
+    PubsubMessage {
+        /// The gossipsub message id. Used when propagating blocks after validation.
+        id: MessageId,
+        /// The peer from which we received this message, not the peer that published it.
+        source: PeerId,
+        /// The topics that this message was sent on.
+        topics: Vec<TopicHash>,
+        /// The message itself.
+        message: PubsubMessage<TSpec>,
+    },
+    /// Subscribed to peer for given topic
+    PeerSubscribed(PeerId, TopicHash),
+    /// Inform the network to send a Status to this peer.
+    StatusPeer(PeerId),
+}

beacon_node/eth2_libp2p/src/config.rs

@@ -0,0 +1,131 @@
+use crate::types::GossipKind;
+use crate::Enr;
+use discv5::{Discv5Config, Discv5ConfigBuilder};
+use libp2p::gossipsub::{GossipsubConfig, GossipsubConfigBuilder, GossipsubMessage, MessageId};
+use libp2p::Multiaddr;
+use serde_derive::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::path::PathBuf;
+use std::time::Duration;
+
+pub const GOSSIP_MAX_SIZE: usize = 1_048_576;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(default)]
+/// Network configuration for lighthouse.
+pub struct Config {
+    /// Data directory where node's keyfile is stored
+    pub network_dir: PathBuf,
+
+    /// IP address to listen on.
+    pub listen_address: std::net::IpAddr,
+
+    /// The TCP port that libp2p listens on.
+    pub libp2p_port: u16,
+
+    /// UDP port that discovery listens on.
+    pub discovery_port: u16,
+
+    /// The address to broadcast to peers about which address we are listening on. None indicates
+    /// that no discovery address has been set in the CLI args.
+    pub enr_address: Option<std::net::IpAddr>,
+
+    /// The udp port to broadcast to peers in order to reach back for discovery.
+    pub enr_udp_port: Option<u16>,
+
+    /// The tcp port to broadcast to peers in order to reach back for libp2p services.
+    pub enr_tcp_port: Option<u16>,
+
+    /// Target number of connected peers.
+    pub max_peers: usize,
+
+    /// Gossipsub configuration parameters.
+    #[serde(skip)]
+    pub gs_config: GossipsubConfig,
+
+    /// Discv5 configuration parameters.
+    #[serde(skip)]
+    pub discv5_config: Discv5Config,
+
+    /// List of nodes to initially connect to.
+    pub boot_nodes: Vec<Enr>,
+
+    /// List of libp2p nodes to initially connect to.
+    pub libp2p_nodes: Vec<Multiaddr>,
+
+    /// Client version
+    pub client_version: String,
+
+    /// List of extra topics to initially subscribe to as strings.
+    pub topics: Vec<GossipKind>,
+}
+
+impl Default for Config {
+    /// Generate a default network configuration.
+    fn default() -> Self {
+        let mut network_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
+        network_dir.push(".lighthouse");
+        network_dir.push("network");
+
+        // The default topics that we will initially subscribe to
+        let topics = vec![
+            GossipKind::BeaconBlock,
+            GossipKind::BeaconAggregateAndProof,
+            GossipKind::VoluntaryExit,
+            GossipKind::ProposerSlashing,
+            GossipKind::AttesterSlashing,
+        ];
+
+        // The function used to generate a gossipsub message id
+        // We use base64(SHA256(data)) for content addressing
+        let gossip_message_id = |message: &GossipsubMessage| {
+            MessageId(base64::encode_config(
+                &Sha256::digest(&message.data),
+                base64::URL_SAFE_NO_PAD,
+            ))
+        };
+
+        // gossipsub configuration
+        // Note: The topics by default are sent as plain strings. Hashes are an optional
+        // parameter.
+        let gs_config = GossipsubConfigBuilder::new()
+            .max_transmit_size(GOSSIP_MAX_SIZE)
+            .heartbeat_interval(Duration::from_secs(1))
+            .manual_propagation() // require validation before propagation
+            .no_source_id()
+            .message_id_fn(gossip_message_id)
+            .build();
+
+        // discv5 configuration
+        let discv5_config = Discv5ConfigBuilder::new()
+            .enable_packet_filter()
+            .session_cache_capacity(1000)
+            .request_timeout(Duration::from_secs(4))
+            .request_retries(2)
+            .enr_peer_update_min(2) // prevents NAT's should be raised for mainnet
+            .query_parallelism(5)
+            .query_timeout(Duration::from_secs(60))
+            .query_peer_timeout(Duration::from_secs(2))
+            .ip_limit() // limits /24 IP's in buckets.
+            .ping_interval(Duration::from_secs(300))
+            .build();
+
+        // NOTE: Some of these get overridden by the corresponding CLI default values.
+        Config {
+            network_dir,
+            listen_address: "0.0.0.0".parse().expect("valid ip address"),
+            libp2p_port: 9000,
+            discovery_port: 9000,
+            enr_address: None,
+            enr_udp_port: None,
+            enr_tcp_port: None,
+            max_peers: 50,
+            gs_config,
+            discv5_config,
+            boot_nodes: vec![],
+            libp2p_nodes: vec![],
+            client_version: version::version(),
+            topics,
+        }
+    }
+}

beacon_node/eth2_libp2p/src/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/discovery/enr_ext.rs

@@ -0,0 +1,255 @@
+//! 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>;
+
+    /// Returns the multiaddr with the `PeerId` prepended.
+    fn multiaddr_p2p(&self) -> Vec<Multiaddr>;
+
+    /// Returns any multiaddrs that contain the TCP protocol.
+    fn multiaddr_tcp(&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.
+    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
+    }
+
+    /// 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.
+    ///
+    /// This also prepends the `PeerId` into each multiaddr with the `P2p` protocol.
+    fn multiaddr_p2p(&self) -> Vec<Multiaddr> {
+        let peer_id = self.peer_id();
+        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));
+                multiaddr.push(Protocol::P2p(peer_id.clone().into()));
+                multiaddrs.push(multiaddr);
+            }
+
+            if let Some(tcp) = self.tcp() {
+                let mut multiaddr: Multiaddr = ip.into();
+                multiaddr.push(Protocol::Tcp(tcp));
+                multiaddr.push(Protocol::P2p(peer_id.clone().into()));
+                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));
+                multiaddr.push(Protocol::P2p(peer_id.clone().into()));
+                multiaddrs.push(multiaddr);
+            }
+
+            if let Some(tcp6) = self.tcp6() {
+                let mut multiaddr: Multiaddr = ip6.into();
+                multiaddr.push(Protocol::Tcp(tcp6));
+                multiaddr.push(Protocol::P2p(peer_id.into()));
+                multiaddrs.push(multiaddr);
+            }
+        }
+        multiaddrs
+    }
+
+    /// 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_tcp(&self) -> Vec<Multiaddr> {
+        let mut multiaddrs: Vec<Multiaddr> = Vec::new();
+        if let Some(ip) = self.ip() {
+            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(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/discovery/mod.rs

@@ -0,0 +1,637 @@
+///! 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 futures::stream::FuturesUnordered;
+use libp2p::core::PeerId;
+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| {
+                debug!(
+                    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 we are in the process of a query, don't bother queuing a new one.
+        if self.find_peer_active {
+            return;
+        }
+        // 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
+            }
+        }
+        // Update the queue metric
+        metrics::set_gauge(&metrics::DISCOVERY_QUEUE, self.queued_queries.len() as i64);
+    }
+
+    // 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/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/lib.rs

@@ -0,0 +1,27 @@
+/// This crate contains the main link for lighthouse to rust-libp2p. It therefore re-exports
+/// all required libp2p functionality.
+///
+/// This crate builds and manages the libp2p services required by the beacon node.
+#[macro_use]
+extern crate lazy_static;
+
+pub mod behaviour;
+mod config;
+pub mod discovery;
+mod metrics;
+mod peer_manager;
+pub mod rpc;
+mod service;
+pub mod types;
+
+pub use crate::types::{error, Enr, GossipTopic, NetworkGlobals, PubsubMessage};
+pub use behaviour::{BehaviourEvent, PeerRequestId, Request, Response};
+pub use config::Config as NetworkConfig;
+pub use discovery::{CombinedKeyExt, EnrExt, Eth2Enr};
+pub use discv5;
+pub use libp2p::gossipsub::{MessageId, Topic, TopicHash};
+pub use libp2p::{core::ConnectedPoint, PeerId, Swarm};
+pub use libp2p::{multiaddr, Multiaddr};
+pub use metrics::scrape_discovery_metrics;
+pub use peer_manager::{client::Client, PeerDB, PeerInfo, PeerSyncStatus, SyncInfo};
+pub use service::{Libp2pEvent, Service, NETWORK_KEY_FILENAME};

beacon_node/eth2_libp2p/src/metrics.rs

@@ -0,0 +1,59 @@
+pub use lighthouse_metrics::*;
+
+lazy_static! {
+    pub static ref ADDRESS_UPDATE_COUNT: Result<IntCounter> = try_create_int_counter(
+        "libp2p_address_update_total",
+        "Count of libp2p socked updated events (when our view of our IP address has changed)"
+    );
+    pub static ref PEERS_CONNECTED: Result<IntGauge> = try_create_int_gauge(
+        "libp2p_peer_connected_peers_total",
+        "Count of libp2p peers currently connected"
+    );
+    pub static ref PEER_CONNECT_EVENT_COUNT: Result<IntCounter> = try_create_int_counter(
+        "libp2p_peer_connect_event_total",
+        "Count of libp2p peer connect events (not the current number of connected peers)"
+    );
+    pub static ref PEER_DISCONNECT_EVENT_COUNT: Result<IntCounter> = try_create_int_counter(
+        "libp2p_peer_disconnect_event_total",
+        "Count of libp2p peer disconnect events"
+    );
+    pub static ref DISCOVERY_QUEUE: Result<IntGauge> = try_create_int_gauge(
+        "discovery_queue_size",
+        "The number of discovery queries awaiting execution"
+    );
+    pub static ref DISCOVERY_REQS: Result<Gauge> = try_create_float_gauge(
+        "discovery_requests",
+        "The number of unsolicited discovery requests per second"
+    );
+    pub static ref DISCOVERY_SESSIONS: Result<IntGauge> = try_create_int_gauge(
+        "discovery_sessions",
+        "The number of active discovery sessions with peers"
+    );
+    pub static ref DISCOVERY_REQS_IP: Result<GaugeVec> = try_create_float_gauge_vec(
+        "discovery_reqs_per_ip",
+        "Unsolicited discovery requests per ip per second",
+        &["Addresses"]
+    );
+}
+
+pub fn scrape_discovery_metrics() {
+    let metrics = discv5::metrics::Metrics::from(discv5::Discv5::raw_metrics());
+
+    set_float_gauge(&DISCOVERY_REQS, metrics.unsolicited_requests_per_second);
+
+    set_gauge(&DISCOVERY_SESSIONS, metrics.active_sessions as i64);
+
+    let process_gauge_vec = |gauge: &Result<GaugeVec>, metrics: discv5::metrics::Metrics| {
+        if let Ok(gauge_vec) = gauge {
+            gauge_vec.reset();
+            for (ip, value) in metrics.requests_per_ip_per_second.iter() {
+                if let Ok(metric) = gauge_vec.get_metric_with_label_values(&[&format!("{:?}", ip)])
+                {
+                    metric.set(*value);
+                }
+            }
+        }
+    };
+
+    process_gauge_vec(&DISCOVERY_REQS_IP, metrics);
+}

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/mod.rs

@@ -0,0 +1,675 @@
+//! Implementation of a Lighthouse's peer management system.
+
+pub use self::peerdb::*;
+use crate::discovery::{Discovery, DiscoveryEvent};
+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;
+mod peer_info;
+mod peer_sync_status;
+mod peerdb;
+
+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());
+    }
+}

beacon_node/eth2_libp2p/src/rpc/codec/base.rs

@@ -0,0 +1,217 @@
+//! This handles the various supported encoding mechanism for the Eth 2.0 RPC.
+
+use crate::rpc::{RPCCodedResponse, RPCRequest, RPCResponse};
+use libp2p::bytes::BufMut;
+use libp2p::bytes::BytesMut;
+use std::marker::PhantomData;
+use tokio_util::codec::{Decoder, Encoder};
+use types::EthSpec;
+
+pub trait OutboundCodec<TItem>: Encoder<TItem> + Decoder {
+    type ErrorType;
+
+    fn decode_error(
+        &mut self,
+        src: &mut BytesMut,
+    ) -> Result<Option<Self::ErrorType>, <Self as Decoder>::Error>;
+}
+
+/* Global Inbound Codec */
+// This deals with Decoding RPC Requests from other peers and encoding our responses
+
+pub struct BaseInboundCodec<TCodec, TSpec>
+where
+    TCodec: Encoder<RPCCodedResponse<TSpec>> + Decoder,
+    TSpec: EthSpec,
+{
+    /// Inner codec for handling various encodings
+    inner: TCodec,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<TCodec, TSpec> BaseInboundCodec<TCodec, TSpec>
+where
+    TCodec: Encoder<RPCCodedResponse<TSpec>> + Decoder,
+    TSpec: EthSpec,
+{
+    pub fn new(codec: TCodec) -> Self {
+        BaseInboundCodec {
+            inner: codec,
+            phantom: PhantomData,
+        }
+    }
+}
+
+/* Global Outbound Codec */
+// This deals with Decoding RPC Responses from other peers and encoding our requests
+pub struct BaseOutboundCodec<TOutboundCodec, TSpec>
+where
+    TOutboundCodec: OutboundCodec<RPCRequest<TSpec>>,
+    TSpec: EthSpec,
+{
+    /// Inner codec for handling various encodings.
+    inner: TOutboundCodec,
+    /// Keeps track of the current response code for a chunk.
+    current_response_code: Option<u8>,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<TOutboundCodec, TSpec> BaseOutboundCodec<TOutboundCodec, TSpec>
+where
+    TSpec: EthSpec,
+    TOutboundCodec: OutboundCodec<RPCRequest<TSpec>>,
+{
+    pub fn new(codec: TOutboundCodec) -> Self {
+        BaseOutboundCodec {
+            inner: codec,
+            current_response_code: None,
+            phantom: PhantomData,
+        }
+    }
+}
+
+/* Implementation of the Encoding/Decoding for the global codecs */
+
+/* Base Inbound Codec */
+
+// This Encodes RPC Responses sent to external peers
+impl<TCodec, TSpec> Encoder<RPCCodedResponse<TSpec>> for BaseInboundCodec<TCodec, TSpec>
+where
+    TSpec: EthSpec,
+    TCodec: Decoder + Encoder<RPCCodedResponse<TSpec>>,
+{
+    type Error = <TCodec as Encoder<RPCCodedResponse<TSpec>>>::Error;
+
+    fn encode(
+        &mut self,
+        item: RPCCodedResponse<TSpec>,
+        dst: &mut BytesMut,
+    ) -> Result<(), Self::Error> {
+        dst.clear();
+        dst.reserve(1);
+        dst.put_u8(
+            item.as_u8()
+                .expect("Should never encode a stream termination"),
+        );
+        self.inner.encode(item, dst)
+    }
+}
+
+// This Decodes RPC Requests from external peers
+impl<TCodec, TSpec> Decoder for BaseInboundCodec<TCodec, TSpec>
+where
+    TSpec: EthSpec,
+    TCodec: Encoder<RPCCodedResponse<TSpec>> + Decoder<Item = RPCRequest<TSpec>>,
+{
+    type Item = RPCRequest<TSpec>;
+    type Error = <TCodec as Decoder>::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        self.inner.decode(src)
+    }
+}
+
+/* Base Outbound Codec */
+
+// This Encodes RPC Requests sent to external peers
+impl<TCodec, TSpec> Encoder<RPCRequest<TSpec>> for BaseOutboundCodec<TCodec, TSpec>
+where
+    TSpec: EthSpec,
+    TCodec: OutboundCodec<RPCRequest<TSpec>> + Encoder<RPCRequest<TSpec>>,
+{
+    type Error = <TCodec as Encoder<RPCRequest<TSpec>>>::Error;
+
+    fn encode(&mut self, item: RPCRequest<TSpec>, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        self.inner.encode(item, dst)
+    }
+}
+
+// This decodes RPC Responses received from external peers
+impl<TCodec, TSpec> Decoder for BaseOutboundCodec<TCodec, TSpec>
+where
+    TSpec: EthSpec,
+    TCodec:
+        OutboundCodec<RPCRequest<TSpec>, ErrorType = String> + Decoder<Item = RPCResponse<TSpec>>,
+{
+    type Item = RPCCodedResponse<TSpec>;
+    type Error = <TCodec as Decoder>::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        // if we have only received the response code, wait for more bytes
+        if src.len() <= 1 {
+            return Ok(None);
+        }
+        // using the response code determine which kind of payload needs to be decoded.
+        let response_code = self.current_response_code.unwrap_or_else(|| {
+            let resp_code = src.split_to(1)[0];
+            self.current_response_code = Some(resp_code);
+            resp_code
+        });
+
+        let inner_result = {
+            if RPCCodedResponse::<TSpec>::is_response(response_code) {
+                // decode an actual response and mutates the buffer if enough bytes have been read
+                // returning the result.
+                self.inner
+                    .decode(src)
+                    .map(|r| r.map(RPCCodedResponse::Success))
+            } else {
+                // decode an error
+                self.inner
+                    .decode_error(src)
+                    .map(|r| r.map(|resp| RPCCodedResponse::from_error(response_code, resp)))
+            }
+        };
+        // if the inner decoder was capable of decoding a chunk, we need to reset the current
+        // response code for the next chunk
+        if let Ok(Some(_)) = inner_result {
+            self.current_response_code = None;
+        }
+        // return the result
+        inner_result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::ssz::*;
+    use super::super::ssz_snappy::*;
+    use super::*;
+    use crate::rpc::protocol::*;
+
+    #[test]
+    fn test_decode_status_message() {
+        let message = hex::decode("ff060000734e615070590032000006e71e7b54989925efd6c9cbcb8ceb9b5f71216f5137282bf6a1e3b50f64e42d6c7fb347abe07eb0db8200000005029e2800").unwrap();
+        let mut buf = BytesMut::new();
+        buf.extend_from_slice(&message);
+
+        type Spec = types::MainnetEthSpec;
+
+        let snappy_protocol_id =
+            ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy);
+        let ssz_protocol_id = ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZ);
+
+        let mut snappy_outbound_codec =
+            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576);
+        let mut ssz_outbound_codec = SSZOutboundCodec::<Spec>::new(ssz_protocol_id, 1_048_576);
+
+        // decode message just as snappy message
+        let snappy_decoded_message = snappy_outbound_codec.decode(&mut buf.clone());
+        // decode message just a ssz message
+        let ssz_decoded_message = ssz_outbound_codec.decode(&mut buf.clone());
+
+        // build codecs for entire chunk
+        let mut snappy_base_outbound_codec = BaseOutboundCodec::new(snappy_outbound_codec);
+        let mut ssz_base_outbound_codec = BaseOutboundCodec::new(ssz_outbound_codec);
+
+        // decode message as ssz snappy chunk
+        let snappy_decoded_chunk = snappy_base_outbound_codec.decode(&mut buf.clone());
+        // decode message just a ssz chunk
+        let ssz_decoded_chunk = ssz_base_outbound_codec.decode(&mut buf.clone());
+
+        let _ = dbg!(snappy_decoded_message);
+        let _ = dbg!(ssz_decoded_message);
+        let _ = dbg!(snappy_decoded_chunk);
+        let _ = dbg!(ssz_decoded_chunk);
+    }
+}

beacon_node/eth2_libp2p/src/rpc/codec/mod.rs

@@ -0,0 +1,69 @@
+pub(crate) mod base;
+pub(crate) mod ssz;
+pub(crate) mod ssz_snappy;
+
+use self::base::{BaseInboundCodec, BaseOutboundCodec};
+use self::ssz::{SSZInboundCodec, SSZOutboundCodec};
+use self::ssz_snappy::{SSZSnappyInboundCodec, SSZSnappyOutboundCodec};
+use crate::rpc::protocol::RPCError;
+use crate::rpc::{RPCCodedResponse, RPCRequest};
+use libp2p::bytes::BytesMut;
+use tokio_util::codec::{Decoder, Encoder};
+use types::EthSpec;
+
+// Known types of codecs
+pub enum InboundCodec<TSpec: EthSpec> {
+    SSZSnappy(BaseInboundCodec<SSZSnappyInboundCodec<TSpec>, TSpec>),
+    SSZ(BaseInboundCodec<SSZInboundCodec<TSpec>, TSpec>),
+}
+
+pub enum OutboundCodec<TSpec: EthSpec> {
+    SSZSnappy(BaseOutboundCodec<SSZSnappyOutboundCodec<TSpec>, TSpec>),
+    SSZ(BaseOutboundCodec<SSZOutboundCodec<TSpec>, TSpec>),
+}
+
+impl<T: EthSpec> Encoder<RPCCodedResponse<T>> for InboundCodec<T> {
+    type Error = RPCError;
+
+    fn encode(&mut self, item: RPCCodedResponse<T>, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        match self {
+            InboundCodec::SSZ(codec) => codec.encode(item, dst),
+            InboundCodec::SSZSnappy(codec) => codec.encode(item, dst),
+        }
+    }
+}
+
+impl<TSpec: EthSpec> Decoder for InboundCodec<TSpec> {
+    type Item = RPCRequest<TSpec>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self {
+            InboundCodec::SSZ(codec) => codec.decode(src),
+            InboundCodec::SSZSnappy(codec) => codec.decode(src),
+        }
+    }
+}
+
+impl<TSpec: EthSpec> Encoder<RPCRequest<TSpec>> for OutboundCodec<TSpec> {
+    type Error = RPCError;
+
+    fn encode(&mut self, item: RPCRequest<TSpec>, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        match self {
+            OutboundCodec::SSZ(codec) => codec.encode(item, dst),
+            OutboundCodec::SSZSnappy(codec) => codec.encode(item, dst),
+        }
+    }
+}
+
+impl<T: EthSpec> Decoder for OutboundCodec<T> {
+    type Item = RPCCodedResponse<T>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self {
+            OutboundCodec::SSZ(codec) => codec.decode(src),
+            OutboundCodec::SSZSnappy(codec) => codec.decode(src),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/rpc/codec/ssz.rs

@@ -0,0 +1,326 @@
+use crate::rpc::methods::*;
+use crate::rpc::{
+    codec::base::OutboundCodec,
+    protocol::{
+        Encoding, Protocol, ProtocolId, RPCError, Version, BLOCKS_BY_ROOT_REQUEST_MAX,
+        BLOCKS_BY_ROOT_REQUEST_MIN, SIGNED_BEACON_BLOCK_MAX, SIGNED_BEACON_BLOCK_MIN,
+    },
+};
+use crate::rpc::{RPCCodedResponse, RPCRequest, RPCResponse};
+use libp2p::bytes::{BufMut, Bytes, BytesMut};
+use ssz::{Decode, Encode};
+use ssz_types::VariableList;
+use std::marker::PhantomData;
+use tokio_util::codec::{Decoder, Encoder};
+use types::{EthSpec, SignedBeaconBlock};
+use unsigned_varint::codec::UviBytes;
+
+/* Inbound Codec */
+
+pub struct SSZInboundCodec<TSpec: EthSpec> {
+    inner: UviBytes,
+    protocol: ProtocolId,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<TSpec: EthSpec> SSZInboundCodec<TSpec> {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let mut uvi_codec = UviBytes::default();
+        uvi_codec.set_max_len(max_packet_size);
+
+        // this encoding only applies to ssz.
+        debug_assert_eq!(protocol.encoding, Encoding::SSZ);
+
+        SSZInboundCodec {
+            inner: uvi_codec,
+            protocol,
+            phantom: PhantomData,
+        }
+    }
+}
+
+// Encoder for inbound streams: Encodes RPC Responses sent to peers.
+impl<TSpec: EthSpec> Encoder<RPCCodedResponse<TSpec>> for SSZInboundCodec<TSpec> {
+    type Error = RPCError;
+
+    fn encode(
+        &mut self,
+        item: RPCCodedResponse<TSpec>,
+        dst: &mut BytesMut,
+    ) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCCodedResponse::Success(resp) => match resp {
+                RPCResponse::Status(res) => res.as_ssz_bytes(),
+                RPCResponse::BlocksByRange(res) => res.as_ssz_bytes(),
+                RPCResponse::BlocksByRoot(res) => res.as_ssz_bytes(),
+                RPCResponse::Pong(res) => res.data.as_ssz_bytes(),
+                RPCResponse::MetaData(res) => res.as_ssz_bytes(),
+            },
+            RPCCodedResponse::InvalidRequest(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::ServerError(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::Unknown(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::StreamTermination(_) => {
+                unreachable!("Code error - attempting to encode a stream termination")
+            }
+        };
+        if !bytes.is_empty() {
+            // length-prefix and return
+            return self
+                .inner
+                .encode(Bytes::from(bytes), dst)
+                .map_err(RPCError::from);
+        } else {
+            // payload is empty, add a 0-byte length prefix
+            dst.reserve(1);
+            dst.put_u8(0);
+        }
+        Ok(())
+    }
+}
+
+// Decoder for inbound streams: Decodes RPC requests from peers
+impl<TSpec: EthSpec> Decoder for SSZInboundCodec<TSpec> {
+    type Item = RPCRequest<TSpec>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self.inner.decode(src).map_err(RPCError::from) {
+            Ok(Some(packet)) => match self.protocol.message_name {
+                Protocol::Status => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() == <StatusMessage as Encode>::ssz_fixed_len() {
+                            Ok(Some(RPCRequest::Status(StatusMessage::from_ssz_bytes(
+                                &packet,
+                            )?)))
+                        } else {
+                            Err(RPCError::InvalidData)
+                        }
+                    }
+                },
+                Protocol::Goodbye => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() == <GoodbyeReason as Encode>::ssz_fixed_len() {
+                            Ok(Some(RPCRequest::Goodbye(GoodbyeReason::from_ssz_bytes(
+                                &packet,
+                            )?)))
+                        } else {
+                            Err(RPCError::InvalidData)
+                        }
+                    }
+                },
+                Protocol::BlocksByRange => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() == <BlocksByRangeRequest as Encode>::ssz_fixed_len() {
+                            Ok(Some(RPCRequest::BlocksByRange(
+                                BlocksByRangeRequest::from_ssz_bytes(&packet)?,
+                            )))
+                        } else {
+                            Err(RPCError::InvalidData)
+                        }
+                    }
+                },
+                Protocol::BlocksByRoot => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() >= *BLOCKS_BY_ROOT_REQUEST_MIN
+                            && packet.len() <= *BLOCKS_BY_ROOT_REQUEST_MAX
+                        {
+                            Ok(Some(RPCRequest::BlocksByRoot(BlocksByRootRequest {
+                                block_roots: VariableList::from_ssz_bytes(&packet)?,
+                            })))
+                        } else {
+                            Err(RPCError::InvalidData)
+                        }
+                    }
+                },
+                Protocol::Ping => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() == <Ping as Encode>::ssz_fixed_len() {
+                            Ok(Some(RPCRequest::Ping(Ping {
+                                data: u64::from_ssz_bytes(&packet)?,
+                            })))
+                        } else {
+                            Err(RPCError::InvalidData)
+                        }
+                    }
+                },
+                Protocol::MetaData => match self.protocol.version {
+                    Version::V1 => {
+                        if packet.len() > 0 {
+                            Err(RPCError::InvalidData)
+                        } else {
+                            Ok(Some(RPCRequest::MetaData(PhantomData)))
+                        }
+                    }
+                },
+            },
+            Ok(None) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/* Outbound Codec: Codec for initiating RPC requests */
+
+pub struct SSZOutboundCodec<TSpec: EthSpec> {
+    inner: UviBytes,
+    protocol: ProtocolId,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<TSpec: EthSpec> SSZOutboundCodec<TSpec> {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let mut uvi_codec = UviBytes::default();
+        uvi_codec.set_max_len(max_packet_size);
+
+        // this encoding only applies to ssz.
+        debug_assert_eq!(protocol.encoding, Encoding::SSZ);
+
+        SSZOutboundCodec {
+            inner: uvi_codec,
+            protocol,
+            phantom: PhantomData,
+        }
+    }
+}
+
+// Encoder for outbound streams: Encodes RPC Requests to peers
+impl<TSpec: EthSpec> Encoder<RPCRequest<TSpec>> for SSZOutboundCodec<TSpec> {
+    type Error = RPCError;
+
+    fn encode(&mut self, item: RPCRequest<TSpec>, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCRequest::Status(req) => req.as_ssz_bytes(),
+            RPCRequest::Goodbye(req) => req.as_ssz_bytes(),
+            RPCRequest::BlocksByRange(req) => req.as_ssz_bytes(),
+            RPCRequest::BlocksByRoot(req) => req.block_roots.as_ssz_bytes(),
+            RPCRequest::Ping(req) => req.as_ssz_bytes(),
+            RPCRequest::MetaData(_) => return Ok(()), // no metadata to encode
+        };
+        // length-prefix
+        self.inner
+            .encode(libp2p::bytes::Bytes::from(bytes), dst)
+            .map_err(RPCError::from)
+    }
+}
+
+// Decoder for outbound streams: Decodes RPC responses from peers.
+//
+// The majority of the decoding has now been pushed upstream due to the changing specification.
+// We prefer to decode blocks and attestations with extra knowledge about the chain to perform
+// faster verification checks before decoding entire blocks/attestations.
+impl<TSpec: EthSpec> Decoder for SSZOutboundCodec<TSpec> {
+    type Item = RPCResponse<TSpec>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if src.len() == 1 && src[0] == 0_u8 {
+            // the object is empty. We return the empty object if this is the case
+            // clear the buffer and return an empty object
+            src.clear();
+            match self.protocol.message_name {
+                Protocol::Status => match self.protocol.version {
+                    Version::V1 => Err(RPCError::IncompleteStream), // cannot have an empty HELLO message. The stream has terminated unexpectedly
+                },
+                Protocol::Goodbye => Err(RPCError::InvalidData),
+                Protocol::BlocksByRange => match self.protocol.version {
+                    Version::V1 => Err(RPCError::IncompleteStream), // cannot have an empty block message.
+                },
+                Protocol::BlocksByRoot => match self.protocol.version {
+                    Version::V1 => Err(RPCError::IncompleteStream), // cannot have an empty block message.
+                },
+                Protocol::Ping => match self.protocol.version {
+                    Version::V1 => Err(RPCError::IncompleteStream), // cannot have an empty block message.
+                },
+                Protocol::MetaData => match self.protocol.version {
+                    Version::V1 => Err(RPCError::IncompleteStream), // cannot have an empty block message.
+                },
+            }
+        } else {
+            match self.inner.decode(src).map_err(RPCError::from) {
+                Ok(Some(mut packet)) => {
+                    // take the bytes from the buffer
+                    let raw_bytes = packet.split();
+
+                    match self.protocol.message_name {
+                        Protocol::Status => match self.protocol.version {
+                            Version::V1 => {
+                                if raw_bytes.len() == <StatusMessage as Encode>::ssz_fixed_len() {
+                                    Ok(Some(RPCResponse::Status(StatusMessage::from_ssz_bytes(
+                                        &raw_bytes,
+                                    )?)))
+                                } else {
+                                    Err(RPCError::InvalidData)
+                                }
+                            }
+                        },
+                        Protocol::Goodbye => Err(RPCError::InvalidData),
+                        Protocol::BlocksByRange => match self.protocol.version {
+                            Version::V1 => {
+                                if raw_bytes.len() >= *SIGNED_BEACON_BLOCK_MIN
+                                    && raw_bytes.len() <= *SIGNED_BEACON_BLOCK_MAX
+                                {
+                                    Ok(Some(RPCResponse::BlocksByRange(Box::new(
+                                        SignedBeaconBlock::from_ssz_bytes(&raw_bytes)?,
+                                    ))))
+                                } else {
+                                    Err(RPCError::InvalidData)
+                                }
+                            }
+                        },
+                        Protocol::BlocksByRoot => match self.protocol.version {
+                            Version::V1 => {
+                                if raw_bytes.len() >= *SIGNED_BEACON_BLOCK_MIN
+                                    && raw_bytes.len() <= *SIGNED_BEACON_BLOCK_MAX
+                                {
+                                    Ok(Some(RPCResponse::BlocksByRoot(Box::new(
+                                        SignedBeaconBlock::from_ssz_bytes(&raw_bytes)?,
+                                    ))))
+                                } else {
+                                    Err(RPCError::InvalidData)
+                                }
+                            }
+                        },
+                        Protocol::Ping => match self.protocol.version {
+                            Version::V1 => {
+                                if raw_bytes.len() == <Ping as Encode>::ssz_fixed_len() {
+                                    Ok(Some(RPCResponse::Pong(Ping {
+                                        data: u64::from_ssz_bytes(&raw_bytes)?,
+                                    })))
+                                } else {
+                                    Err(RPCError::InvalidData)
+                                }
+                            }
+                        },
+                        Protocol::MetaData => match self.protocol.version {
+                            Version::V1 => {
+                                if raw_bytes.len() == <MetaData<TSpec> as Encode>::ssz_fixed_len() {
+                                    Ok(Some(RPCResponse::MetaData(MetaData::from_ssz_bytes(
+                                        &raw_bytes,
+                                    )?)))
+                                } else {
+                                    Err(RPCError::InvalidData)
+                                }
+                            }
+                        },
+                    }
+                }
+                Ok(None) => Ok(None), // waiting for more bytes
+                Err(e) => Err(e),
+            }
+        }
+    }
+}
+
+impl<TSpec: EthSpec> OutboundCodec<RPCRequest<TSpec>> for SSZOutboundCodec<TSpec> {
+    type ErrorType = String;
+
+    fn decode_error(&mut self, src: &mut BytesMut) -> Result<Option<Self::ErrorType>, RPCError> {
+        match self.inner.decode(src).map_err(RPCError::from) {
+            Ok(Some(packet)) => Ok(Some(
+                String::from_utf8_lossy(&<Vec<u8>>::from_ssz_bytes(&packet)?).into(),
+            )),
+            Ok(None) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/rpc/codec/ssz_snappy.rs

@@ -0,0 +1,424 @@
+use crate::rpc::methods::*;
+use crate::rpc::{
+    codec::base::OutboundCodec,
+    protocol::{
+        Encoding, Protocol, ProtocolId, RPCError, Version, BLOCKS_BY_ROOT_REQUEST_MAX,
+        BLOCKS_BY_ROOT_REQUEST_MIN, SIGNED_BEACON_BLOCK_MAX, SIGNED_BEACON_BLOCK_MIN,
+    },
+};
+use crate::rpc::{RPCCodedResponse, RPCRequest, RPCResponse};
+use libp2p::bytes::BytesMut;
+use snap::read::FrameDecoder;
+use snap::write::FrameEncoder;
+use ssz::{Decode, Encode};
+use ssz_types::VariableList;
+use std::io::Cursor;
+use std::io::ErrorKind;
+use std::io::{Read, Write};
+use std::marker::PhantomData;
+use tokio_util::codec::{Decoder, Encoder};
+use types::{EthSpec, SignedBeaconBlock};
+use unsigned_varint::codec::Uvi;
+
+/* Inbound Codec */
+
+pub struct SSZSnappyInboundCodec<TSpec: EthSpec> {
+    protocol: ProtocolId,
+    inner: Uvi<usize>,
+    len: Option<usize>,
+    /// Maximum bytes that can be sent in one req/resp chunked responses.
+    max_packet_size: usize,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<T: EthSpec> SSZSnappyInboundCodec<T> {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let uvi_codec = Uvi::default();
+        // this encoding only applies to ssz_snappy.
+        debug_assert_eq!(protocol.encoding, Encoding::SSZSnappy);
+
+        SSZSnappyInboundCodec {
+            inner: uvi_codec,
+            protocol,
+            len: None,
+            phantom: PhantomData,
+            max_packet_size,
+        }
+    }
+}
+
+// Encoder for inbound streams: Encodes RPC Responses sent to peers.
+impl<TSpec: EthSpec> Encoder<RPCCodedResponse<TSpec>> for SSZSnappyInboundCodec<TSpec> {
+    type Error = RPCError;
+
+    fn encode(
+        &mut self,
+        item: RPCCodedResponse<TSpec>,
+        dst: &mut BytesMut,
+    ) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCCodedResponse::Success(resp) => match resp {
+                RPCResponse::Status(res) => res.as_ssz_bytes(),
+                RPCResponse::BlocksByRange(res) => res.as_ssz_bytes(),
+                RPCResponse::BlocksByRoot(res) => res.as_ssz_bytes(),
+                RPCResponse::Pong(res) => res.data.as_ssz_bytes(),
+                RPCResponse::MetaData(res) => res.as_ssz_bytes(),
+            },
+            RPCCodedResponse::InvalidRequest(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::ServerError(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::Unknown(err) => err.as_ssz_bytes(),
+            RPCCodedResponse::StreamTermination(_) => {
+                unreachable!("Code error - attempting to encode a stream termination")
+            }
+        };
+        // SSZ encoded bytes should be within `max_packet_size`
+        if bytes.len() > self.max_packet_size {
+            return Err(RPCError::InternalError(
+                "attempting to encode data > max_packet_size".into(),
+            ));
+        }
+        // Inserts the length prefix of the uncompressed bytes into dst
+        // encoded as a unsigned varint
+        self.inner
+            .encode(bytes.len(), dst)
+            .map_err(RPCError::from)?;
+
+        let mut writer = FrameEncoder::new(Vec::new());
+        writer.write_all(&bytes).map_err(RPCError::from)?;
+        writer.flush().map_err(RPCError::from)?;
+
+        // Write compressed bytes to `dst`
+        dst.extend_from_slice(writer.get_ref());
+        Ok(())
+    }
+}
+
+// Decoder for inbound streams: Decodes RPC requests from peers
+impl<TSpec: EthSpec> Decoder for SSZSnappyInboundCodec<TSpec> {
+    type Item = RPCRequest<TSpec>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if self.len.is_none() {
+            // Decode the length of the uncompressed bytes from an unsigned varint
+            match self.inner.decode(src).map_err(RPCError::from)? {
+                Some(length) => {
+                    self.len = Some(length);
+                }
+                None => return Ok(None), // need more bytes to decode length
+            }
+        };
+
+        let length = self.len.expect("length should be Some");
+
+        // Should not attempt to decode rpc chunks with length > max_packet_size
+        if length > self.max_packet_size {
+            return Err(RPCError::InvalidData);
+        }
+        let mut reader = FrameDecoder::new(Cursor::new(&src));
+        let mut decoded_buffer = vec![0; length];
+
+        match reader.read_exact(&mut decoded_buffer) {
+            Ok(()) => {
+                // `n` is how many bytes the reader read in the compressed stream
+                let n = reader.get_ref().position();
+                self.len = None;
+                let _read_bytes = src.split_to(n as usize);
+                match self.protocol.message_name {
+                    Protocol::Status => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <StatusMessage as Encode>::ssz_fixed_len() {
+                                Ok(Some(RPCRequest::Status(StatusMessage::from_ssz_bytes(
+                                    &decoded_buffer,
+                                )?)))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::Goodbye => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <GoodbyeReason as Encode>::ssz_fixed_len() {
+                                Ok(Some(RPCRequest::Goodbye(GoodbyeReason::from_ssz_bytes(
+                                    &decoded_buffer,
+                                )?)))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::BlocksByRange => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len()
+                                == <BlocksByRangeRequest as Encode>::ssz_fixed_len()
+                            {
+                                Ok(Some(RPCRequest::BlocksByRange(
+                                    BlocksByRangeRequest::from_ssz_bytes(&decoded_buffer)?,
+                                )))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::BlocksByRoot => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() >= *BLOCKS_BY_ROOT_REQUEST_MIN
+                                && decoded_buffer.len() <= *BLOCKS_BY_ROOT_REQUEST_MAX
+                            {
+                                Ok(Some(RPCRequest::BlocksByRoot(BlocksByRootRequest {
+                                    block_roots: VariableList::from_ssz_bytes(&decoded_buffer)?,
+                                })))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::Ping => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <Ping as Encode>::ssz_fixed_len() {
+                                Ok(Some(RPCRequest::Ping(Ping {
+                                    data: u64::from_ssz_bytes(&decoded_buffer)?,
+                                })))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::MetaData => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() > 0 {
+                                Err(RPCError::InvalidData)
+                            } else {
+                                Ok(Some(RPCRequest::MetaData(PhantomData)))
+                            }
+                        }
+                    },
+                }
+            }
+            Err(e) => match e.kind() {
+                // Haven't received enough bytes to decode yet
+                // TODO: check if this is the only Error variant where we return `Ok(None)`
+                ErrorKind::UnexpectedEof => {
+                    return Ok(None);
+                }
+                _ => return Err(e).map_err(RPCError::from),
+            },
+        }
+    }
+}
+
+/* Outbound Codec: Codec for initiating RPC requests */
+pub struct SSZSnappyOutboundCodec<TSpec: EthSpec> {
+    inner: Uvi<usize>,
+    len: Option<usize>,
+    protocol: ProtocolId,
+    /// Maximum bytes that can be sent in one req/resp chunked responses.
+    max_packet_size: usize,
+    phantom: PhantomData<TSpec>,
+}
+
+impl<TSpec: EthSpec> SSZSnappyOutboundCodec<TSpec> {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let uvi_codec = Uvi::default();
+        // this encoding only applies to ssz_snappy.
+        debug_assert_eq!(protocol.encoding, Encoding::SSZSnappy);
+
+        SSZSnappyOutboundCodec {
+            inner: uvi_codec,
+            protocol,
+            max_packet_size,
+            len: None,
+            phantom: PhantomData,
+        }
+    }
+}
+
+// Encoder for outbound streams: Encodes RPC Requests to peers
+impl<TSpec: EthSpec> Encoder<RPCRequest<TSpec>> for SSZSnappyOutboundCodec<TSpec> {
+    type Error = RPCError;
+
+    fn encode(&mut self, item: RPCRequest<TSpec>, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCRequest::Status(req) => req.as_ssz_bytes(),
+            RPCRequest::Goodbye(req) => req.as_ssz_bytes(),
+            RPCRequest::BlocksByRange(req) => req.as_ssz_bytes(),
+            RPCRequest::BlocksByRoot(req) => req.block_roots.as_ssz_bytes(),
+            RPCRequest::Ping(req) => req.as_ssz_bytes(),
+            RPCRequest::MetaData(_) => return Ok(()), // no metadata to encode
+        };
+        // SSZ encoded bytes should be within `max_packet_size`
+        if bytes.len() > self.max_packet_size {
+            return Err(RPCError::InternalError(
+                "attempting to encode data > max_packet_size",
+            ));
+        }
+
+        // Inserts the length prefix of the uncompressed bytes into dst
+        // encoded as a unsigned varint
+        self.inner
+            .encode(bytes.len(), dst)
+            .map_err(RPCError::from)?;
+
+        let mut writer = FrameEncoder::new(Vec::new());
+        writer.write_all(&bytes).map_err(RPCError::from)?;
+        writer.flush().map_err(RPCError::from)?;
+
+        // Write compressed bytes to `dst`
+        dst.extend_from_slice(writer.get_ref());
+        Ok(())
+    }
+}
+
+// Decoder for outbound streams: Decodes RPC responses from peers.
+//
+// The majority of the decoding has now been pushed upstream due to the changing specification.
+// We prefer to decode blocks and attestations with extra knowledge about the chain to perform
+// faster verification checks before decoding entire blocks/attestations.
+impl<TSpec: EthSpec> Decoder for SSZSnappyOutboundCodec<TSpec> {
+    type Item = RPCResponse<TSpec>;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        if self.len.is_none() {
+            // Decode the length of the uncompressed bytes from an unsigned varint
+            match self.inner.decode(src).map_err(RPCError::from)? {
+                Some(length) => {
+                    self.len = Some(length as usize);
+                }
+                None => return Ok(None), // need more bytes to decode length
+            }
+        };
+
+        let length = self.len.expect("length should be Some");
+
+        // Should not attempt to decode rpc chunks with length > max_packet_size
+        if length > self.max_packet_size {
+            return Err(RPCError::InvalidData);
+        }
+        let mut reader = FrameDecoder::new(Cursor::new(&src));
+        let mut decoded_buffer = vec![0; length];
+        match reader.read_exact(&mut decoded_buffer) {
+            Ok(()) => {
+                // `n` is how many bytes the reader read in the compressed stream
+                let n = reader.get_ref().position();
+                self.len = None;
+                let _read_byts = src.split_to(n as usize);
+                match self.protocol.message_name {
+                    Protocol::Status => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <StatusMessage as Encode>::ssz_fixed_len() {
+                                Ok(Some(RPCResponse::Status(StatusMessage::from_ssz_bytes(
+                                    &decoded_buffer,
+                                )?)))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::Goodbye => Err(RPCError::InvalidData),
+                    Protocol::BlocksByRange => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() >= *SIGNED_BEACON_BLOCK_MIN
+                                && decoded_buffer.len() <= *SIGNED_BEACON_BLOCK_MAX
+                            {
+                                Ok(Some(RPCResponse::BlocksByRange(Box::new(
+                                    SignedBeaconBlock::from_ssz_bytes(&decoded_buffer)?,
+                                ))))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::BlocksByRoot => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() >= *SIGNED_BEACON_BLOCK_MIN
+                                && decoded_buffer.len() <= *SIGNED_BEACON_BLOCK_MAX
+                            {
+                                Ok(Some(RPCResponse::BlocksByRoot(Box::new(
+                                    SignedBeaconBlock::from_ssz_bytes(&decoded_buffer)?,
+                                ))))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::Ping => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <Ping as Encode>::ssz_fixed_len() {
+                                Ok(Some(RPCResponse::Pong(Ping {
+                                    data: u64::from_ssz_bytes(&decoded_buffer)?,
+                                })))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                    Protocol::MetaData => match self.protocol.version {
+                        Version::V1 => {
+                            if decoded_buffer.len() == <MetaData<TSpec> as Encode>::ssz_fixed_len()
+                            {
+                                Ok(Some(RPCResponse::MetaData(MetaData::from_ssz_bytes(
+                                    &decoded_buffer,
+                                )?)))
+                            } else {
+                                Err(RPCError::InvalidData)
+                            }
+                        }
+                    },
+                }
+            }
+            Err(e) => match e.kind() {
+                // Haven't received enough bytes to decode yet
+                // TODO: check if this is the only Error variant where we return `Ok(None)`
+                ErrorKind::UnexpectedEof => {
+                    return Ok(None);
+                }
+                _ => return Err(e).map_err(RPCError::from),
+            },
+        }
+    }
+}
+
+impl<TSpec: EthSpec> OutboundCodec<RPCRequest<TSpec>> for SSZSnappyOutboundCodec<TSpec> {
+    type ErrorType = String;
+
+    fn decode_error(&mut self, src: &mut BytesMut) -> Result<Option<Self::ErrorType>, RPCError> {
+        if self.len.is_none() {
+            // Decode the length of the uncompressed bytes from an unsigned varint
+            match self.inner.decode(src).map_err(RPCError::from)? {
+                Some(length) => {
+                    self.len = Some(length as usize);
+                }
+                None => return Ok(None), // need more bytes to decode length
+            }
+        };
+
+        let length = self.len.expect("length should be Some");
+
+        // Should not attempt to decode rpc chunks with length > max_packet_size
+        if length > self.max_packet_size {
+            return Err(RPCError::InvalidData);
+        }
+        let mut reader = FrameDecoder::new(Cursor::new(&src));
+        let mut decoded_buffer = vec![0; length];
+        match reader.read_exact(&mut decoded_buffer) {
+            Ok(()) => {
+                // `n` is how many bytes the reader read in the compressed stream
+                let n = reader.get_ref().position();
+                self.len = None;
+                let _read_bytes = src.split_to(n as usize);
+                Ok(Some(
+                    String::from_utf8_lossy(&<Vec<u8>>::from_ssz_bytes(&decoded_buffer)?).into(),
+                ))
+            }
+            Err(e) => match e.kind() {
+                // Haven't received enough bytes to decode yet
+                // TODO: check if this is the only Error variant where we return `Ok(None)`
+                ErrorKind::UnexpectedEof => {
+                    return Ok(None);
+                }
+                _ => return Err(e).map_err(RPCError::from),
+            },
+        }
+    }
+}

beacon_node/eth2_libp2p/src/rpc/methods.rs

@@ -0,0 +1,412 @@
+//! Available RPC methods types and ids.
+
+use crate::types::EnrBitfield;
+use serde::Serialize;
+use ssz_derive::{Decode, Encode};
+use ssz_types::{
+    typenum::{U1024, U256},
+    VariableList,
+};
+use std::ops::Deref;
+use types::{Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot};
+
+/// Maximum number of blocks in a single request.
+pub type MaxRequestBlocks = U1024;
+pub const MAX_REQUEST_BLOCKS: u64 = 1024;
+
+/// Maximum length of error message.
+type MaxErrorLen = U256;
+
+/// Wrapper over SSZ List to represent error message in rpc responses.
+#[derive(Debug, Clone)]
+pub struct ErrorType(VariableList<u8, MaxErrorLen>);
+
+impl From<String> for ErrorType {
+    fn from(s: String) -> Self {
+        Self(VariableList::from(s.as_bytes().to_vec()))
+    }
+}
+
+impl From<&str> for ErrorType {
+    fn from(s: &str) -> Self {
+        Self(VariableList::from(s.as_bytes().to_vec()))
+    }
+}
+
+impl Deref for ErrorType {
+    type Target = VariableList<u8, MaxErrorLen>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl ToString for ErrorType {
+    fn to_string(&self) -> String {
+        match std::str::from_utf8(self.0.deref()) {
+            Ok(s) => s.to_string(),
+            Err(_) => format!("{:?}", self.0.deref()), // Display raw bytes if not a UTF-8 string
+        }
+    }
+}
+
+/* Request/Response data structures for RPC methods */
+
+/* Requests */
+
+/// Identifier of a request.
+///
+// NOTE: The handler stores the `RequestId` to inform back of responses and errors, but it's execution
+// is independent of the contents on this type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RequestId {
+    Router,
+    Sync(usize),
+    Behaviour,
+}
+
+/// The STATUS request/response handshake message.
+#[derive(Encode, Decode, Clone, Debug, PartialEq)]
+pub struct StatusMessage {
+    /// The fork version of the chain we are broadcasting.
+    pub fork_digest: [u8; 4],
+
+    /// Latest finalized root.
+    pub finalized_root: Hash256,
+
+    /// Latest finalized epoch.
+    pub finalized_epoch: Epoch,
+
+    /// The latest block root.
+    pub head_root: Hash256,
+
+    /// The slot associated with the latest block root.
+    pub head_slot: Slot,
+}
+
+/// The PING request/response message.
+#[derive(Encode, Decode, Clone, Debug, PartialEq)]
+pub struct Ping {
+    /// The metadata sequence number.
+    pub data: u64,
+}
+
+/// The METADATA response structure.
+#[derive(Encode, Decode, Clone, Debug, PartialEq, Serialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct MetaData<T: EthSpec> {
+    /// A sequential counter indicating when data gets modified.
+    pub seq_number: u64,
+    /// The persistent subnet bitfield.
+    pub attnets: EnrBitfield<T>,
+}
+
+/// The reason given for a `Goodbye` message.
+///
+/// Note: any unknown `u64::into(n)` will resolve to `Goodbye::Unknown` for any unknown `n`,
+/// however `GoodbyeReason::Unknown.into()` will go into `0_u64`. Therefore de-serializing then
+/// re-serializing may not return the same bytes.
+#[derive(Debug, Clone, PartialEq)]
+pub enum GoodbyeReason {
+    /// This node has shutdown.
+    ClientShutdown = 1,
+
+    /// Incompatible networks.
+    IrrelevantNetwork = 2,
+
+    /// Error/fault in the RPC.
+    Fault = 3,
+
+    /// Unknown reason.
+    Unknown = 0,
+}
+
+impl From<u64> for GoodbyeReason {
+    fn from(id: u64) -> GoodbyeReason {
+        match id {
+            1 => GoodbyeReason::ClientShutdown,
+            2 => GoodbyeReason::IrrelevantNetwork,
+            3 => GoodbyeReason::Fault,
+            _ => GoodbyeReason::Unknown,
+        }
+    }
+}
+
+impl Into<u64> for GoodbyeReason {
+    fn into(self) -> u64 {
+        self as u64
+    }
+}
+
+impl ssz::Encode for GoodbyeReason {
+    fn is_ssz_fixed_len() -> bool {
+        <u64 as ssz::Encode>::is_ssz_fixed_len()
+    }
+
+    fn ssz_fixed_len() -> usize {
+        <u64 as ssz::Encode>::ssz_fixed_len()
+    }
+
+    fn ssz_bytes_len(&self) -> usize {
+        0_u64.ssz_bytes_len()
+    }
+
+    fn ssz_append(&self, buf: &mut Vec<u8>) {
+        let conv: u64 = self.clone().into();
+        conv.ssz_append(buf)
+    }
+}
+
+impl ssz::Decode for GoodbyeReason {
+    fn is_ssz_fixed_len() -> bool {
+        <u64 as ssz::Decode>::is_ssz_fixed_len()
+    }
+
+    fn ssz_fixed_len() -> usize {
+        <u64 as ssz::Decode>::ssz_fixed_len()
+    }
+
+    fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
+        u64::from_ssz_bytes(bytes).and_then(|n| Ok(n.into()))
+    }
+}
+
+/// Request a number of beacon block roots from a peer.
+#[derive(Encode, Decode, Clone, Debug, PartialEq)]
+pub struct BlocksByRangeRequest {
+    /// The starting slot to request blocks.
+    pub start_slot: u64,
+
+    /// The number of blocks from the start slot.
+    pub count: u64,
+
+    /// The step increment to receive blocks.
+    ///
+    /// A value of 1 returns every block.
+    /// A value of 2 returns every second block.
+    /// A value of 3 returns every third block and so on.
+    pub step: u64,
+}
+
+/// Request a number of beacon block bodies from a peer.
+#[derive(Encode, Decode, Clone, Debug, PartialEq)]
+pub struct BlocksByRootRequest {
+    /// The list of beacon block bodies being requested.
+    pub block_roots: VariableList<Hash256, MaxRequestBlocks>,
+}
+
+/* RPC Handling and Grouping */
+// Collection of enums and structs used by the Codecs to encode/decode RPC messages
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum RPCResponse<T: EthSpec> {
+    /// A HELLO message.
+    Status(StatusMessage),
+
+    /// A response to a get BLOCKS_BY_RANGE request. A None response signifies the end of the
+    /// batch.
+    BlocksByRange(Box<SignedBeaconBlock<T>>),
+
+    /// A response to a get BLOCKS_BY_ROOT request.
+    BlocksByRoot(Box<SignedBeaconBlock<T>>),
+
+    /// A PONG response to a PING request.
+    Pong(Ping),
+
+    /// A response to a META_DATA request.
+    MetaData(MetaData<T>),
+}
+
+/// Indicates which response is being terminated by a stream termination response.
+#[derive(Debug, Clone)]
+pub enum ResponseTermination {
+    /// Blocks by range stream termination.
+    BlocksByRange,
+
+    /// Blocks by root stream termination.
+    BlocksByRoot,
+}
+
+/// The structured response containing a result/code indicating success or failure
+/// and the contents of the response
+#[derive(Debug, Clone)]
+pub enum RPCCodedResponse<T: EthSpec> {
+    /// The response is a successful.
+    Success(RPCResponse<T>),
+
+    /// The response was invalid.
+    InvalidRequest(ErrorType),
+
+    /// The response indicates a server error.
+    ServerError(ErrorType),
+
+    /// There was an unknown response.
+    Unknown(ErrorType),
+
+    /// Received a stream termination indicating which response is being terminated.
+    StreamTermination(ResponseTermination),
+}
+
+/// The code assigned to an erroneous `RPCResponse`.
+#[derive(Debug, Clone, Copy)]
+pub enum RPCResponseErrorCode {
+    InvalidRequest,
+    ServerError,
+    Unknown,
+}
+
+impl<T: EthSpec> RPCCodedResponse<T> {
+    /// Used to encode the response in the codec.
+    pub fn as_u8(&self) -> Option<u8> {
+        match self {
+            RPCCodedResponse::Success(_) => Some(0),
+            RPCCodedResponse::InvalidRequest(_) => Some(1),
+            RPCCodedResponse::ServerError(_) => Some(2),
+            RPCCodedResponse::Unknown(_) => Some(255),
+            RPCCodedResponse::StreamTermination(_) => None,
+        }
+    }
+
+    /// Tells the codec whether to decode as an RPCResponse or an error.
+    pub fn is_response(response_code: u8) -> bool {
+        match response_code {
+            0 => true,
+            _ => false,
+        }
+    }
+
+    /// Builds an RPCCodedResponse from a response code and an ErrorMessage
+    pub fn from_error(response_code: u8, err: String) -> Self {
+        match response_code {
+            1 => RPCCodedResponse::InvalidRequest(err.into()),
+            2 => RPCCodedResponse::ServerError(err.into()),
+            _ => RPCCodedResponse::Unknown(err.into()),
+        }
+    }
+
+    /// Builds an RPCCodedResponse from a response code and an ErrorMessage
+    pub fn from_error_code(response_code: RPCResponseErrorCode, err: String) -> Self {
+        match response_code {
+            RPCResponseErrorCode::InvalidRequest => RPCCodedResponse::InvalidRequest(err.into()),
+            RPCResponseErrorCode::ServerError => RPCCodedResponse::ServerError(err.into()),
+            RPCResponseErrorCode::Unknown => RPCCodedResponse::Unknown(err.into()),
+        }
+    }
+
+    /// Specifies which response allows for multiple chunks for the stream handler.
+    pub fn multiple_responses(&self) -> bool {
+        match self {
+            RPCCodedResponse::Success(resp) => match resp {
+                RPCResponse::Status(_) => false,
+                RPCResponse::BlocksByRange(_) => true,
+                RPCResponse::BlocksByRoot(_) => true,
+                RPCResponse::Pong(_) => false,
+                RPCResponse::MetaData(_) => false,
+            },
+            RPCCodedResponse::InvalidRequest(_) => true,
+            RPCCodedResponse::ServerError(_) => true,
+            RPCCodedResponse::Unknown(_) => true,
+            // Stream terminations are part of responses that have chunks
+            RPCCodedResponse::StreamTermination(_) => true,
+        }
+    }
+
+    /// Returns true if this response is an error. Used to terminate the stream after an error is
+    /// sent.
+    pub fn is_error(&self) -> bool {
+        match self {
+            RPCCodedResponse::Success(_) => false,
+            _ => true,
+        }
+    }
+
+    pub fn error_code(&self) -> Option<RPCResponseErrorCode> {
+        match self {
+            RPCCodedResponse::Success(_) => None,
+            RPCCodedResponse::StreamTermination(_) => None,
+            RPCCodedResponse::InvalidRequest(_) => Some(RPCResponseErrorCode::InvalidRequest),
+            RPCCodedResponse::ServerError(_) => Some(RPCResponseErrorCode::ServerError),
+            RPCCodedResponse::Unknown(_) => Some(RPCResponseErrorCode::Unknown),
+        }
+    }
+}
+
+impl std::fmt::Display for RPCResponseErrorCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = match self {
+            RPCResponseErrorCode::InvalidRequest => "The request was invalid",
+            RPCResponseErrorCode::ServerError => "Server error occurred",
+            RPCResponseErrorCode::Unknown => "Unknown error occurred",
+        };
+        f.write_str(repr)
+    }
+}
+
+impl std::fmt::Display for StatusMessage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Status Message: Fork Digest: {:?}, Finalized Root: {}, Finalized Epoch: {}, Head Root: {}, Head Slot: {}", self.fork_digest, self.finalized_root, self.finalized_epoch, self.head_root, self.head_slot)
+    }
+}
+
+impl<T: EthSpec> std::fmt::Display for RPCResponse<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCResponse::Status(status) => write!(f, "{}", status),
+            RPCResponse::BlocksByRange(block) => {
+                write!(f, "BlocksByRange: Block slot: {}", block.message.slot)
+            }
+            RPCResponse::BlocksByRoot(block) => {
+                write!(f, "BlocksByRoot: BLock slot: {}", block.message.slot)
+            }
+            RPCResponse::Pong(ping) => write!(f, "Pong: {}", ping.data),
+            RPCResponse::MetaData(metadata) => write!(f, "Metadata: {}", metadata.seq_number),
+        }
+    }
+}
+
+impl<T: EthSpec> std::fmt::Display for RPCCodedResponse<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCCodedResponse::Success(res) => write!(f, "{}", res),
+            RPCCodedResponse::InvalidRequest(err) => write!(f, "Invalid Request: {:?}", err),
+            RPCCodedResponse::ServerError(err) => write!(f, "Server Error: {:?}", err),
+            RPCCodedResponse::Unknown(err) => write!(f, "Unknown Error: {:?}", err),
+            RPCCodedResponse::StreamTermination(_) => write!(f, "Stream Termination"),
+        }
+    }
+}
+
+impl std::fmt::Display for GoodbyeReason {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GoodbyeReason::ClientShutdown => write!(f, "Client Shutdown"),
+            GoodbyeReason::IrrelevantNetwork => write!(f, "Irrelevant Network"),
+            GoodbyeReason::Fault => write!(f, "Fault"),
+            GoodbyeReason::Unknown => write!(f, "Unknown Reason"),
+        }
+    }
+}
+
+impl std::fmt::Display for BlocksByRangeRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Start Slot: {}, Count: {}, Step: {}",
+            self.start_slot, self.count, self.step
+        )
+    }
+}
+
+impl slog::Value for RequestId {
+    fn serialize(
+        &self,
+        record: &slog::Record,
+        key: slog::Key,
+        serializer: &mut dyn slog::Serializer,
+    ) -> slog::Result {
+        match self {
+            RequestId::Behaviour => slog::Value::serialize("Behaviour", record, key, serializer),
+            RequestId::Router => slog::Value::serialize("Router", record, key, serializer),
+            RequestId::Sync(ref id) => slog::Value::serialize(id, record, key, serializer),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/rpc/mod.rs

@@ -0,0 +1,222 @@
+//! The Ethereum 2.0 Wire Protocol
+//!
+//! This protocol is a purpose built Ethereum 2.0 libp2p protocol. It's role is to facilitate
+//! direct peer-to-peer communication primarily for sending/receiving chain information for
+//! syncing.
+
+use handler::RPCHandler;
+use libp2p::core::{connection::ConnectionId, ConnectedPoint};
+use libp2p::swarm::{
+    protocols_handler::ProtocolsHandler, NetworkBehaviour, NetworkBehaviourAction, NotifyHandler,
+    PollParameters, SubstreamProtocol,
+};
+use libp2p::{Multiaddr, PeerId};
+use slog::{debug, o};
+use std::marker::PhantomData;
+use std::task::{Context, Poll};
+use std::time::Duration;
+use types::EthSpec;
+
+pub(crate) use handler::HandlerErr;
+pub(crate) use methods::{MetaData, Ping, RPCCodedResponse, RPCResponse};
+pub(crate) use protocol::{RPCProtocol, RPCRequest};
+
+pub use handler::SubstreamId;
+pub use methods::{
+    BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, MaxRequestBlocks,
+    RPCResponseErrorCode, RequestId, ResponseTermination, StatusMessage, MAX_REQUEST_BLOCKS,
+};
+pub use protocol::{Protocol, RPCError};
+
+pub(crate) mod codec;
+mod handler;
+pub mod methods;
+mod protocol;
+
+/// RPC events sent from Lighthouse.
+#[derive(Debug, Clone)]
+pub enum RPCSend<T: EthSpec> {
+    /// A request sent from Lighthouse.
+    ///
+    /// The `RequestId` is given by the application making the request. These
+    /// go over *outbound* connections.
+    Request(RequestId, RPCRequest<T>),
+    /// A response sent from Lighthouse.
+    ///
+    /// The `SubstreamId` must correspond to the RPC-given ID of the original request received from the
+    /// peer. The second parameter is a single chunk of a response. These go over *inbound*
+    /// connections.
+    Response(SubstreamId, RPCCodedResponse<T>),
+}
+
+/// RPC events received from outside Lighthouse.
+#[derive(Debug, Clone)]
+pub enum RPCReceived<T: EthSpec> {
+    /// A request received from the outside.
+    ///
+    /// The `SubstreamId` is given by the `RPCHandler` as it identifies this request with the
+    /// *inbound* substream over which it is managed.
+    Request(SubstreamId, RPCRequest<T>),
+    /// A response received from the outside.
+    ///
+    /// The `RequestId` corresponds to the application given ID of the original request sent to the
+    /// peer. The second parameter is a single chunk of a response. These go over *outbound*
+    /// connections.
+    Response(RequestId, RPCResponse<T>),
+    /// Marks a request as completed
+    EndOfStream(RequestId, ResponseTermination),
+}
+
+impl<T: EthSpec> std::fmt::Display for RPCSend<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCSend::Request(id, req) => write!(f, "RPC Request(id: {:?}, {})", id, req),
+            RPCSend::Response(id, res) => write!(f, "RPC Response(id: {:?}, {})", id, res),
+        }
+    }
+}
+
+/// Messages sent to the user from the RPC protocol.
+pub struct RPCMessage<TSpec: EthSpec> {
+    /// The peer that sent the message.
+    pub peer_id: PeerId,
+    /// Handler managing this message.
+    pub conn_id: ConnectionId,
+    /// The message that was sent.
+    pub event: <RPCHandler<TSpec> as ProtocolsHandler>::OutEvent,
+}
+
+/// Implements the libp2p `NetworkBehaviour` trait and therefore manages network-level
+/// logic.
+pub struct RPC<TSpec: EthSpec> {
+    /// Queue of events to be processed.
+    events: Vec<NetworkBehaviourAction<RPCSend<TSpec>, RPCMessage<TSpec>>>,
+    /// Slog logger for RPC behaviour.
+    log: slog::Logger,
+}
+
+impl<TSpec: EthSpec> RPC<TSpec> {
+    pub fn new(log: slog::Logger) -> Self {
+        let log = log.new(o!("service" => "libp2p_rpc"));
+        RPC {
+            events: Vec::new(),
+            log,
+        }
+    }
+
+    /// Sends an RPC response.
+    ///
+    /// The peer must be connected for this to succeed.
+    pub fn send_response(
+        &mut self,
+        peer_id: PeerId,
+        id: (ConnectionId, SubstreamId),
+        event: RPCCodedResponse<TSpec>,
+    ) {
+        self.events.push(NetworkBehaviourAction::NotifyHandler {
+            peer_id,
+            handler: NotifyHandler::One(id.0),
+            event: RPCSend::Response(id.1, event),
+        });
+    }
+
+    /// Submits an RPC request.
+    ///
+    /// The peer must be connected for this to succeed.
+    pub fn send_request(
+        &mut self,
+        peer_id: PeerId,
+        request_id: RequestId,
+        event: RPCRequest<TSpec>,
+    ) {
+        self.events.push(NetworkBehaviourAction::NotifyHandler {
+            peer_id,
+            handler: NotifyHandler::Any,
+            event: RPCSend::Request(request_id, event),
+        });
+    }
+}
+
+impl<TSpec> NetworkBehaviour for RPC<TSpec>
+where
+    TSpec: EthSpec,
+{
+    type ProtocolsHandler = RPCHandler<TSpec>;
+    type OutEvent = RPCMessage<TSpec>;
+
+    fn new_handler(&mut self) -> Self::ProtocolsHandler {
+        RPCHandler::new(
+            SubstreamProtocol::new(RPCProtocol {
+                phantom: PhantomData,
+            }),
+            Duration::from_secs(30),
+            &self.log,
+        )
+    }
+
+    // handled by discovery
+    fn addresses_of_peer(&mut self, _peer_id: &PeerId) -> Vec<Multiaddr> {
+        Vec::new()
+    }
+
+    // Use connection established/closed instead of these currently
+    fn inject_connected(&mut self, peer_id: &PeerId) {
+        // find the peer's meta-data
+        debug!(self.log, "Requesting new peer's metadata"; "peer_id" => format!("{}",peer_id));
+        let rpc_event = RPCSend::Request(RequestId::Behaviour, RPCRequest::MetaData(PhantomData));
+        self.events.push(NetworkBehaviourAction::NotifyHandler {
+            peer_id: peer_id.clone(),
+            handler: NotifyHandler::Any,
+            event: rpc_event,
+        });
+    }
+
+    fn inject_disconnected(&mut self, _peer_id: &PeerId) {}
+
+    fn inject_connection_established(
+        &mut self,
+        _peer_id: &PeerId,
+        _: &ConnectionId,
+        _connected_point: &ConnectedPoint,
+    ) {
+    }
+
+    fn inject_connection_closed(
+        &mut self,
+        _peer_id: &PeerId,
+        _: &ConnectionId,
+        _connected_point: &ConnectedPoint,
+    ) {
+    }
+
+    fn inject_event(
+        &mut self,
+        peer_id: PeerId,
+        conn_id: ConnectionId,
+        event: <Self::ProtocolsHandler as ProtocolsHandler>::OutEvent,
+    ) {
+        // send the event to the user
+        self.events
+            .push(NetworkBehaviourAction::GenerateEvent(RPCMessage {
+                peer_id,
+                conn_id,
+                event,
+            }));
+    }
+
+    fn poll(
+        &mut self,
+        _cx: &mut Context,
+        _: &mut impl PollParameters,
+    ) -> Poll<
+        NetworkBehaviourAction<
+            <Self::ProtocolsHandler as ProtocolsHandler>::InEvent,
+            Self::OutEvent,
+        >,
+    > {
+        if !self.events.is_empty() {
+            return Poll::Ready(self.events.remove(0));
+        }
+        Poll::Pending
+    }
+}

beacon_node/eth2_libp2p/src/rpc/protocol.rs

@@ -0,0 +1,500 @@
+#![allow(clippy::type_complexity)]
+
+use super::methods::*;
+use crate::rpc::{
+    codec::{
+        base::{BaseInboundCodec, BaseOutboundCodec},
+        ssz::{SSZInboundCodec, SSZOutboundCodec},
+        ssz_snappy::{SSZSnappyInboundCodec, SSZSnappyOutboundCodec},
+        InboundCodec, OutboundCodec,
+    },
+    methods::ResponseTermination,
+    MaxRequestBlocks, MAX_REQUEST_BLOCKS,
+};
+use futures::future::Ready;
+use futures::prelude::*;
+use futures::prelude::{AsyncRead, AsyncWrite};
+use libp2p::core::{InboundUpgrade, OutboundUpgrade, ProtocolName, UpgradeInfo};
+use ssz::Encode;
+use ssz_types::VariableList;
+use std::io;
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::time::Duration;
+use tokio_io_timeout::TimeoutStream;
+use tokio_util::{
+    codec::Framed,
+    compat::{Compat, FuturesAsyncReadCompatExt},
+};
+use types::{BeaconBlock, EthSpec, Hash256, MainnetEthSpec, Signature, SignedBeaconBlock};
+
+lazy_static! {
+    // Note: Hardcoding the `EthSpec` type for `SignedBeaconBlock` as min/max values is
+    // same across different `EthSpec` implementations.
+    pub static ref SIGNED_BEACON_BLOCK_MIN: usize = SignedBeaconBlock::<MainnetEthSpec> {
+        message: BeaconBlock::empty(&MainnetEthSpec::default_spec()),
+        signature: Signature::empty_signature(),
+    }
+    .as_ssz_bytes()
+    .len();
+    pub static ref SIGNED_BEACON_BLOCK_MAX: usize = SignedBeaconBlock::<MainnetEthSpec> {
+        message: BeaconBlock::full(&MainnetEthSpec::default_spec()),
+        signature: Signature::empty_signature(),
+    }
+    .as_ssz_bytes()
+    .len();
+    pub static ref BLOCKS_BY_ROOT_REQUEST_MIN: usize = BlocksByRootRequest {
+        block_roots: VariableList::<Hash256, MaxRequestBlocks>::from(Vec::<Hash256>::new())
+    }
+    .as_ssz_bytes()
+    .len();
+    pub static ref BLOCKS_BY_ROOT_REQUEST_MAX: usize = BlocksByRootRequest {
+        block_roots: VariableList::<Hash256, MaxRequestBlocks>::from(vec![
+            Hash256::zero();
+            MAX_REQUEST_BLOCKS
+                as usize
+        ])
+    }
+    .as_ssz_bytes()
+    .len();
+}
+
+/// The maximum bytes that can be sent across the RPC.
+const MAX_RPC_SIZE: usize = 1_048_576; // 1M
+/// The protocol prefix the RPC protocol id.
+const PROTOCOL_PREFIX: &str = "/eth2/beacon_chain/req";
+/// Time allowed for the first byte of a request to arrive before we time out (Time To First Byte).
+const TTFB_TIMEOUT: u64 = 5;
+/// The number of seconds to wait for the first bytes of a request once a protocol has been
+/// established before the stream is terminated.
+const REQUEST_TIMEOUT: u64 = 15;
+
+/// Protocol names to be used.
+#[derive(Debug, Clone, Copy)]
+pub enum Protocol {
+    /// The Status protocol name.
+    Status,
+    /// The Goodbye protocol name.
+    Goodbye,
+    /// The `BlocksByRange` protocol name.
+    BlocksByRange,
+    /// The `BlocksByRoot` protocol name.
+    BlocksByRoot,
+    /// The `Ping` protocol name.
+    Ping,
+    /// The `MetaData` protocol name.
+    MetaData,
+}
+
+/// RPC Versions
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Version {
+    /// Version 1 of RPC
+    V1,
+}
+
+/// RPC Encondings supported.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Encoding {
+    SSZ,
+    SSZSnappy,
+}
+
+impl std::fmt::Display for Protocol {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = match self {
+            Protocol::Status => "status",
+            Protocol::Goodbye => "goodbye",
+            Protocol::BlocksByRange => "beacon_blocks_by_range",
+            Protocol::BlocksByRoot => "beacon_blocks_by_root",
+            Protocol::Ping => "ping",
+            Protocol::MetaData => "metadata",
+        };
+        f.write_str(repr)
+    }
+}
+
+impl std::fmt::Display for Encoding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = match self {
+            Encoding::SSZ => "ssz",
+            Encoding::SSZSnappy => "ssz_snappy",
+        };
+        f.write_str(repr)
+    }
+}
+
+impl std::fmt::Display for Version {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = match self {
+            Version::V1 => "1",
+        };
+        f.write_str(repr)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct RPCProtocol<TSpec: EthSpec> {
+    pub phantom: PhantomData<TSpec>,
+}
+
+impl<TSpec: EthSpec> UpgradeInfo for RPCProtocol<TSpec> {
+    type Info = ProtocolId;
+    type InfoIter = Vec<Self::Info>;
+
+    /// The list of supported RPC protocols for Lighthouse.
+    fn protocol_info(&self) -> Self::InfoIter {
+        vec![
+            ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZ),
+            ProtocolId::new(Protocol::Goodbye, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::Goodbye, Version::V1, Encoding::SSZ),
+            ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZ),
+            ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZ),
+            ProtocolId::new(Protocol::Ping, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::Ping, Version::V1, Encoding::SSZ),
+            ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZ),
+        ]
+    }
+}
+
+/// Tracks the types in a protocol id.
+#[derive(Clone, Debug)]
+pub struct ProtocolId {
+    /// The RPC message type/name.
+    pub message_name: Protocol,
+
+    /// The version of the RPC.
+    pub version: Version,
+
+    /// The encoding of the RPC.
+    pub encoding: Encoding,
+
+    /// The protocol id that is formed from the above fields.
+    protocol_id: String,
+}
+
+/// An RPC protocol ID.
+impl ProtocolId {
+    pub fn new(message_name: Protocol, version: Version, encoding: Encoding) -> Self {
+        let protocol_id = format!(
+            "{}/{}/{}/{}",
+            PROTOCOL_PREFIX, message_name, version, encoding
+        );
+
+        ProtocolId {
+            message_name,
+            version,
+            encoding,
+            protocol_id,
+        }
+    }
+}
+
+impl ProtocolName for ProtocolId {
+    fn protocol_name(&self) -> &[u8] {
+        self.protocol_id.as_bytes()
+    }
+}
+
+/* Inbound upgrade */
+
+// The inbound protocol reads the request, decodes it and returns the stream to the protocol
+// handler to respond to once ready.
+
+pub type InboundOutput<TSocket, TSpec> = (RPCRequest<TSpec>, InboundFramed<TSocket, TSpec>);
+pub type InboundFramed<TSocket, TSpec> =
+    Framed<TimeoutStream<Compat<TSocket>>, InboundCodec<TSpec>>;
+type FnAndThen<TSocket, TSpec> = fn(
+    (
+        Option<Result<RPCRequest<TSpec>, RPCError>>,
+        InboundFramed<TSocket, TSpec>,
+    ),
+) -> Ready<Result<InboundOutput<TSocket, TSpec>, RPCError>>;
+type FnMapErr = fn(tokio::time::Elapsed) -> RPCError;
+
+impl<TSocket, TSpec> InboundUpgrade<TSocket> for RPCProtocol<TSpec>
+where
+    TSocket: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+    TSpec: EthSpec,
+{
+    type Output = InboundOutput<TSocket, TSpec>;
+    type Error = RPCError;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
+
+    fn upgrade_inbound(self, socket: TSocket, protocol: ProtocolId) -> Self::Future {
+        let protocol_name = protocol.message_name;
+        // convert the socket to tokio compatible socket
+        let socket = socket.compat();
+        let codec = match protocol.encoding {
+            Encoding::SSZSnappy => {
+                let ssz_snappy_codec =
+                    BaseInboundCodec::new(SSZSnappyInboundCodec::new(protocol, MAX_RPC_SIZE));
+                InboundCodec::SSZSnappy(ssz_snappy_codec)
+            }
+            Encoding::SSZ => {
+                let ssz_codec = BaseInboundCodec::new(SSZInboundCodec::new(protocol, MAX_RPC_SIZE));
+                InboundCodec::SSZ(ssz_codec)
+            }
+        };
+        let mut timed_socket = TimeoutStream::new(socket);
+        timed_socket.set_read_timeout(Some(Duration::from_secs(TTFB_TIMEOUT)));
+
+        let socket = Framed::new(timed_socket, codec);
+
+        // MetaData requests should be empty, return the stream
+        Box::pin(match protocol_name {
+            Protocol::MetaData => {
+                future::Either::Left(future::ok((RPCRequest::MetaData(PhantomData), socket)))
+            }
+
+            _ => future::Either::Right(
+                tokio::time::timeout(Duration::from_secs(REQUEST_TIMEOUT), socket.into_future())
+                    .map_err(RPCError::from as FnMapErr)
+                    .and_then({
+                        |(req, stream)| match req {
+                            Some(Ok(request)) => future::ok((request, stream)),
+                            Some(Err(_)) | None => future::err(RPCError::IncompleteStream),
+                        }
+                    } as FnAndThen<TSocket, TSpec>),
+            ),
+        })
+    }
+}
+
+/* Outbound request */
+
+// Combines all the RPC requests into a single enum to implement `UpgradeInfo` and
+// `OutboundUpgrade`
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum RPCRequest<TSpec: EthSpec> {
+    Status(StatusMessage),
+    Goodbye(GoodbyeReason),
+    BlocksByRange(BlocksByRangeRequest),
+    BlocksByRoot(BlocksByRootRequest),
+    Ping(Ping),
+    MetaData(PhantomData<TSpec>),
+}
+
+impl<TSpec: EthSpec> UpgradeInfo for RPCRequest<TSpec> {
+    type Info = ProtocolId;
+    type InfoIter = Vec<Self::Info>;
+
+    // add further protocols as we support more encodings/versions
+    fn protocol_info(&self) -> Self::InfoIter {
+        self.supported_protocols()
+    }
+}
+
+/// Implements the encoding per supported protocol for `RPCRequest`.
+impl<TSpec: EthSpec> RPCRequest<TSpec> {
+    pub fn supported_protocols(&self) -> Vec<ProtocolId> {
+        match self {
+            // add more protocols when versions/encodings are supported
+            RPCRequest::Status(_) => vec![
+                ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZ),
+            ],
+            RPCRequest::Goodbye(_) => vec![
+                ProtocolId::new(Protocol::Goodbye, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::Goodbye, Version::V1, Encoding::SSZ),
+            ],
+            RPCRequest::BlocksByRange(_) => vec![
+                ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZ),
+            ],
+            RPCRequest::BlocksByRoot(_) => vec![
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZ),
+            ],
+            RPCRequest::Ping(_) => vec![
+                ProtocolId::new(Protocol::Ping, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::Ping, Version::V1, Encoding::SSZ),
+            ],
+            RPCRequest::MetaData(_) => vec![
+                ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZ),
+            ],
+        }
+    }
+
+    /* These functions are used in the handler for stream management */
+
+    /// Number of responses expected for this request.
+    pub fn expected_responses(&self) -> usize {
+        match self {
+            RPCRequest::Status(_) => 1,
+            RPCRequest::Goodbye(_) => 0,
+            RPCRequest::BlocksByRange(req) => req.count as usize,
+            RPCRequest::BlocksByRoot(req) => req.block_roots.len(),
+            RPCRequest::Ping(_) => 1,
+            RPCRequest::MetaData(_) => 1,
+        }
+    }
+
+    /// Gives the corresponding `Protocol` to this request.
+    pub fn protocol(&self) -> Protocol {
+        match self {
+            RPCRequest::Status(_) => Protocol::Status,
+            RPCRequest::Goodbye(_) => Protocol::Goodbye,
+            RPCRequest::BlocksByRange(_) => Protocol::BlocksByRange,
+            RPCRequest::BlocksByRoot(_) => Protocol::BlocksByRoot,
+            RPCRequest::Ping(_) => Protocol::Ping,
+            RPCRequest::MetaData(_) => Protocol::MetaData,
+        }
+    }
+
+    /// Returns the `ResponseTermination` type associated with the request if a stream gets
+    /// terminated.
+    pub fn stream_termination(&self) -> ResponseTermination {
+        match self {
+            // this only gets called after `multiple_responses()` returns true. Therefore, only
+            // variants that have `multiple_responses()` can have values.
+            RPCRequest::BlocksByRange(_) => ResponseTermination::BlocksByRange,
+            RPCRequest::BlocksByRoot(_) => ResponseTermination::BlocksByRoot,
+            RPCRequest::Status(_) => unreachable!(),
+            RPCRequest::Goodbye(_) => unreachable!(),
+            RPCRequest::Ping(_) => unreachable!(),
+            RPCRequest::MetaData(_) => unreachable!(),
+        }
+    }
+}
+
+/* RPC Response type - used for outbound upgrades */
+
+/* Outbound upgrades */
+
+pub type OutboundFramed<TSocket, TSpec> = Framed<Compat<TSocket>, OutboundCodec<TSpec>>;
+
+impl<TSocket, TSpec> OutboundUpgrade<TSocket> for RPCRequest<TSpec>
+where
+    TSpec: EthSpec + Send + 'static,
+    TSocket: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+    type Output = OutboundFramed<TSocket, TSpec>;
+    type Error = RPCError;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
+
+    fn upgrade_outbound(self, socket: TSocket, protocol: Self::Info) -> Self::Future {
+        // convert to a tokio compatible socket
+        let socket = socket.compat();
+        let codec = match protocol.encoding {
+            Encoding::SSZSnappy => {
+                let ssz_snappy_codec =
+                    BaseOutboundCodec::new(SSZSnappyOutboundCodec::new(protocol, MAX_RPC_SIZE));
+                OutboundCodec::SSZSnappy(ssz_snappy_codec)
+            }
+            Encoding::SSZ => {
+                let ssz_codec =
+                    BaseOutboundCodec::new(SSZOutboundCodec::new(protocol, MAX_RPC_SIZE));
+                OutboundCodec::SSZ(ssz_codec)
+            }
+        };
+
+        let mut socket = Framed::new(socket, codec);
+
+        let future = async { socket.send(self).await.map(|_| socket) };
+        Box::pin(future)
+    }
+}
+
+/// Error in RPC Encoding/Decoding.
+#[derive(Debug, Clone)]
+pub enum RPCError {
+    /// Error when decoding the raw buffer from ssz.
+    // NOTE: in the future a ssz::DecodeError should map to an InvalidData error
+    SSZDecodeError(ssz::DecodeError),
+    /// IO Error.
+    IoError(String),
+    /// The peer returned a valid response but the response indicated an error.
+    ErrorResponse(RPCResponseErrorCode, String),
+    /// Timed out waiting for a response.
+    StreamTimeout,
+    /// Peer does not support the protocol.
+    UnsupportedProtocol,
+    /// Stream ended unexpectedly.
+    IncompleteStream,
+    /// Peer sent invalid data.
+    InvalidData,
+    /// An error occurred due to internal reasons. Ex: timer failure.
+    InternalError(&'static str),
+    /// Negotiation with this peer timed out.
+    NegotiationTimeout,
+    /// Handler rejected this request.
+    HandlerRejected,
+}
+
+impl From<ssz::DecodeError> for RPCError {
+    #[inline]
+    fn from(err: ssz::DecodeError) -> Self {
+        RPCError::SSZDecodeError(err)
+    }
+}
+impl From<tokio::time::Elapsed> for RPCError {
+    fn from(_: tokio::time::Elapsed) -> Self {
+        RPCError::StreamTimeout
+    }
+}
+
+impl From<io::Error> for RPCError {
+    fn from(err: io::Error) -> Self {
+        RPCError::IoError(err.to_string())
+    }
+}
+
+// Error trait is required for `ProtocolsHandler`
+impl std::fmt::Display for RPCError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            RPCError::SSZDecodeError(ref err) => write!(f, "Error while decoding ssz: {:?}", err),
+            RPCError::InvalidData => write!(f, "Peer sent unexpected data"),
+            RPCError::IoError(ref err) => write!(f, "IO Error: {}", err),
+            RPCError::ErrorResponse(ref code, ref reason) => write!(
+                f,
+                "RPC response was an error: {} with reason: {}",
+                code, reason
+            ),
+            RPCError::StreamTimeout => write!(f, "Stream Timeout"),
+            RPCError::UnsupportedProtocol => write!(f, "Peer does not support the protocol"),
+            RPCError::IncompleteStream => write!(f, "Stream ended unexpectedly"),
+            RPCError::InternalError(ref err) => write!(f, "Internal error: {}", err),
+            RPCError::NegotiationTimeout => write!(f, "Negotiation timeout"),
+            RPCError::HandlerRejected => write!(f, "Handler rejected the request"),
+        }
+    }
+}
+
+impl std::error::Error for RPCError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            // NOTE: this does have a source
+            RPCError::SSZDecodeError(_) => None,
+            RPCError::IoError(_) => None,
+            RPCError::StreamTimeout => None,
+            RPCError::UnsupportedProtocol => None,
+            RPCError::IncompleteStream => None,
+            RPCError::InvalidData => None,
+            RPCError::InternalError(_) => None,
+            RPCError::ErrorResponse(_, _) => None,
+            RPCError::NegotiationTimeout => None,
+            RPCError::HandlerRejected => None,
+        }
+    }
+}
+
+impl<TSpec: EthSpec> std::fmt::Display for RPCRequest<TSpec> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RPCRequest::Status(status) => write!(f, "Status Message: {}", status),
+            RPCRequest::Goodbye(reason) => write!(f, "Goodbye: {}", reason),
+            RPCRequest::BlocksByRange(req) => write!(f, "Blocks by range: {}", req),
+            RPCRequest::BlocksByRoot(req) => write!(f, "Blocks by root: {:?}", req),
+            RPCRequest::Ping(ping) => write!(f, "Ping: {}", ping.data),
+            RPCRequest::MetaData(_) => write!(f, "MetaData request"),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/service.rs

@@ -0,0 +1,470 @@
+use crate::behaviour::{Behaviour, BehaviourEvent, PeerRequestId, Request, Response};
+use crate::discovery::enr;
+use crate::multiaddr::Protocol;
+use crate::rpc::{RPCResponseErrorCode, RequestId};
+use crate::types::{error, GossipKind};
+use crate::EnrExt;
+use crate::{NetworkConfig, NetworkGlobals};
+use futures::prelude::*;
+use libp2p::core::{
+    identity::Keypair, multiaddr::Multiaddr, muxing::StreamMuxerBox, transport::boxed::Boxed,
+    ConnectedPoint,
+};
+use libp2p::{
+    core, noise,
+    swarm::{NetworkBehaviour, SwarmBuilder, SwarmEvent},
+    PeerId, Swarm, Transport,
+};
+use slog::{crit, debug, info, o, trace, warn};
+use std::fs::File;
+use std::io::prelude::*;
+use std::io::{Error, ErrorKind};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::DelayQueue;
+use types::{EnrForkId, EthSpec};
+
+pub const NETWORK_KEY_FILENAME: &str = "key";
+/// The time in milliseconds to wait before banning a peer. This allows for any Goodbye messages to be
+/// flushed and protocols to be negotiated.
+const BAN_PEER_WAIT_TIMEOUT: u64 = 200;
+/// The maximum simultaneous libp2p connections per peer.
+const MAX_CONNECTIONS_PER_PEER: usize = 1;
+
+/// The types of events than can be obtained from polling the libp2p service.
+///
+/// This is a subset of the events that a libp2p swarm emits.
+#[derive(Debug)]
+pub enum Libp2pEvent<TSpec: EthSpec> {
+    /// A behaviour event
+    Behaviour(BehaviourEvent<TSpec>),
+    /// A new listening address has been established.
+    NewListenAddr(Multiaddr),
+    /// A peer has established at least one connection.
+    PeerConnected {
+        /// The peer that connected.
+        peer_id: PeerId,
+        /// Whether the peer was a dialer or listener.
+        endpoint: ConnectedPoint,
+    },
+    /// A peer no longer has any connections, i.e is disconnected.
+    PeerDisconnected {
+        /// The peer the disconnected.
+        peer_id: PeerId,
+        /// Whether the peer was a dialer or a listener.
+        endpoint: ConnectedPoint,
+    },
+}
+
+/// The configuration and state of the libp2p components for the beacon node.
+pub struct Service<TSpec: EthSpec> {
+    /// The libp2p Swarm handler.
+    //TODO: Make this private
+    pub swarm: Swarm<Behaviour<TSpec>>,
+
+    /// This node's PeerId.
+    pub local_peer_id: PeerId,
+
+    /// Used for managing the state of peers.
+    network_globals: Arc<NetworkGlobals<TSpec>>,
+
+    /// A current list of peers to ban after a given timeout.
+    peers_to_ban: DelayQueue<PeerId>,
+
+    /// A list of timeouts after which peers become unbanned.
+    peer_ban_timeout: DelayQueue<PeerId>,
+
+    /// The libp2p logger handle.
+    pub log: slog::Logger,
+}
+
+impl<TSpec: EthSpec> Service<TSpec> {
+    pub fn new(
+        executor: environment::TaskExecutor,
+        config: &NetworkConfig,
+        enr_fork_id: EnrForkId,
+        log: &slog::Logger,
+    ) -> error::Result<(Arc<NetworkGlobals<TSpec>>, Self)> {
+        let log = log.new(o!("service"=> "libp2p"));
+        trace!(log, "Libp2p Service starting");
+
+        // initialise the node's ID
+        let local_keypair = load_private_key(config, &log);
+
+        // Create an ENR or load from disk if appropriate
+        let enr =
+            enr::build_or_load_enr::<TSpec>(local_keypair.clone(), config, enr_fork_id, &log)?;
+
+        let local_peer_id = enr.peer_id();
+        // set up a collection of variables accessible outside of the network crate
+        let network_globals = Arc::new(NetworkGlobals::new(
+            enr.clone(),
+            config.libp2p_port,
+            config.discovery_port,
+            &log,
+        ));
+
+        info!(log, "Libp2p Service"; "peer_id" => format!("{:?}", enr.peer_id()));
+        debug!(log, "Attempting to open listening ports"; "address" => format!("{}", config.listen_address), "tcp_port" => config.libp2p_port, "udp_port" => config.discovery_port);
+
+        let mut swarm = {
+            // Set up the transport - tcp/ws with noise and yamux/mplex
+            let transport = build_transport(local_keypair.clone())
+                .map_err(|e| format!("Failed to build transport: {:?}", e))?;
+            // Lighthouse network behaviour
+            let behaviour = Behaviour::new(&local_keypair, config, network_globals.clone(), &log)?;
+
+            // use the executor for libp2p
+            struct Executor(environment::TaskExecutor);
+            impl libp2p::core::Executor for Executor {
+                fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+                    self.0.spawn(f, "libp2p");
+                }
+            }
+            SwarmBuilder::new(transport, behaviour, local_peer_id.clone())
+                .peer_connection_limit(MAX_CONNECTIONS_PER_PEER)
+                .executor(Box::new(Executor(executor)))
+                .build()
+        };
+
+        // listen on the specified address
+        let listen_multiaddr = {
+            let mut m = Multiaddr::from(config.listen_address);
+            m.push(Protocol::Tcp(config.libp2p_port));
+            m
+        };
+
+        match Swarm::listen_on(&mut swarm, listen_multiaddr.clone()) {
+            Ok(_) => {
+                let mut log_address = listen_multiaddr;
+                log_address.push(Protocol::P2p(local_peer_id.clone().into()));
+                info!(log, "Listening established"; "address" => format!("{}", log_address));
+            }
+            Err(err) => {
+                crit!(
+                    log,
+                    "Unable to listen on libp2p address";
+                    "error" => format!("{:?}", err),
+                    "listen_multiaddr" => format!("{}", listen_multiaddr),
+                );
+                return Err("Libp2p was unable to listen on the given listen address.".into());
+            }
+        };
+
+        // helper closure for dialing peers
+        let mut dial_addr = |multiaddr: &Multiaddr| {
+            match Swarm::dial_addr(&mut swarm, multiaddr.clone()) {
+                Ok(()) => debug!(log, "Dialing libp2p peer"; "address" => format!("{}", multiaddr)),
+                Err(err) => debug!(
+                    log,
+                    "Could not connect to peer"; "address" => format!("{}", multiaddr), "error" => format!("{:?}", err)
+                ),
+            };
+        };
+
+        // attempt to connect to user-input libp2p nodes
+        for multiaddr in &config.libp2p_nodes {
+            dial_addr(multiaddr);
+        }
+
+        // attempt to connect to any specified boot-nodes
+        let mut boot_nodes = config.boot_nodes.clone();
+        boot_nodes.dedup();
+
+        for bootnode_enr in boot_nodes {
+            for multiaddr in &bootnode_enr.multiaddr() {
+                // ignore udp multiaddr if it exists
+                let components = multiaddr.iter().collect::<Vec<_>>();
+                if let Protocol::Udp(_) = components[1] {
+                    continue;
+                }
+
+                if !network_globals
+                    .peers
+                    .read()
+                    .is_connected_or_dialing(&bootnode_enr.peer_id())
+                {
+                    dial_addr(multiaddr);
+                }
+            }
+        }
+
+        let mut subscribed_topics: Vec<GossipKind> = vec![];
+        for topic_kind in &config.topics {
+            if swarm.subscribe_kind(topic_kind.clone()) {
+                subscribed_topics.push(topic_kind.clone());
+            } else {
+                warn!(log, "Could not subscribe to topic"; "topic" => format!("{}",topic_kind));
+            }
+        }
+        info!(log, "Subscribed to topics"; "topics" => format!("{:?}", subscribed_topics));
+
+        let service = Service {
+            local_peer_id,
+            swarm,
+            network_globals: network_globals.clone(),
+            peers_to_ban: DelayQueue::new(),
+            peer_ban_timeout: DelayQueue::new(),
+            log,
+        };
+
+        Ok((network_globals, service))
+    }
+
+    /// Adds a peer to be banned for a period of time, specified by a timeout.
+    pub fn disconnect_and_ban_peer(&mut self, peer_id: PeerId, timeout: Duration) {
+        warn!(self.log, "Disconnecting and banning peer"; "peer_id" => peer_id.to_string(), "timeout" => format!("{:?}", timeout));
+        self.peers_to_ban.insert(
+            peer_id.clone(),
+            Duration::from_millis(BAN_PEER_WAIT_TIMEOUT),
+        );
+        self.peer_ban_timeout.insert(peer_id, timeout);
+    }
+
+    /// Sends a request to a peer, with a given Id.
+    pub fn send_request(&mut self, peer_id: PeerId, request_id: RequestId, request: Request) {
+        self.swarm.send_request(peer_id, request_id, request);
+    }
+
+    /// Informs the peer that their request failed.
+    pub fn respond_with_error(
+        &mut self,
+        peer_id: PeerId,
+        id: PeerRequestId,
+        error: RPCResponseErrorCode,
+        reason: String,
+    ) {
+        self.swarm._send_error_reponse(peer_id, id, error, reason);
+    }
+
+    /// Sends a response to a peer's request.
+    pub fn send_response(&mut self, peer_id: PeerId, id: PeerRequestId, response: Response<TSpec>) {
+        self.swarm.send_successful_response(peer_id, id, response);
+    }
+
+    pub async fn next_event(&mut self) -> Libp2pEvent<TSpec> {
+        loop {
+            tokio::select! {
+                event = self.swarm.next_event() => {
+                    match event {
+                        SwarmEvent::Behaviour(behaviour) => {
+                            return Libp2pEvent::Behaviour(behaviour)
+                        }
+                        SwarmEvent::ConnectionEstablished {
+                            peer_id,
+                            endpoint,
+                            num_established,
+                        } => {
+                            debug!(self.log, "Connection established"; "peer_id" => peer_id.to_string(), "connections" => num_established.get());
+                            // if this is the first connection inform the network layer a new connection
+                            // has been established and update the db
+                            if num_established.get() == 1 {
+                                // update the peerdb
+                                match endpoint {
+                                    ConnectedPoint::Listener { .. } => {
+                                        self.swarm.peer_manager().connect_ingoing(&peer_id);
+                                    }
+                                    ConnectedPoint::Dialer { .. } => self
+                                        .network_globals
+                                        .peers
+                                        .write()
+                                        .connect_outgoing(&peer_id),
+                                }
+                                return Libp2pEvent::PeerConnected { peer_id, endpoint };
+                            }
+                        }
+                        SwarmEvent::ConnectionClosed {
+                            peer_id,
+                            cause,
+                            endpoint,
+                            num_established,
+                        } => {
+                            debug!(self.log, "Connection closed"; "peer_id"=> peer_id.to_string(), "cause" => cause.to_string(), "connections" => num_established);
+                            if num_established == 0 {
+                                // update the peer_db
+                                self.swarm.peer_manager().notify_disconnect(&peer_id);
+                                // the peer has disconnected
+                                return Libp2pEvent::PeerDisconnected {
+                                    peer_id,
+                                    endpoint,
+                                };
+                            }
+                        }
+                        SwarmEvent::NewListenAddr(multiaddr) => {
+                            return Libp2pEvent::NewListenAddr(multiaddr)
+                        }
+
+                        SwarmEvent::IncomingConnection {
+                            local_addr,
+                            send_back_addr,
+                        } => {
+                            debug!(self.log, "Incoming connection"; "our_addr" => local_addr.to_string(), "from" => send_back_addr.to_string())
+                        }
+                        SwarmEvent::IncomingConnectionError {
+                            local_addr,
+                            send_back_addr,
+                            error,
+                        } => {
+                            debug!(self.log, "Failed incoming connection"; "our_addr" => local_addr.to_string(), "from" => send_back_addr.to_string(), "error" => error.to_string())
+                        }
+                        SwarmEvent::BannedPeer {
+                            peer_id,
+                            endpoint: _,
+                        } => {
+                            debug!(self.log, "Attempted to dial a banned peer"; "peer_id" => peer_id.to_string())
+                        }
+                        SwarmEvent::UnreachableAddr {
+                            peer_id,
+                            address,
+                            error,
+                            attempts_remaining,
+                        } => {
+                            debug!(self.log, "Failed to dial address"; "peer_id" => peer_id.to_string(), "address" => address.to_string(), "error" => error.to_string(), "attempts_remaining" => attempts_remaining);
+                            self.swarm.peer_manager().notify_disconnect(&peer_id);
+                        }
+                        SwarmEvent::UnknownPeerUnreachableAddr { address, error } => {
+                            debug!(self.log, "Peer not known at dialed address"; "address" => address.to_string(), "error" => error.to_string());
+                        }
+                        SwarmEvent::ExpiredListenAddr(multiaddr) => {
+                            debug!(self.log, "Listen address expired"; "multiaddr" => multiaddr.to_string())
+                        }
+                        SwarmEvent::ListenerClosed { addresses, reason } => {
+                            debug!(self.log, "Listener closed"; "addresses" => format!("{:?}", addresses), "reason" => format!("{:?}", reason))
+                        }
+                        SwarmEvent::ListenerError { error } => {
+                            debug!(self.log, "Listener error"; "error" => format!("{:?}", error.to_string()))
+                        }
+                        SwarmEvent::Dialing(peer_id) => {
+                            self.swarm.peer_manager().dialing_peer(&peer_id);
+                        }
+                    }
+                }
+                Some(Ok(peer_to_ban)) = self.peers_to_ban.next() => {
+                    let peer_id = peer_to_ban.into_inner();
+                    Swarm::ban_peer_id(&mut self.swarm, peer_id.clone());
+                    // TODO: Correctly notify protocols of the disconnect
+                    // TODO: Also remove peer from the DHT: https://github.com/sigp/lighthouse/issues/629
+                    self.swarm.inject_disconnected(&peer_id);
+                    // inform the behaviour that the peer has been banned
+                    self.swarm.peer_banned(peer_id);
+                }
+                Some(Ok(peer_to_unban)) = self.peer_ban_timeout.next() => {
+                    debug!(self.log, "Peer has been unbanned"; "peer" => format!("{:?}", peer_to_unban));
+                    let unban_peer = peer_to_unban.into_inner();
+                    self.swarm.peer_unbanned(&unban_peer);
+                    Swarm::unban_peer_id(&mut self.swarm, unban_peer);
+                }
+            }
+        }
+    }
+}
+
+/// The implementation supports TCP/IP, WebSockets over TCP/IP, noise as the encryption layer, and
+/// yamux or mplex as the multiplexing layer.
+fn build_transport(
+    local_private_key: Keypair,
+) -> Result<Boxed<(PeerId, StreamMuxerBox), Error>, Error> {
+    let transport = libp2p_tcp::TokioTcpConfig::new().nodelay(true);
+    let transport = libp2p::dns::DnsConfig::new(transport)?;
+    #[cfg(feature = "libp2p-websocket")]
+    let transport = {
+        let trans_clone = transport.clone();
+        transport.or_transport(libp2p::websocket::WsConfig::new(trans_clone))
+    };
+    // Authentication
+    Ok(transport
+        .upgrade(core::upgrade::Version::V1)
+        .authenticate(generate_noise_config(&local_private_key))
+        .multiplex(core::upgrade::SelectUpgrade::new(
+            libp2p::yamux::Config::default(),
+            libp2p::mplex::MplexConfig::new(),
+        ))
+        .map(|(peer, muxer), _| (peer, core::muxing::StreamMuxerBox::new(muxer)))
+        .timeout(Duration::from_secs(20))
+        .timeout(Duration::from_secs(20))
+        .map_err(|err| Error::new(ErrorKind::Other, err))
+        .boxed())
+}
+
+// Useful helper functions for debugging. Currently not used in the client.
+#[allow(dead_code)]
+fn keypair_from_hex(hex_bytes: &str) -> error::Result<Keypair> {
+    let hex_bytes = if hex_bytes.starts_with("0x") {
+        hex_bytes[2..].to_string()
+    } else {
+        hex_bytes.to_string()
+    };
+
+    hex::decode(&hex_bytes)
+        .map_err(|e| format!("Failed to parse p2p secret key bytes: {:?}", e).into())
+        .and_then(keypair_from_bytes)
+}
+
+#[allow(dead_code)]
+fn keypair_from_bytes(mut bytes: Vec<u8>) -> error::Result<Keypair> {
+    libp2p::core::identity::secp256k1::SecretKey::from_bytes(&mut bytes)
+        .map(|secret| {
+            let keypair: libp2p::core::identity::secp256k1::Keypair = secret.into();
+            Keypair::Secp256k1(keypair)
+        })
+        .map_err(|e| format!("Unable to parse p2p secret key: {:?}", e).into())
+}
+
+/// Loads a private key from disk. If this fails, a new key is
+/// generated and is then saved to disk.
+///
+/// Currently only secp256k1 keys are allowed, as these are the only keys supported by discv5.
+fn load_private_key(config: &NetworkConfig, log: &slog::Logger) -> Keypair {
+    // TODO: Currently using secp256k1 keypairs - currently required for discv5
+    // check for key from disk
+    let network_key_f = config.network_dir.join(NETWORK_KEY_FILENAME);
+    if let Ok(mut network_key_file) = File::open(network_key_f.clone()) {
+        let mut key_bytes: Vec<u8> = Vec::with_capacity(36);
+        match network_key_file.read_to_end(&mut key_bytes) {
+            Err(_) => debug!(log, "Could not read network key file"),
+            Ok(_) => {
+                // only accept secp256k1 keys for now
+                if let Ok(secret_key) =
+                    libp2p::core::identity::secp256k1::SecretKey::from_bytes(&mut key_bytes)
+                {
+                    let kp: libp2p::core::identity::secp256k1::Keypair = secret_key.into();
+                    debug!(log, "Loaded network key from disk.");
+                    return Keypair::Secp256k1(kp);
+                } else {
+                    debug!(log, "Network key file is not a valid secp256k1 key");
+                }
+            }
+        }
+    }
+
+    // if a key could not be loaded from disk, generate a new one and save it
+    let local_private_key = Keypair::generate_secp256k1();
+    if let Keypair::Secp256k1(key) = local_private_key.clone() {
+        let _ = std::fs::create_dir_all(&config.network_dir);
+        match File::create(network_key_f.clone())
+            .and_then(|mut f| f.write_all(&key.secret().to_bytes()))
+        {
+            Ok(_) => {
+                debug!(log, "New network key generated and written to disk");
+            }
+            Err(e) => {
+                warn!(
+                    log,
+                    "Could not write node key to file: {:?}. error: {}", network_key_f, e
+                );
+            }
+        }
+    }
+    local_private_key
+}
+
+/// Generate authenticated XX Noise config from identity keys
+fn generate_noise_config(
+    identity_keypair: &Keypair,
+) -> noise::NoiseAuthenticated<noise::XX, noise::X25519Spec, ()> {
+    let static_dh_keys = noise::Keypair::<noise::X25519Spec>::new()
+        .into_authentic(identity_keypair)
+        .expect("signing can fail only once during starting a node");
+    noise::NoiseConfig::xx(static_dh_keys).into_authenticated()
+}

beacon_node/eth2_libp2p/src/types/error.rs

@@ -0,0 +1,5 @@
+// generates error types
+
+use error_chain::error_chain;
+
+error_chain! {}

beacon_node/eth2_libp2p/src/types/globals.rs

@@ -0,0 +1,135 @@
+//! A collection of variables that are accessible outside of the network thread itself.
+use crate::peer_manager::PeerDB;
+use crate::rpc::methods::MetaData;
+use crate::types::SyncState;
+use crate::Client;
+use crate::EnrExt;
+use crate::{Enr, Eth2Enr, GossipTopic, Multiaddr, PeerId};
+use parking_lot::RwLock;
+use std::collections::HashSet;
+use std::sync::atomic::{AtomicU16, Ordering};
+use types::EthSpec;
+
+pub struct NetworkGlobals<TSpec: EthSpec> {
+    /// The current local ENR.
+    pub local_enr: RwLock<Enr>,
+    /// The current node's meta-data.
+    pub meta_data: RwLock<MetaData<TSpec>>,
+    /// The local peer_id.
+    pub peer_id: RwLock<PeerId>,
+    /// Listening multiaddrs.
+    pub listen_multiaddrs: RwLock<Vec<Multiaddr>>,
+    /// The TCP port that the libp2p service is listening on
+    pub listen_port_tcp: AtomicU16,
+    /// The UDP port that the discovery service is listening on
+    pub listen_port_udp: AtomicU16,
+    /// The collection of known peers.
+    pub peers: RwLock<PeerDB<TSpec>>,
+    /// The current gossipsub topic subscriptions.
+    pub gossipsub_subscriptions: RwLock<HashSet<GossipTopic>>,
+    /// The current sync status of the node.
+    pub sync_state: RwLock<SyncState>,
+}
+
+impl<TSpec: EthSpec> NetworkGlobals<TSpec> {
+    pub fn new(enr: Enr, tcp_port: u16, udp_port: u16, log: &slog::Logger) -> Self {
+        // set up the local meta data of the node
+        let meta_data = RwLock::new(MetaData {
+            seq_number: 0,
+            attnets: enr
+                .bitfield::<TSpec>()
+                .expect("Local ENR must have a bitfield specified"),
+        });
+
+        NetworkGlobals {
+            local_enr: RwLock::new(enr.clone()),
+            meta_data,
+            peer_id: RwLock::new(enr.peer_id()),
+            listen_multiaddrs: RwLock::new(Vec::new()),
+            listen_port_tcp: AtomicU16::new(tcp_port),
+            listen_port_udp: AtomicU16::new(udp_port),
+            peers: RwLock::new(PeerDB::new(log)),
+            gossipsub_subscriptions: RwLock::new(HashSet::new()),
+            sync_state: RwLock::new(SyncState::Stalled),
+        }
+    }
+
+    /// Returns the local ENR from the underlying Discv5 behaviour that external peers may connect
+    /// to.
+    pub fn local_enr(&self) -> Enr {
+        self.local_enr.read().clone()
+    }
+
+    /// Returns the local libp2p PeerID.
+    pub fn local_peer_id(&self) -> PeerId {
+        self.peer_id.read().clone()
+    }
+
+    /// Returns the list of `Multiaddr` that the underlying libp2p instance is listening on.
+    pub fn listen_multiaddrs(&self) -> Vec<Multiaddr> {
+        self.listen_multiaddrs.read().clone()
+    }
+
+    /// Returns the libp2p TCP port that this node has been configured to listen on.
+    pub fn listen_port_tcp(&self) -> u16 {
+        self.listen_port_tcp.load(Ordering::Relaxed)
+    }
+
+    /// Returns the UDP discovery port that this node has been configured to listen on.
+    pub fn listen_port_udp(&self) -> u16 {
+        self.listen_port_udp.load(Ordering::Relaxed)
+    }
+
+    /// Returns the number of libp2p connected peers.
+    pub fn connected_peers(&self) -> usize {
+        self.peers.read().connected_peer_ids().count()
+    }
+
+    /// Returns the number of libp2p peers that are either connected or being dialed.
+    pub fn connected_or_dialing_peers(&self) -> usize {
+        self.peers.read().connected_or_dialing_peers().count()
+    }
+
+    /// Returns in the node is syncing.
+    pub fn is_syncing(&self) -> bool {
+        self.sync_state.read().is_syncing()
+    }
+
+    /// Returns the current sync state of the peer.
+    pub fn sync_state(&self) -> SyncState {
+        self.sync_state.read().clone()
+    }
+
+    /// Returns a `Client` type if one is known for the `PeerId`.
+    pub fn client(&self, peer_id: &PeerId) -> Client {
+        self.peers
+            .read()
+            .peer_info(peer_id)
+            .map(|info| info.client.clone())
+            .unwrap_or_default()
+    }
+
+    /// Updates the syncing state of the node.
+    ///
+    /// If there is a new state, the old state and the new states are returned.
+    pub fn update_sync_state(&self) -> Option<(SyncState, SyncState)> {
+        let mut result = None;
+        // if we are in a range sync, nothing changes. Range sync will update this.
+        if !self.is_syncing() {
+            let new_state = self
+                .peers
+                .read()
+                .synced_peers()
+                .next()
+                .map(|_| SyncState::Synced)
+                .unwrap_or_else(|| SyncState::Stalled);
+
+            let mut peer_state = self.sync_state.write();
+            if new_state != *peer_state {
+                result = Some((peer_state.clone(), new_state.clone()));
+            }
+            *peer_state = new_state;
+        }
+        result
+    }
+}

beacon_node/eth2_libp2p/src/types/mod.rs

@@ -0,0 +1,17 @@
+pub mod error;
+mod globals;
+mod pubsub;
+mod sync_state;
+mod topics;
+
+use types::{BitVector, EthSpec};
+
+#[allow(type_alias_bounds)]
+pub type EnrBitfield<T: EthSpec> = BitVector<T::SubnetBitfieldLength>;
+
+pub type Enr = discv5::enr::Enr<discv5::enr::CombinedKey>;
+
+pub use globals::NetworkGlobals;
+pub use pubsub::PubsubMessage;
+pub use sync_state::SyncState;
+pub use topics::{GossipEncoding, GossipKind, GossipTopic};

beacon_node/eth2_libp2p/src/types/pubsub.rs

@@ -0,0 +1,193 @@
+//! Handles the encoding and decoding of pubsub messages.
+
+use crate::config::GOSSIP_MAX_SIZE;
+use crate::types::{GossipEncoding, GossipKind, GossipTopic};
+use crate::TopicHash;
+use snap::raw::{decompress_len, Decoder, Encoder};
+use ssz::{Decode, Encode};
+use std::boxed::Box;
+use types::SubnetId;
+use types::{
+    Attestation, AttesterSlashing, EthSpec, ProposerSlashing, SignedAggregateAndProof,
+    SignedBeaconBlock, SignedVoluntaryExit,
+};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum PubsubMessage<T: EthSpec> {
+    /// Gossipsub message providing notification of a new block.
+    BeaconBlock(Box<SignedBeaconBlock<T>>),
+    /// Gossipsub message providing notification of a Aggregate attestation and associated proof.
+    AggregateAndProofAttestation(Box<SignedAggregateAndProof<T>>),
+    /// Gossipsub message providing notification of a raw un-aggregated attestation with its shard id.
+    Attestation(Box<(SubnetId, Attestation<T>)>),
+    /// Gossipsub message providing notification of a voluntary exit.
+    VoluntaryExit(Box<SignedVoluntaryExit>),
+    /// Gossipsub message providing notification of a new proposer slashing.
+    ProposerSlashing(Box<ProposerSlashing>),
+    /// Gossipsub message providing notification of a new attester slashing.
+    AttesterSlashing(Box<AttesterSlashing<T>>),
+}
+
+impl<T: EthSpec> PubsubMessage<T> {
+    /// Returns the topics that each pubsub message will be sent across, given a supported
+    /// gossipsub encoding and fork version.
+    pub fn topics(&self, encoding: GossipEncoding, fork_version: [u8; 4]) -> Vec<GossipTopic> {
+        vec![GossipTopic::new(self.kind(), encoding, fork_version)]
+    }
+
+    /// Returns the kind of gossipsub topic associated with the message.
+    pub fn kind(&self) -> GossipKind {
+        match self {
+            PubsubMessage::BeaconBlock(_) => GossipKind::BeaconBlock,
+            PubsubMessage::AggregateAndProofAttestation(_) => GossipKind::BeaconAggregateAndProof,
+            PubsubMessage::Attestation(attestation_data) => {
+                GossipKind::Attestation(attestation_data.0)
+            }
+            PubsubMessage::VoluntaryExit(_) => GossipKind::VoluntaryExit,
+            PubsubMessage::ProposerSlashing(_) => GossipKind::ProposerSlashing,
+            PubsubMessage::AttesterSlashing(_) => GossipKind::AttesterSlashing,
+        }
+    }
+
+    /// This decodes `data` into a `PubsubMessage` given a list of topics.
+    ///
+    /// The topics are checked
+    /// in order and as soon as one topic matches the decoded data, we return the data.
+    /* Note: This is assuming we are not hashing topics. If we choose to hash topics, these will
+     * need to be modified.
+     *
+     * Also note that a message can be associated with many topics. As soon as one of the topics is
+     * known we match. If none of the topics are known we return an unknown state.
+     */
+    pub fn decode(topics: &[TopicHash], data: &[u8]) -> Result<Self, String> {
+        let mut unknown_topics = Vec::new();
+        for topic in topics {
+            match GossipTopic::decode(topic.as_str()) {
+                Err(_) => {
+                    unknown_topics.push(topic);
+                    continue;
+                }
+                Ok(gossip_topic) => {
+                    let ref decompressed_data = match gossip_topic.encoding() {
+                        GossipEncoding::SSZSnappy => {
+                            // Exit early if uncompressed data is > GOSSIP_MAX_SIZE
+                            match decompress_len(data) {
+                                Ok(n) if n > GOSSIP_MAX_SIZE => {
+                                    return Err("ssz_snappy decoded data > GOSSIP_MAX_SIZE".into());
+                                }
+                                Ok(_) => {}
+                                Err(e) => {
+                                    return Err(format!("{}", e));
+                                }
+                            };
+                            let mut decoder = Decoder::new();
+                            match decoder.decompress_vec(data) {
+                                Ok(decompressed_data) => decompressed_data,
+                                Err(e) => return Err(format!("{}", e)),
+                            }
+                        }
+                    };
+                    // the ssz decoders
+                    match gossip_topic.kind() {
+                        GossipKind::BeaconAggregateAndProof => {
+                            let agg_and_proof =
+                                SignedAggregateAndProof::from_ssz_bytes(decompressed_data)
+                                    .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::AggregateAndProofAttestation(Box::new(
+                                agg_and_proof,
+                            )));
+                        }
+                        GossipKind::Attestation(subnet_id) => {
+                            let attestation = Attestation::from_ssz_bytes(decompressed_data)
+                                .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::Attestation(Box::new((
+                                *subnet_id,
+                                attestation,
+                            ))));
+                        }
+                        GossipKind::BeaconBlock => {
+                            let beacon_block = SignedBeaconBlock::from_ssz_bytes(decompressed_data)
+                                .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::BeaconBlock(Box::new(beacon_block)));
+                        }
+                        GossipKind::VoluntaryExit => {
+                            let voluntary_exit =
+                                SignedVoluntaryExit::from_ssz_bytes(decompressed_data)
+                                    .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::VoluntaryExit(Box::new(voluntary_exit)));
+                        }
+                        GossipKind::ProposerSlashing => {
+                            let proposer_slashing =
+                                ProposerSlashing::from_ssz_bytes(decompressed_data)
+                                    .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::ProposerSlashing(Box::new(
+                                proposer_slashing,
+                            )));
+                        }
+                        GossipKind::AttesterSlashing => {
+                            let attester_slashing =
+                                AttesterSlashing::from_ssz_bytes(decompressed_data)
+                                    .map_err(|e| format!("{:?}", e))?;
+                            return Ok(PubsubMessage::AttesterSlashing(Box::new(
+                                attester_slashing,
+                            )));
+                        }
+                    }
+                }
+            }
+        }
+        Err(format!("Unknown gossipsub topics: {:?}", unknown_topics))
+    }
+
+    /// Encodes a `PubsubMessage` based on the topic encodings. The first known encoding is used. If
+    /// no encoding is known, and error is returned.
+    pub fn encode(&self, encoding: GossipEncoding) -> Result<Vec<u8>, String> {
+        let data = match &self {
+            PubsubMessage::BeaconBlock(data) => data.as_ssz_bytes(),
+            PubsubMessage::AggregateAndProofAttestation(data) => data.as_ssz_bytes(),
+            PubsubMessage::VoluntaryExit(data) => data.as_ssz_bytes(),
+            PubsubMessage::ProposerSlashing(data) => data.as_ssz_bytes(),
+            PubsubMessage::AttesterSlashing(data) => data.as_ssz_bytes(),
+            PubsubMessage::Attestation(data) => data.1.as_ssz_bytes(),
+        };
+        match encoding {
+            GossipEncoding::SSZSnappy => {
+                let mut encoder = Encoder::new();
+                match encoder.compress_vec(&data) {
+                    Ok(compressed) if compressed.len() > GOSSIP_MAX_SIZE => {
+                        Err("ssz_snappy Encoded data > GOSSIP_MAX_SIZE".into())
+                    }
+                    Ok(compressed) => Ok(compressed),
+                    Err(e) => Err(format!("{}", e)),
+                }
+            }
+        }
+    }
+}
+
+impl<T: EthSpec> std::fmt::Display for PubsubMessage<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PubsubMessage::BeaconBlock(block) => write!(
+                f,
+                "Beacon Block: slot: {}, proposer_index: {}",
+                block.message.slot, block.message.proposer_index
+            ),
+            PubsubMessage::AggregateAndProofAttestation(att) => write!(
+                f,
+                "Aggregate and Proof: slot: {}, index: {}, aggregator_index: {}",
+                att.message.aggregate.data.slot,
+                att.message.aggregate.data.index,
+                att.message.aggregator_index,
+            ),
+            PubsubMessage::Attestation(data) => write!(
+                f,
+                "Attestation: subnet_id: {}, attestation_slot: {}, attestation_index: {}",
+                *data.0, data.1.data.slot, data.1.data.index,
+            ),
+            PubsubMessage::VoluntaryExit(_data) => write!(f, "Voluntary Exit"),
+            PubsubMessage::ProposerSlashing(_data) => write!(f, "Proposer Slashing"),
+            PubsubMessage::AttesterSlashing(_data) => write!(f, "Attester Slashing"),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/types/sync_state.rs

@@ -0,0 +1,66 @@
+use serde::{Deserialize, Serialize};
+use types::{Hash256, Slot};
+
+/// The current state of the node.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum SyncState {
+    /// The node is performing a long-range (batch) sync over a finalized chain.
+    /// In this state, parent lookups are disabled.
+    SyncingFinalized {
+        start_slot: Slot,
+        head_slot: Slot,
+        head_root: Hash256,
+    },
+    /// The node is performing a long-range (batch) sync over one or many head chains.
+    /// In this state parent lookups are disabled.
+    SyncingHead { start_slot: Slot, head_slot: Slot },
+    /// The node is up to date with all known peers and is connected to at least one
+    /// fully synced peer. In this state, parent lookups are enabled.
+    Synced,
+    /// No useful peers are connected. Long-range sync's cannot proceed and we have no useful
+    /// peers to download parents for. More peers need to be connected before we can proceed.
+    Stalled,
+}
+
+impl PartialEq for SyncState {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (SyncState::SyncingFinalized { .. }, SyncState::SyncingFinalized { .. }) => true,
+            (SyncState::SyncingHead { .. }, SyncState::SyncingHead { .. }) => true,
+            (SyncState::Synced, SyncState::Synced) => true,
+            (SyncState::Stalled, SyncState::Stalled) => true,
+            _ => false,
+        }
+    }
+}
+
+impl SyncState {
+    /// Returns a boolean indicating the node is currently performing a long-range sync.
+    pub fn is_syncing(&self) -> bool {
+        match self {
+            SyncState::SyncingFinalized { .. } => true,
+            SyncState::SyncingHead { .. } => true,
+            SyncState::Synced => false,
+            SyncState::Stalled => false,
+        }
+    }
+
+    /// Returns true if the node is synced.
+    pub fn is_synced(&self) -> bool {
+        match self {
+            SyncState::Synced => true,
+            _ => false,
+        }
+    }
+}
+
+impl std::fmt::Display for SyncState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SyncState::SyncingFinalized { .. } => write!(f, "Syncing Finalized Chain"),
+            SyncState::SyncingHead { .. } => write!(f, "Syncing Head Chain"),
+            SyncState::Synced { .. } => write!(f, "Synced"),
+            SyncState::Stalled { .. } => write!(f, "Stalled"),
+        }
+    }
+}

beacon_node/eth2_libp2p/src/types/topics.rs

@@ -0,0 +1,186 @@
+use libp2p::gossipsub::Topic;
+use serde_derive::{Deserialize, Serialize};
+use types::SubnetId;
+
+/// The gossipsub topic names.
+// These constants form a topic name of the form /TOPIC_PREFIX/TOPIC/ENCODING_POSTFIX
+// For example /eth2/beacon_block/ssz
+pub const TOPIC_PREFIX: &str = "eth2";
+pub const SSZ_SNAPPY_ENCODING_POSTFIX: &str = "ssz_snappy";
+pub const BEACON_BLOCK_TOPIC: &str = "beacon_block";
+pub const BEACON_AGGREGATE_AND_PROOF_TOPIC: &str = "beacon_aggregate_and_proof";
+pub const BEACON_ATTESTATION_PREFIX: &str = "beacon_attestation_";
+pub const VOLUNTARY_EXIT_TOPIC: &str = "voluntary_exit";
+pub const PROPOSER_SLASHING_TOPIC: &str = "proposer_slashing";
+pub const ATTESTER_SLASHING_TOPIC: &str = "attester_slashing";
+
+/// A gossipsub topic which encapsulates the type of messages that should be sent and received over
+/// the pubsub protocol and the way the messages should be encoded.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct GossipTopic {
+    /// The encoding of the topic.
+    encoding: GossipEncoding,
+    /// The fork digest of the topic,
+    fork_digest: [u8; 4],
+    /// The kind of topic.
+    kind: GossipKind,
+}
+
+/// Enum that brings these topics into the rust type system.
+// NOTE: There is intentionally no unknown type here. We only allow known gossipsub topics.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub enum GossipKind {
+    /// Topic for publishing beacon blocks.
+    BeaconBlock,
+    /// Topic for publishing aggregate attestations and proofs.    
+    BeaconAggregateAndProof,
+    /// Topic for publishing raw attestations on a particular subnet.
+    Attestation(SubnetId),
+    /// Topic for publishing voluntary exits.
+    VoluntaryExit,
+    /// Topic for publishing block proposer slashings.
+    ProposerSlashing,
+    /// Topic for publishing attester slashings.
+    AttesterSlashing,
+}
+
+impl std::fmt::Display for GossipKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GossipKind::BeaconBlock => write!(f, "beacon_block"),
+            GossipKind::BeaconAggregateAndProof => write!(f, "beacon_aggregate_and_proof"),
+            GossipKind::Attestation(subnet_id) => write!(f, "beacon_attestation_{}", **subnet_id),
+            GossipKind::VoluntaryExit => write!(f, "voluntary_exit"),
+            GossipKind::ProposerSlashing => write!(f, "proposer_slashing"),
+            GossipKind::AttesterSlashing => write!(f, "attester_slashing"),
+        }
+    }
+}
+
+/// The known encoding types for gossipsub messages.
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub enum GossipEncoding {
+    /// Messages are encoded with SSZSnappy.
+    SSZSnappy,
+}
+
+impl Default for GossipEncoding {
+    fn default() -> Self {
+        GossipEncoding::SSZSnappy
+    }
+}
+
+impl GossipTopic {
+    pub fn new(kind: GossipKind, encoding: GossipEncoding, fork_digest: [u8; 4]) -> Self {
+        GossipTopic {
+            encoding,
+            kind,
+            fork_digest,
+        }
+    }
+
+    /// Returns the encoding type for the gossipsub topic.
+    pub fn encoding(&self) -> &GossipEncoding {
+        &self.encoding
+    }
+
+    /// Returns a mutable reference to the fork digest of the gossipsub topic.
+    pub fn digest(&mut self) -> &mut [u8; 4] {
+        &mut self.fork_digest
+    }
+
+    /// Returns the kind of message expected on the gossipsub topic.
+    pub fn kind(&self) -> &GossipKind {
+        &self.kind
+    }
+
+    pub fn decode(topic: &str) -> Result<Self, String> {
+        let topic_parts: Vec<&str> = topic.split('/').collect();
+        if topic_parts.len() == 5 && topic_parts[1] == TOPIC_PREFIX {
+            let digest_bytes = hex::decode(topic_parts[2])
+                .map_err(|e| format!("Could not decode fork_digest hex: {}", e))?;
+
+            if digest_bytes.len() != 4 {
+                return Err(format!(
+                    "Invalid gossipsub fork digest size: {}",
+                    digest_bytes.len()
+                ));
+            }
+
+            let mut fork_digest = [0; 4];
+            fork_digest.copy_from_slice(&digest_bytes);
+
+            let encoding = match topic_parts[4] {
+                SSZ_SNAPPY_ENCODING_POSTFIX => GossipEncoding::SSZSnappy,
+                _ => return Err(format!("Unknown encoding: {}", topic)),
+            };
+            let kind = match topic_parts[3] {
+                BEACON_BLOCK_TOPIC => GossipKind::BeaconBlock,
+                BEACON_AGGREGATE_AND_PROOF_TOPIC => GossipKind::BeaconAggregateAndProof,
+                VOLUNTARY_EXIT_TOPIC => GossipKind::VoluntaryExit,
+                PROPOSER_SLASHING_TOPIC => GossipKind::ProposerSlashing,
+                ATTESTER_SLASHING_TOPIC => GossipKind::AttesterSlashing,
+                topic => match committee_topic_index(topic) {
+                    Some(subnet_id) => GossipKind::Attestation(subnet_id),
+                    None => return Err(format!("Unknown topic: {}", topic)),
+                },
+            };
+
+            return Ok(GossipTopic {
+                encoding,
+                kind,
+                fork_digest,
+            });
+        }
+
+        Err(format!("Unknown topic: {}", topic))
+    }
+}
+
+impl Into<Topic> for GossipTopic {
+    fn into(self) -> Topic {
+        Topic::new(self.into())
+    }
+}
+
+impl Into<String> for GossipTopic {
+    fn into(self) -> String {
+        let encoding = match self.encoding {
+            GossipEncoding::SSZSnappy => SSZ_SNAPPY_ENCODING_POSTFIX,
+        };
+
+        let kind = match self.kind {
+            GossipKind::BeaconBlock => BEACON_BLOCK_TOPIC.into(),
+            GossipKind::BeaconAggregateAndProof => BEACON_AGGREGATE_AND_PROOF_TOPIC.into(),
+            GossipKind::VoluntaryExit => VOLUNTARY_EXIT_TOPIC.into(),
+            GossipKind::ProposerSlashing => PROPOSER_SLASHING_TOPIC.into(),
+            GossipKind::AttesterSlashing => ATTESTER_SLASHING_TOPIC.into(),
+            GossipKind::Attestation(index) => format!("{}{}", BEACON_ATTESTATION_PREFIX, *index,),
+        };
+        format!(
+            "/{}/{}/{}/{}",
+            TOPIC_PREFIX,
+            hex::encode(self.fork_digest),
+            kind,
+            encoding
+        )
+    }
+}
+
+impl From<SubnetId> for GossipKind {
+    fn from(subnet_id: SubnetId) -> Self {
+        GossipKind::Attestation(subnet_id)
+    }
+}
+
+// helper functions
+
+// Determines if a string is a committee topic.
+fn committee_topic_index(topic: &str) -> Option<SubnetId> {
+    if topic.starts_with(BEACON_ATTESTATION_PREFIX) {
+        return Some(SubnetId::new(
+            u64::from_str_radix(topic.trim_start_matches(BEACON_ATTESTATION_PREFIX), 10).ok()?,
+        ));
+    }
+    None
+}

beacon_node/eth2_libp2p/tests/common/mod.rs

@@ -0,0 +1,199 @@
+#![cfg(test)]
+use eth2_libp2p::Enr;
+use eth2_libp2p::EnrExt;
+use eth2_libp2p::Multiaddr;
+use eth2_libp2p::Service as LibP2PService;
+use eth2_libp2p::{Libp2pEvent, NetworkConfig};
+use slog::{debug, error, o, Drain};
+use std::net::{TcpListener, UdpSocket};
+use std::time::Duration;
+use types::{EnrForkId, MinimalEthSpec};
+
+type E = MinimalEthSpec;
+use tempdir::TempDir;
+
+pub struct Libp2pInstance(LibP2PService<E>, exit_future::Signal);
+
+impl std::ops::Deref for Libp2pInstance {
+    type Target = LibP2PService<E>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::ops::DerefMut for Libp2pInstance {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+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!())
+    }
+}
+
+// A bit of hack to find an unused port.
+///
+/// Does not guarantee that the given port is unused after the function exists, just that it was
+/// unused before the function started (i.e., it does not reserve a port).
+pub fn unused_port(transport: &str) -> Result<u16, String> {
+    let local_addr = match transport {
+        "tcp" => {
+            let listener = TcpListener::bind("127.0.0.1:0").map_err(|e| {
+                format!("Failed to create TCP listener to find unused port: {:?}", e)
+            })?;
+            listener.local_addr().map_err(|e| {
+                format!(
+                    "Failed to read TCP listener local_addr to find unused port: {:?}",
+                    e
+                )
+            })?
+        }
+        "udp" => {
+            let socket = UdpSocket::bind("127.0.0.1:0")
+                .map_err(|e| format!("Failed to create UDP socket to find unused port: {:?}", e))?;
+            socket.local_addr().map_err(|e| {
+                format!(
+                    "Failed to read UDP socket local_addr to find unused port: {:?}",
+                    e
+                )
+            })?
+        }
+        _ => return Err("Invalid transport to find unused port".into()),
+    };
+    Ok(local_addr.port())
+}
+
+pub fn build_config(port: u16, mut boot_nodes: Vec<Enr>) -> NetworkConfig {
+    let mut config = NetworkConfig::default();
+    let path = TempDir::new(&format!("libp2p_test{}", port)).unwrap();
+
+    config.libp2p_port = port; // tcp port
+    config.discovery_port = port; // udp port
+    config.enr_tcp_port = Some(port);
+    config.enr_udp_port = Some(port);
+    config.enr_address = Some("127.0.0.1".parse().unwrap());
+    config.boot_nodes.append(&mut boot_nodes);
+    config.network_dir = path.into_path();
+    // Reduce gossipsub heartbeat parameters
+    config.gs_config.heartbeat_initial_delay = Duration::from_millis(500);
+    config.gs_config.heartbeat_interval = Duration::from_millis(500);
+    config
+}
+
+pub fn build_libp2p_instance(boot_nodes: Vec<Enr>, log: slog::Logger) -> Libp2pInstance {
+    let port = unused_port("tcp").unwrap();
+    let config = build_config(port, boot_nodes);
+    // launch libp2p service
+
+    let (signal, exit) = exit_future::signal();
+    let executor =
+        environment::TaskExecutor::new(tokio::runtime::Handle::current(), exit, log.clone());
+    Libp2pInstance(
+        LibP2PService::new(executor, &config, EnrForkId::default(), &log)
+            .expect("should build libp2p instance")
+            .1,
+        signal,
+    )
+}
+
+#[allow(dead_code)]
+pub fn get_enr(node: &LibP2PService<E>) -> Enr {
+    let enr = node.swarm.local_enr().clone();
+    enr
+}
+
+// Returns `n` libp2p peers in fully connected topology.
+#[allow(dead_code)]
+pub fn build_full_mesh(log: slog::Logger, n: usize) -> Vec<Libp2pInstance> {
+    let mut nodes: Vec<_> = (0..n)
+        .map(|_| build_libp2p_instance(vec![], log.clone()))
+        .collect();
+    let multiaddrs: Vec<Multiaddr> = nodes
+        .iter()
+        .map(|x| get_enr(&x).multiaddr()[1].clone())
+        .collect();
+
+    for (i, node) in nodes.iter_mut().enumerate().take(n) {
+        for (j, multiaddr) in multiaddrs.iter().enumerate().skip(i) {
+            if i != j {
+                match libp2p::Swarm::dial_addr(&mut node.swarm, multiaddr.clone()) {
+                    Ok(()) => debug!(log, "Connected"),
+                    Err(_) => error!(log, "Failed to connect"),
+                };
+            }
+        }
+    }
+    nodes
+}
+
+// Constructs a pair of nodes with separate loggers. The sender dials the receiver.
+// This returns a (sender, receiver) pair.
+#[allow(dead_code)]
+pub async fn build_node_pair(log: &slog::Logger) -> (Libp2pInstance, Libp2pInstance) {
+    let sender_log = log.new(o!("who" => "sender"));
+    let receiver_log = log.new(o!("who" => "receiver"));
+
+    let mut sender = build_libp2p_instance(vec![], sender_log);
+    let mut receiver = build_libp2p_instance(vec![], receiver_log);
+
+    let receiver_multiaddr = receiver.swarm.local_enr().multiaddr()[1].clone();
+
+    // let the two nodes set up listeners
+    let sender_fut = async {
+        loop {
+            if let Libp2pEvent::NewListenAddr(_) = sender.next_event().await {
+                return;
+            }
+        }
+    };
+    let receiver_fut = async {
+        loop {
+            if let Libp2pEvent::NewListenAddr(_) = receiver.next_event().await {
+                return;
+            }
+        }
+    };
+
+    let joined = futures::future::join(sender_fut, receiver_fut);
+
+    // wait for either both nodes to listen or a timeout
+    tokio::select! {
+        _  = tokio::time::delay_for(Duration::from_millis(500)) => {}
+        _ = joined => {}
+    }
+
+    match libp2p::Swarm::dial_addr(&mut sender.swarm, receiver_multiaddr.clone()) {
+        Ok(()) => {
+            debug!(log, "Sender dialed receiver"; "address" => format!("{:?}", receiver_multiaddr))
+        }
+        Err(_) => error!(log, "Dialing failed"),
+    };
+    (sender, receiver)
+}
+
+// Returns `n` peers in a linear topology
+#[allow(dead_code)]
+pub fn build_linear(log: slog::Logger, n: usize) -> Vec<Libp2pInstance> {
+    let mut nodes: Vec<_> = (0..n)
+        .map(|_| build_libp2p_instance(vec![], log.clone()))
+        .collect();
+    let multiaddrs: Vec<Multiaddr> = nodes
+        .iter()
+        .map(|x| get_enr(&x).multiaddr()[1].clone())
+        .collect();
+    for i in 0..n - 1 {
+        match libp2p::Swarm::dial_addr(&mut nodes[i].swarm, multiaddrs[i + 1].clone()) {
+            Ok(()) => debug!(log, "Connected"),
+            Err(_) => error!(log, "Failed to connect"),
+        };
+    }
+    nodes
+}

beacon_node/eth2_libp2p/tests/gossipsub_tests.rs

@@ -0,0 +1,171 @@
+/* These are temporarily disabled due to their non-deterministic behaviour and impending update to
+ * gossipsub 1.1. We leave these here as a template for future test upgrades
+
+
+#![cfg(test)]
+use crate::types::GossipEncoding;
+use ::types::{BeaconBlock, EthSpec, MinimalEthSpec, Signature, SignedBeaconBlock};
+use eth2_libp2p::*;
+use slog::{debug, Level};
+
+type E = MinimalEthSpec;
+
+mod common;
+
+/* Gossipsub tests */
+// Note: The aim of these tests is not to test the robustness of the gossip network
+// but to check if the gossipsub implementation is behaving according to the specifications.
+
+// Test if gossipsub message are forwarded by nodes with a simple linear topology.
+//
+//                Topology used in test
+//
+// node1 <-> node2 <-> node3 ..... <-> node(n-1) <-> node(n)
+
+#[tokio::test]
+async fn test_gossipsub_forward() {
+    // set up the logging. The level and enabled or not
+    let log = common::build_log(Level::Info, false);
+
+    let num_nodes = 20;
+    let mut nodes = common::build_linear(log.clone(), num_nodes);
+    let mut received_count = 0;
+    let spec = E::default_spec();
+    let empty_block = BeaconBlock::empty(&spec);
+    let signed_block = SignedBeaconBlock {
+        message: empty_block,
+        signature: Signature::empty_signature(),
+    };
+    let pubsub_message = PubsubMessage::BeaconBlock(Box::new(signed_block));
+    let publishing_topic: String = pubsub_message
+        .topics(GossipEncoding::default(), [0, 0, 0, 0])
+        .first()
+        .unwrap()
+        .clone()
+        .into();
+    let mut subscribed_count = 0;
+    let fut = async move {
+        for node in nodes.iter_mut() {
+            loop {
+                match node.next_event().await {
+                    Libp2pEvent::Behaviour(b) => match b {
+                        BehaviourEvent::PubsubMessage {
+                            topics,
+                            message,
+                            source,
+                            id,
+                        } => {
+                            assert_eq!(topics.len(), 1);
+                            // Assert topic is the published topic
+                            assert_eq!(
+                                topics.first().unwrap(),
+                                &TopicHash::from_raw(publishing_topic.clone())
+                            );
+                            // Assert message received is the correct one
+                            assert_eq!(message, pubsub_message.clone());
+                            received_count += 1;
+                            // Since `propagate_message` is false, need to propagate manually
+                            node.swarm.propagate_message(&source, id);
+                            // Test should succeed if all nodes except the publisher receive the message
+                            if received_count == num_nodes - 1 {
+                                debug!(log.clone(), "Received message at {} nodes", num_nodes - 1);
+                                return;
+                            }
+                        }
+                        BehaviourEvent::PeerSubscribed(_, topic) => {
+                            // Publish on beacon block topic
+                            if topic == TopicHash::from_raw(publishing_topic.clone()) {
+                                subscribed_count += 1;
+                                // Every node except the corner nodes are connected to 2 nodes.
+                                if subscribed_count == (num_nodes * 2) - 2 {
+                                    node.swarm.publish(vec![pubsub_message.clone()]);
+                                }
+                            }
+                        }
+                        _ => break,
+                    },
+                    _ => break,
+                }
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = fut => {}
+        _ = tokio::time::delay_for(tokio::time::Duration::from_millis(800)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+// Test publishing of a message with a full mesh for the topic
+// Not very useful but this is the bare minimum functionality.
+#[tokio::test]
+async fn test_gossipsub_full_mesh_publish() {
+    // set up the logging. The level and enabled or not
+    let log = common::build_log(Level::Debug, false);
+
+    // Note: This test does not propagate gossipsub messages.
+    // Having `num_nodes` > `mesh_n_high` may give inconsistent results
+    // as nodes may get pruned out of the mesh before the gossipsub message
+    // is published to them.
+    let num_nodes = 12;
+    let mut nodes = common::build_full_mesh(log, num_nodes);
+    let mut publishing_node = nodes.pop().unwrap();
+    let spec = E::default_spec();
+    let empty_block = BeaconBlock::empty(&spec);
+    let signed_block = SignedBeaconBlock {
+        message: empty_block,
+        signature: Signature::empty_signature(),
+    };
+    let pubsub_message = PubsubMessage::BeaconBlock(Box::new(signed_block));
+    let publishing_topic: String = pubsub_message
+        .topics(GossipEncoding::default(), [0, 0, 0, 0])
+        .first()
+        .unwrap()
+        .clone()
+        .into();
+    let mut subscribed_count = 0;
+    let mut received_count = 0;
+    let fut = async move {
+        for node in nodes.iter_mut() {
+            while let Libp2pEvent::Behaviour(BehaviourEvent::PubsubMessage {
+                topics,
+                message,
+                ..
+            }) = node.next_event().await
+            {
+                assert_eq!(topics.len(), 1);
+                // Assert topic is the published topic
+                assert_eq!(
+                    topics.first().unwrap(),
+                    &TopicHash::from_raw(publishing_topic.clone())
+                );
+                // Assert message received is the correct one
+                assert_eq!(message, pubsub_message.clone());
+                received_count += 1;
+                if received_count == num_nodes - 1 {
+                    return;
+                }
+            }
+        }
+        while let Libp2pEvent::Behaviour(BehaviourEvent::PeerSubscribed(_, topic)) =
+            publishing_node.next_event().await
+        {
+            // Publish on beacon block topic
+            if topic == TopicHash::from_raw(publishing_topic.clone()) {
+                subscribed_count += 1;
+                if subscribed_count == num_nodes - 1 {
+                    publishing_node.swarm.publish(vec![pubsub_message.clone()]);
+                }
+            }
+        }
+    };
+    tokio::select! {
+            _ = fut => {}
+            _ = tokio::time::delay_for(tokio::time::Duration::from_millis(800)) => {
+                panic!("Future timed out");
+            }
+    }
+}
+*/

beacon_node/eth2_libp2p/tests/noise.rs

@@ -0,0 +1,184 @@
+#![cfg(test)]
+use crate::behaviour::Behaviour;
+use crate::multiaddr::Protocol;
+use ::types::{EnrForkId, MinimalEthSpec};
+use eth2_libp2p::discovery::{build_enr, CombinedKey, CombinedKeyExt};
+use eth2_libp2p::*;
+use futures::prelude::*;
+use libp2p::core::identity::Keypair;
+use libp2p::{
+    core,
+    core::{muxing::StreamMuxerBox, transport::boxed::Boxed},
+    secio,
+    swarm::{SwarmBuilder, SwarmEvent},
+    PeerId, Swarm, Transport,
+};
+use slog::{crit, debug, info, Level};
+use std::io::{Error, ErrorKind};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+
+type TSpec = MinimalEthSpec;
+
+mod common;
+
+type Libp2pBehaviour = Behaviour<TSpec>;
+
+/// Build and return a eth2_libp2p Swarm with only secio support.
+fn build_secio_swarm(
+    config: &NetworkConfig,
+    log: slog::Logger,
+) -> error::Result<Swarm<Libp2pBehaviour>> {
+    let local_keypair = Keypair::generate_secp256k1();
+    let local_peer_id = PeerId::from(local_keypair.public());
+    let enr_key = CombinedKey::from_libp2p(&local_keypair).unwrap();
+
+    let enr = build_enr::<TSpec>(&enr_key, config, EnrForkId::default()).unwrap();
+    let network_globals = Arc::new(NetworkGlobals::new(
+        enr,
+        config.libp2p_port,
+        config.discovery_port,
+        &log,
+    ));
+
+    let mut swarm = {
+        // Set up the transport - tcp/ws with secio and mplex/yamux
+        let transport = build_secio_transport(local_keypair.clone());
+        // Lighthouse network behaviour
+        let behaviour = Behaviour::new(&local_keypair, config, network_globals.clone(), &log)?;
+        // requires a tokio runtime
+        struct Executor(tokio::runtime::Handle);
+        impl libp2p::core::Executor for Executor {
+            fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+                self.0.spawn(f);
+            }
+        }
+        SwarmBuilder::new(transport, behaviour, local_peer_id.clone())
+            .executor(Box::new(Executor(tokio::runtime::Handle::current())))
+            .build()
+    };
+
+    // listen on the specified address
+    let listen_multiaddr = {
+        let mut m = Multiaddr::from(config.listen_address);
+        m.push(Protocol::Tcp(config.libp2p_port));
+        m
+    };
+
+    match Swarm::listen_on(&mut swarm, listen_multiaddr.clone()) {
+        Ok(_) => {
+            let mut log_address = listen_multiaddr;
+            log_address.push(Protocol::P2p(local_peer_id.clone().into()));
+            info!(log, "Listening established"; "address" => format!("{}", log_address));
+        }
+        Err(err) => {
+            crit!(
+                log,
+                "Unable to listen on libp2p address";
+                "error" => format!("{:?}", err),
+                "listen_multiaddr" => format!("{}", listen_multiaddr),
+            );
+            return Err("Libp2p was unable to listen on the given listen address.".into());
+        }
+    };
+
+    // helper closure for dialing peers
+    let mut dial_addr = |multiaddr: &Multiaddr| {
+        match Swarm::dial_addr(&mut swarm, multiaddr.clone()) {
+            Ok(()) => debug!(log, "Dialing libp2p peer"; "address" => format!("{}", multiaddr)),
+            Err(err) => debug!(
+                log,
+                "Could not connect to peer"; "address" => format!("{}", multiaddr), "error" => format!("{:?}", err)
+            ),
+        };
+    };
+
+    // attempt to connect to any specified boot-nodes
+    for bootnode_enr in &config.boot_nodes {
+        for multiaddr in &bootnode_enr.multiaddr() {
+            // ignore udp multiaddr if it exists
+            let components = multiaddr.iter().collect::<Vec<_>>();
+            if let Protocol::Udp(_) = components[1] {
+                continue;
+            }
+            dial_addr(multiaddr);
+        }
+    }
+    Ok(swarm)
+}
+
+/// Build a simple TCP transport with secio, mplex/yamux.
+fn build_secio_transport(local_private_key: Keypair) -> Boxed<(PeerId, StreamMuxerBox), Error> {
+    let transport = libp2p_tcp::TokioTcpConfig::new().nodelay(true);
+    transport
+        .upgrade(core::upgrade::Version::V1)
+        .authenticate(secio::SecioConfig::new(local_private_key))
+        .multiplex(core::upgrade::SelectUpgrade::new(
+            libp2p::yamux::Config::default(),
+            libp2p::mplex::MplexConfig::new(),
+        ))
+        .map(|(peer, muxer), _| (peer, core::muxing::StreamMuxerBox::new(muxer)))
+        .timeout(Duration::from_secs(20))
+        .timeout(Duration::from_secs(20))
+        .map_err(|err| Error::new(ErrorKind::Other, err))
+        .boxed()
+}
+
+/// Test if the encryption falls back to secio if noise isn't available
+#[tokio::test]
+async fn test_secio_noise_fallback() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Trace;
+    let enable_logging = false;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    let port = common::unused_port("tcp").unwrap();
+    let noisy_config = common::build_config(port, vec![]);
+    let (_signal, exit) = exit_future::signal();
+    let executor =
+        environment::TaskExecutor::new(tokio::runtime::Handle::current(), exit, log.clone());
+    let mut noisy_node = Service::new(executor, &noisy_config, EnrForkId::default(), &log)
+        .expect("should build a libp2p instance")
+        .1;
+
+    let port = common::unused_port("tcp").unwrap();
+    let secio_config = common::build_config(port, vec![common::get_enr(&noisy_node)]);
+
+    // Building a custom Libp2pService from outside the crate isn't possible because of
+    // private fields in the Libp2pService struct. A swarm is good enough for testing
+    // compatibility with secio.
+    let mut secio_swarm =
+        build_secio_swarm(&secio_config, log.clone()).expect("should build a secio swarm");
+
+    let secio_log = log.clone();
+
+    let noisy_future = async {
+        loop {
+            noisy_node.next_event().await;
+        }
+    };
+
+    let secio_future = async {
+        loop {
+            match secio_swarm.next_event().await {
+                SwarmEvent::ConnectionEstablished { peer_id, .. } => {
+                    // secio node negotiated a secio transport with
+                    // the noise compatible node
+                    info!(secio_log, "Connected to peer {}", peer_id);
+                    return;
+                }
+                _ => {} // Ignore all other events
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = noisy_future => {}
+        _ = secio_future => {}
+        _ = tokio::time::delay_for(Duration::from_millis(800)) => {
+            panic!("Future timed out");
+        }
+    }
+}

beacon_node/eth2_libp2p/tests/rpc_tests.rs

@@ -0,0 +1,760 @@
+#![cfg(test)]
+use eth2_libp2p::rpc::methods::*;
+use eth2_libp2p::{BehaviourEvent, Libp2pEvent, Request, Response};
+use slog::{debug, warn, Level};
+use ssz_types::VariableList;
+use std::time::Duration;
+use tokio::time::delay_for;
+use types::{
+    BeaconBlock, Epoch, EthSpec, Hash256, MinimalEthSpec, Signature, SignedBeaconBlock, Slot,
+};
+
+mod common;
+
+type E = MinimalEthSpec;
+
+#[tokio::test]
+// Tests the STATUS RPC message
+async fn test_status_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // Dummy STATUS RPC message
+    let rpc_request = Request::Status(StatusMessage {
+        fork_digest: [0; 4],
+        finalized_root: Hash256::from_low_u64_be(0),
+        finalized_epoch: Epoch::new(1),
+        head_root: Hash256::from_low_u64_be(0),
+        head_slot: Slot::new(1),
+    });
+
+    // Dummy STATUS RPC message
+    let rpc_response = Response::Status(StatusMessage {
+        fork_digest: [0; 4],
+        finalized_root: Hash256::from_low_u64_be(0),
+        finalized_epoch: Epoch::new(1),
+        head_root: Hash256::from_low_u64_be(0),
+        head_slot: Slot::new(1),
+    });
+
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) => {
+                    // Should receive the RPC response
+                    debug!(log, "Sender Received");
+                    assert_eq!(response, rpc_response.clone());
+                    debug!(log, "Sender Completed");
+                    return;
+                }
+                _ => {}
+            }
+        }
+    };
+
+    // build the receiver future
+    let receiver_future = async {
+        loop {
+            match receiver.next_event().await {
+                Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                    peer_id,
+                    id,
+                    request,
+                }) => {
+                    if request == rpc_request {
+                        // send the response
+                        debug!(log, "Receiver Received");
+                        receiver
+                            .swarm
+                            .send_successful_response(peer_id, id, rpc_response.clone());
+                    }
+                }
+                _ => {} // Ignore other events
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests a streamed BlocksByRange RPC Message
+async fn test_blocks_by_range_chunked_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Trace;
+    let enable_logging = false;
+
+    let messages_to_send = 10;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // BlocksByRange Request
+    let rpc_request = Request::BlocksByRange(BlocksByRangeRequest {
+        start_slot: 0,
+        count: messages_to_send,
+        step: 0,
+    });
+
+    // BlocksByRange Response
+    let spec = E::default_spec();
+    let empty_block = BeaconBlock::empty(&spec);
+    let empty_signed = SignedBeaconBlock {
+        message: empty_block,
+        signature: Signature::empty_signature(),
+    };
+    let rpc_response = Response::BlocksByRange(Some(Box::new(empty_signed)));
+
+    // keep count of the number of messages received
+    let mut messages_received = 0;
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) => {
+                    warn!(log, "Sender received a response");
+                    match response {
+                        Response::BlocksByRange(Some(_)) => {
+                            assert_eq!(response, rpc_response.clone());
+                            messages_received += 1;
+                            warn!(log, "Chunk received");
+                        }
+                        Response::BlocksByRange(None) => {
+                            // should be exactly 10 messages before terminating
+                            assert_eq!(messages_received, messages_to_send);
+                            // end the test
+                            return;
+                        }
+                        _ => panic!("Invalid RPC received"),
+                    }
+                }
+                _ => {} // Ignore other behaviour events
+            }
+        }
+    };
+
+    // build the receiver future
+    let receiver_future = async {
+        loop {
+            match receiver.next_event().await {
+                Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                    peer_id,
+                    id,
+                    request,
+                }) => {
+                    if request == rpc_request {
+                        // send the response
+                        warn!(log, "Receiver got request");
+                        for _ in 1..=messages_to_send {
+                            receiver.swarm.send_successful_response(
+                                peer_id.clone(),
+                                id,
+                                rpc_response.clone(),
+                            );
+                        }
+                        // send the stream termination
+                        receiver.swarm.send_successful_response(
+                            peer_id,
+                            id,
+                            Response::BlocksByRange(None),
+                        );
+                    }
+                }
+                _ => {} // Ignore other events
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests that a streamed BlocksByRange RPC Message terminates when all expected chunks were received
+async fn test_blocks_by_range_chunked_rpc_terminates_correctly() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let messages_to_send = 10;
+    let extra_messages_to_send = 10;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // BlocksByRange Request
+    let rpc_request = Request::BlocksByRange(BlocksByRangeRequest {
+        start_slot: 0,
+        count: messages_to_send,
+        step: 0,
+    });
+
+    // BlocksByRange Response
+    let spec = E::default_spec();
+    let empty_block = BeaconBlock::empty(&spec);
+    let empty_signed = SignedBeaconBlock {
+        message: empty_block,
+        signature: Signature::empty_signature(),
+    };
+    let rpc_response = Response::BlocksByRange(Some(Box::new(empty_signed)));
+
+    // keep count of the number of messages received
+    let mut messages_received: u64 = 0;
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) =>
+                // Should receive the RPC response
+                {
+                    debug!(log, "Sender received a response");
+                    match response {
+                        Response::BlocksByRange(Some(_)) => {
+                            assert_eq!(response, rpc_response.clone());
+                            messages_received += 1;
+                        }
+                        Response::BlocksByRange(None) => {
+                            // should be exactly 10 messages, as requested
+                            assert_eq!(messages_received, messages_to_send);
+                        }
+                        _ => panic!("Invalid RPC received"),
+                    }
+                }
+
+                _ => {} // Ignore other behaviour events
+            }
+        }
+    };
+
+    // determine messages to send (PeerId, RequestId). If some, indicates we still need to send
+    // messages
+    let mut message_info = None;
+    // the number of messages we've sent
+    let mut messages_sent = 0;
+    let receiver_future = async {
+        loop {
+            // this future either drives the sending/receiving or times out allowing messages to be
+            // sent in the timeout
+            match futures::future::select(
+                Box::pin(receiver.next_event()),
+                tokio::time::delay_for(Duration::from_secs(1)),
+            )
+            .await
+            {
+                futures::future::Either::Left((
+                    Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                        peer_id,
+                        id,
+                        request,
+                    }),
+                    _,
+                )) => {
+                    if request == rpc_request {
+                        // send the response
+                        warn!(log, "Receiver got request");
+                        message_info = Some((peer_id, id));
+                    }
+                }
+                futures::future::Either::Right((_, _)) => {} // The timeout hit, send messages if required
+                _ => continue,
+            }
+
+            // if we need to send messages send them here. This will happen after a delay
+            if message_info.is_some() {
+                messages_sent += 1;
+                let (peer_id, stream_id) = message_info.as_ref().unwrap();
+                receiver.swarm.send_successful_response(
+                    peer_id.clone(),
+                    stream_id.clone(),
+                    rpc_response.clone(),
+                );
+                debug!(log, "Sending message {}", messages_sent);
+                if messages_sent == messages_to_send + extra_messages_to_send {
+                    // stop sending messages
+                    return;
+                }
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests an empty response to a BlocksByRange RPC Message
+async fn test_blocks_by_range_single_empty_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Trace;
+    let enable_logging = false;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // BlocksByRange Request
+    let rpc_request = Request::BlocksByRange(BlocksByRangeRequest {
+        start_slot: 0,
+        count: 10,
+        step: 0,
+    });
+
+    // BlocksByRange Response
+    let spec = E::default_spec();
+    let empty_block = BeaconBlock::empty(&spec);
+    let empty_signed = SignedBeaconBlock {
+        message: empty_block,
+        signature: Signature::empty_signature(),
+    };
+    let rpc_response = Response::BlocksByRange(Some(Box::new(empty_signed)));
+
+    let messages_to_send = 1;
+
+    // keep count of the number of messages received
+    let mut messages_received = 0;
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) => match response {
+                    Response::BlocksByRange(Some(_)) => {
+                        assert_eq!(response, rpc_response.clone());
+                        messages_received += 1;
+                        warn!(log, "Chunk received");
+                    }
+                    Response::BlocksByRange(None) => {
+                        // should be exactly 10 messages before terminating
+                        assert_eq!(messages_received, messages_to_send);
+                        // end the test
+                        return;
+                    }
+                    _ => panic!("Invalid RPC received"),
+                },
+                _ => {} // Ignore other behaviour events
+            }
+        }
+    };
+
+    // build the receiver future
+    let receiver_future = async {
+        loop {
+            match receiver.next_event().await {
+                Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                    peer_id,
+                    id,
+                    request,
+                }) => {
+                    if request == rpc_request {
+                        // send the response
+                        warn!(log, "Receiver got request");
+
+                        for _ in 1..=messages_to_send {
+                            receiver.swarm.send_successful_response(
+                                peer_id.clone(),
+                                id,
+                                rpc_response.clone(),
+                            );
+                        }
+                        // send the stream termination
+                        receiver.swarm.send_successful_response(
+                            peer_id,
+                            id,
+                            Response::BlocksByRange(None),
+                        );
+                    }
+                }
+                _ => {} // Ignore other events
+            }
+        }
+    };
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(20)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests a streamed, chunked BlocksByRoot RPC Message
+// The size of the reponse is a full `BeaconBlock`
+// which is greater than the Snappy frame size. Hence, this test
+// serves to test the snappy framing format as well.
+async fn test_blocks_by_root_chunked_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let messages_to_send = 3;
+
+    let log = common::build_log(log_level, enable_logging);
+    let spec = E::default_spec();
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // BlocksByRoot Request
+    let rpc_request = Request::BlocksByRoot(BlocksByRootRequest {
+        block_roots: VariableList::from(vec![
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+        ]),
+    });
+
+    // BlocksByRoot Response
+    let full_block = BeaconBlock::full(&spec);
+    let signed_full_block = SignedBeaconBlock {
+        message: full_block,
+        signature: Signature::empty_signature(),
+    };
+    let rpc_response = Response::BlocksByRoot(Some(Box::new(signed_full_block)));
+
+    // keep count of the number of messages received
+    let mut messages_received = 0;
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) => match response {
+                    Response::BlocksByRoot(Some(_)) => {
+                        assert_eq!(response, rpc_response.clone());
+                        messages_received += 1;
+                        debug!(log, "Chunk received");
+                    }
+                    Response::BlocksByRoot(None) => {
+                        // should be exactly messages_to_send
+                        assert_eq!(messages_received, messages_to_send);
+                        // end the test
+                        return;
+                    }
+                    _ => {} // Ignore other RPC messages
+                },
+                _ => {} // Ignore other behaviour events
+            }
+        }
+    };
+
+    // build the receiver future
+    let receiver_future = async {
+        loop {
+            match receiver.next_event().await {
+                Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                    peer_id,
+                    id,
+                    request,
+                }) => {
+                    if request == rpc_request {
+                        // send the response
+                        debug!(log, "Receiver got request");
+
+                        for _ in 1..=messages_to_send {
+                            receiver.swarm.send_successful_response(
+                                peer_id.clone(),
+                                id,
+                                rpc_response.clone(),
+                            );
+                            debug!(log, "Sending message");
+                        }
+                        // send the stream termination
+                        receiver.swarm.send_successful_response(
+                            peer_id,
+                            id,
+                            Response::BlocksByRange(None),
+                        );
+                        debug!(log, "Send stream term");
+                    }
+                }
+                _ => {} // Ignore other events
+            }
+        }
+    };
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests a streamed, chunked BlocksByRoot RPC Message terminates when all expected reponses have been received
+async fn test_blocks_by_root_chunked_rpc_terminates_correctly() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Debug;
+    let enable_logging = false;
+
+    let messages_to_send: u64 = 10;
+    let extra_messages_to_send: u64 = 10;
+
+    let log = common::build_log(log_level, enable_logging);
+    let spec = E::default_spec();
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // BlocksByRoot Request
+    let rpc_request = Request::BlocksByRoot(BlocksByRootRequest {
+        block_roots: VariableList::from(vec![
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+            Hash256::from_low_u64_be(0),
+        ]),
+    });
+
+    // BlocksByRoot Response
+    let full_block = BeaconBlock::full(&spec);
+    let signed_full_block = SignedBeaconBlock {
+        message: full_block,
+        signature: Signature::empty_signature(),
+    };
+    let rpc_response = Response::BlocksByRoot(Some(Box::new(signed_full_block)));
+
+    // keep count of the number of messages received
+    let mut messages_received = 0;
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                Libp2pEvent::Behaviour(BehaviourEvent::ResponseReceived {
+                    peer_id: _,
+                    id: RequestId::Sync(10),
+                    response,
+                }) => {
+                    debug!(log, "Sender received a response");
+                    match response {
+                        Response::BlocksByRoot(Some(_)) => {
+                            assert_eq!(response, rpc_response.clone());
+                            messages_received += 1;
+                            debug!(log, "Chunk received");
+                        }
+                        Response::BlocksByRoot(None) => {
+                            // should be exactly messages_to_send
+                            assert_eq!(messages_received, messages_to_send);
+                            // end the test
+                            return;
+                        }
+                        _ => {} // Ignore other RPC messages
+                    }
+                }
+                _ => {} // Ignore other behaviour events
+            }
+        }
+    };
+
+    // determine messages to send (PeerId, RequestId). If some, indicates we still need to send
+    // messages
+    let mut message_info = None;
+    // the number of messages we've sent
+    let mut messages_sent = 0;
+    let receiver_future = async {
+        loop {
+            // this future either drives the sending/receiving or times out allowing messages to be
+            // sent in the timeout
+            match futures::future::select(
+                Box::pin(receiver.next_event()),
+                tokio::time::delay_for(Duration::from_millis(1000)),
+            )
+            .await
+            {
+                futures::future::Either::Left((
+                    Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                        peer_id,
+                        id,
+                        request,
+                    }),
+                    _,
+                )) => {
+                    if request == rpc_request {
+                        // send the response
+                        warn!(log, "Receiver got request");
+                        message_info = Some((peer_id, id));
+                    }
+                }
+                futures::future::Either::Right((_, _)) => {} // The timeout hit, send messages if required
+                _ => continue,
+            }
+
+            // if we need to send messages send them here. This will happen after a delay
+            if message_info.is_some() {
+                messages_sent += 1;
+                let (peer_id, stream_id) = message_info.as_ref().unwrap();
+                receiver.swarm.send_successful_response(
+                    peer_id.clone(),
+                    stream_id.clone(),
+                    rpc_response.clone(),
+                );
+                debug!(log, "Sending message {}", messages_sent);
+                if messages_sent == messages_to_send + extra_messages_to_send {
+                    // stop sending messages
+                    return;
+                }
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}
+
+#[tokio::test]
+// Tests a Goodbye RPC message
+async fn test_goodbye_rpc() {
+    // set up the logging. The level and enabled logging or not
+    let log_level = Level::Trace;
+    let enable_logging = false;
+
+    let log = common::build_log(log_level, enable_logging);
+
+    // get sender/receiver
+    let (mut sender, mut receiver) = common::build_node_pair(&log).await;
+
+    // Goodbye Request
+    let rpc_request = Request::Goodbye(GoodbyeReason::ClientShutdown);
+
+    // build the sender future
+    let sender_future = async {
+        loop {
+            match sender.next_event().await {
+                Libp2pEvent::PeerConnected { peer_id, .. } => {
+                    // Send a STATUS message
+                    debug!(log, "Sending RPC");
+                    sender
+                        .swarm
+                        .send_request(peer_id, RequestId::Sync(10), rpc_request.clone());
+                }
+                _ => {} // Ignore other RPC messages
+            }
+        }
+    };
+
+    // build the receiver future
+    let receiver_future = async {
+        loop {
+            match receiver.next_event().await {
+                Libp2pEvent::Behaviour(BehaviourEvent::RequestReceived {
+                    peer_id: _,
+                    id: _,
+                    request,
+                }) => {
+                    // Should receive sent RPC request
+                    assert_eq!(rpc_request.clone(), request); // receives the goodbye. Nothing left to do
+                    return;
+                }
+                _ => {} // Ignore other events
+            }
+        }
+    };
+
+    tokio::select! {
+        _ = sender_future => {}
+        _ = receiver_future => {}
+        _ = delay_for(Duration::from_secs(30)) => {
+            panic!("Future timed out");
+        }
+    }
+}