v0.11.1 Network update (#989)

* Minor log bumps

* Initial building of extended RPC methods

* Wire in extended RPC methods

* Merge initial peer management template

* Add a PeerDB and give the peer manager some basic functions

* Initial connection of peer manager

* Add peer manager to lighthouse

* Connect peer manager with new RPC methods

* Correct tests and metadata RPC

Co-authored-by: Diva <divma@protonmail.com>

beacon_node/eth2-libp2p/src/service.rs

@@ -1,8 +1,8 @@
 use crate::behaviour::{Behaviour, BehaviourEvent};
+use crate::discovery::enr;
 use crate::multiaddr::Protocol;
-use crate::rpc::RPCEvent;
 use crate::types::{error, GossipKind};
-use crate::{NetworkConfig, NetworkGlobals, PubsubMessage, TopicHash};
+use crate::{NetworkConfig, NetworkGlobals};
 use futures::prelude::*;
 use futures::Stream;
 use libp2p::core::{
@@ -14,7 +14,6 @@ use libp2p::core::{
     upgrade::{InboundUpgradeExt, OutboundUpgradeExt},
     ConnectedPoint,
 };
-use libp2p::gossipsub::MessageId;
 use libp2p::{core, noise, secio, swarm::NetworkBehaviour, PeerId, Swarm, Transport};
 use slog::{crit, debug, error, info, trace, warn};
 use std::fs::File;
@@ -60,34 +59,33 @@ impl<TSpec: EthSpec> Service<TSpec> {
     ) -> error::Result<(Arc<NetworkGlobals<TSpec>>, Self)> {
         trace!(log, "Libp2p Service starting");
 
+        // initialise the node's ID
         let local_keypair = if let Some(hex_bytes) = &config.secret_key_hex {
             keypair_from_hex(hex_bytes)?
         } else {
             load_private_key(config, &log)
         };
 
-        // load the private key from CLI flag, disk or generate a new one
-        let local_peer_id = PeerId::from(local_keypair.public());
-        info!(log, "Libp2p Service"; "peer_id" => format!("{:?}", local_peer_id));
+        // 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(
-            local_peer_id.clone(),
+            enr.clone(),
             config.libp2p_port,
             config.discovery_port,
+            &log,
         ));
 
+        info!(log, "Libp2p Service"; "peer_id" => format!("{:?}", enr.peer_id()));
+
         let mut swarm = {
             // Set up the transport - tcp/ws with noise/secio and mplex/yamux
             let transport = build_transport(local_keypair.clone());
             // Lighthouse network behaviour
-            let behaviour = Behaviour::new(
-                &local_keypair,
-                config,
-                network_globals.clone(),
-                enr_fork_id,
-                &log,
-            )?;
+            let behaviour = Behaviour::new(&local_keypair, config, network_globals.clone(), &log)?;
             Swarm::new(transport, behaviour, local_peer_id.clone())
         };
 
@@ -176,42 +174,15 @@ impl<TSpec: EthSpec> Service<TSpec> {
 }
 
 impl<TSpec: EthSpec> Stream for Service<TSpec> {
-    type Item = Libp2pEvent<TSpec>;
+    type Item = BehaviourEvent<TSpec>;
     type Error = error::Error;
 
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
         loop {
             match self.swarm.poll() {
-                Ok(Async::Ready(Some(event))) => match event {
-                    BehaviourEvent::GossipMessage {
-                        id,
-                        source,
-                        topics,
-                        message,
-                    } => {
-                        trace!(self.log, "Gossipsub message received"; "service" => "Swarm");
-                        return Ok(Async::Ready(Some(Libp2pEvent::PubsubMessage {
-                            id,
-                            source,
-                            topics,
-                            message,
-                        })));
-                    }
-                    BehaviourEvent::RPC(peer_id, event) => {
-                        return Ok(Async::Ready(Some(Libp2pEvent::RPC(peer_id, event))));
-                    }
-                    BehaviourEvent::PeerDialed(peer_id) => {
-                        return Ok(Async::Ready(Some(Libp2pEvent::PeerDialed(peer_id))));
-                    }
-                    BehaviourEvent::PeerDisconnected(peer_id) => {
-                        return Ok(Async::Ready(Some(Libp2pEvent::PeerDisconnected(peer_id))));
-                    }
-                    BehaviourEvent::PeerSubscribed(peer_id, topic) => {
-                        return Ok(Async::Ready(Some(Libp2pEvent::PeerSubscribed(
-                            peer_id, topic,
-                        ))));
-                    }
-                },
+                Ok(Async::Ready(Some(event))) => {
+                    return Ok(Async::Ready(Some(event)));
+                }
                 Ok(Async::Ready(None)) => unreachable!("Swarm stream shouldn't end"),
                 Ok(Async::NotReady) => break,
                 _ => break,
@@ -319,26 +290,6 @@ fn build_transport(local_private_key: Keypair) -> Boxed<(PeerId, StreamMuxerBox)
     transport
 }
 
-#[derive(Debug)]
-/// Events that can be obtained from polling the Libp2p Service.
-pub enum Libp2pEvent<TSpec: EthSpec> {
-    /// An RPC response request has been received on the swarm.
-    RPC(PeerId, RPCEvent<TSpec>),
-    /// Initiated the connection to a new peer.
-    PeerDialed(PeerId),
-    /// A peer has disconnected.
-    PeerDisconnected(PeerId),
-    /// Received pubsub message.
-    PubsubMessage {
-        id: MessageId,
-        source: PeerId,
-        topics: Vec<TopicHash>,
-        message: PubsubMessage<TSpec>,
-    },
-    /// Subscribed to peer for a topic hash.
-    PeerSubscribed(PeerId, TopicHash),
-}
-
 fn keypair_from_hex(hex_bytes: &str) -> error::Result<Keypair> {
     let hex_bytes = if hex_bytes.starts_with("0x") {
         hex_bytes[2..].to_string()