Network protocol upgrades (#2345)

This provides a number of upgrades to gossipsub and discovery. 

The updates are extensive and this needs thorough testing.

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

@@ -56,7 +56,7 @@ impl<TSpec: EthSpec> DelegatingHandler<TSpec> {
 
 /// Wrapper around the `ProtocolsHandler::InEvent` types of the handlers.
 /// Simply delegated to the corresponding behaviour's handler.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum DelegateIn<TSpec: EthSpec> {
     Gossipsub(<GossipHandler as ProtocolsHandler>::InEvent),
     RPC(<RPCHandler<TSpec> as ProtocolsHandler>::InEvent),
@@ -141,8 +141,8 @@ impl<TSpec: EthSpec> ProtocolsHandler for DelegatingHandler<TSpec> {
             .max(identify_proto.timeout());
 
         let select = SelectUpgrade::new(
-            gossip_proto.into_upgrade().1,
-            SelectUpgrade::new(rpc_proto.into_upgrade().1, identify_proto.into_upgrade().1),
+            gossip_proto.into_upgrade().0,
+            SelectUpgrade::new(rpc_proto.into_upgrade().0, identify_proto.into_upgrade().0),
         );
 
         SubstreamProtocol::new(select, ()).with_timeout(timeout)
@@ -202,7 +202,7 @@ impl<TSpec: EthSpec> ProtocolsHandler for DelegatingHandler<TSpec> {
         match event {
             DelegateIn::Gossipsub(ev) => self.gossip_handler.inject_event(ev),
             DelegateIn::RPC(ev) => self.rpc_handler.inject_event(ev),
-            DelegateIn::Identify(()) => self.identify_handler.inject_event(()),
+            DelegateIn::Identify(ev) => self.identify_handler.inject_event(ev),
         }
     }
 

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

@@ -34,7 +34,6 @@ impl<TSpec: EthSpec> BehaviourHandler<TSpec> {
     }
 }
 
-#[derive(Clone)]
 pub enum BehaviourHandlerIn<TSpec: EthSpec> {
     Delegate(DelegateIn<TSpec>),
     /// Start the shutdown process.

beacon_node/eth2_libp2p/src/behaviour/mod.rs

@@ -24,7 +24,7 @@ use libp2p::{
         Gossipsub as BaseGossipsub, GossipsubEvent, IdentTopic as Topic, MessageAcceptance,
         MessageAuthenticity, MessageId, PeerScoreThresholds,
     },
-    identify::{Identify, IdentifyEvent},
+    identify::{Identify, IdentifyConfig, IdentifyEvent},
     swarm::{
         AddressScore, NetworkBehaviour, NetworkBehaviourAction as NBAction, NotifyHandler,
         PollParameters, ProtocolsHandler,
@@ -151,18 +151,14 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
     ) -> error::Result<Self> {
         let behaviour_log = log.new(o!());
 
-        let identify = if net_conf.private {
-            Identify::new(
-                "".into(),
+        let identify_config = if net_conf.private {
+            IdentifyConfig::new(
                 "".into(),
                 local_key.public(), // Still send legitimate public key
             )
         } else {
-            Identify::new(
-                "lighthouse/libp2p".into(),
-                lighthouse_version::version_with_platform(),
-                local_key.public(),
-            )
+            IdentifyConfig::new("eth2/1.0.0".into(), local_key.public())
+                .with_agent_version(lighthouse_version::version_with_platform())
         };
 
         let enr_fork_id = network_globals
@@ -221,7 +217,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         Ok(Behaviour {
             eth2_rpc: RPC::new(log.clone()),
             gossipsub,
-            identify,
+            identify: Identify::new(identify_config),
             peer_manager: PeerManager::new(local_key, net_conf, network_globals.clone(), log)
                 .await?,
             events: VecDeque::new(),
@@ -902,11 +898,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
 
     fn on_identify_event(&mut self, event: IdentifyEvent) {
         match event {
-            IdentifyEvent::Received {
-                peer_id,
-                mut info,
-                observed_addr,
-            } => {
+            IdentifyEvent::Received { peer_id, mut info } => {
                 if info.listen_addrs.len() > MAX_IDENTIFY_ADDRESSES {
                     debug!(
                         self.log,
@@ -921,12 +913,13 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                     "protocol_version" => info.protocol_version,
                     "agent_version" => info.agent_version,
                     "listening_ addresses" => ?info.listen_addrs,
-                    "observed_address" => ?observed_addr,
+                    "observed_address" => ?info.observed_addr,
                     "protocols" => ?info.protocols
                 );
             }
             IdentifyEvent::Sent { .. } => {}
             IdentifyEvent::Error { .. } => {}
+            IdentifyEvent::Pushed { .. } => {}
         }
     }
 
@@ -1171,12 +1164,16 @@ impl<TSpec: EthSpec> NetworkBehaviour for Behaviour<TSpec> {
         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_new_listener(&mut self, id: ListenerId) {
+        delegate_to_behaviours!(self, inject_new_listener, id);
     }
 
-    fn inject_expired_listen_addr(&mut self, addr: &Multiaddr) {
-        delegate_to_behaviours!(self, inject_expired_listen_addr, addr);
+    fn inject_new_listen_addr(&mut self, id: ListenerId, addr: &Multiaddr) {
+        delegate_to_behaviours!(self, inject_new_listen_addr, id, addr);
+    }
+
+    fn inject_expired_listen_addr(&mut self, id: ListenerId, addr: &Multiaddr) {
+        delegate_to_behaviours!(self, inject_expired_listen_addr, id, addr);
     }
 
     fn inject_new_external_addr(&mut self, addr: &Multiaddr) {