upgrade libp2p to v0.53.*

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.69.0-bullseye AS builder
+FROM rust:1.73.0-bullseye AS builder
 RUN apt-get update && apt-get -y upgrade && apt-get install -y cmake libclang-dev
 COPY . lighthouse
 ARG FEATURES
@@ -15,4 +15,4 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-reco
   ca-certificates \
   && apt-get clean \
   && rm -rf /var/lib/apt/lists/*
-COPY --from=builder /usr/local/cargo/bin/lighthouse /usr/local/bin/lighthouse
+COPY --from=builder /usr/local/cargo/bin/lighthouse /usr/local/bin/lighthouse

beacon_node/client/src/builder.rs

@@ -68,7 +68,7 @@ pub struct ClientBuilder<T: BeaconChainTypes> {
     eth1_service: Option<Eth1Service>,
     network_globals: Option<Arc<NetworkGlobals<T::EthSpec>>>,
     network_senders: Option<NetworkSenders<T::EthSpec>>,
-    gossipsub_registry: Option<Registry>,
+    libp2p_registry: Option<Registry>,
     db_path: Option<PathBuf>,
     freezer_db_path: Option<PathBuf>,
     http_api_config: http_api::Config,
@@ -102,7 +102,7 @@ where
             eth1_service: None,
             network_globals: None,
             network_senders: None,
-            gossipsub_registry: None,
+            libp2p_registry: None,
             db_path: None,
             freezer_db_path: None,
             http_api_config: <_>::default(),
@@ -531,7 +531,7 @@ where
             .ok_or("network requires beacon_processor_channels")?;
 
         // If gossipsub metrics are required we build a registry to record them
-        let mut gossipsub_registry = if config.metrics_enabled {
+        let mut libp2p_registry = if config.metrics_enabled {
             Some(Registry::default())
         } else {
             None
@@ -541,9 +541,7 @@ where
             beacon_chain,
             config,
             context.executor,
-            gossipsub_registry
-                .as_mut()
-                .map(|registry| registry.sub_registry_with_prefix("gossipsub")),
+            libp2p_registry.as_mut(),
             beacon_processor_channels.beacon_processor_tx.clone(),
             beacon_processor_channels.work_reprocessing_tx.clone(),
         )
@@ -552,7 +550,7 @@ where
 
         self.network_globals = Some(network_globals);
         self.network_senders = Some(network_senders);
-        self.gossipsub_registry = gossipsub_registry;
+        self.libp2p_registry = libp2p_registry;
 
         Ok(self)
     }
@@ -718,7 +716,7 @@ where
                 chain: self.beacon_chain.clone(),
                 db_path: self.db_path.clone(),
                 freezer_db_path: self.freezer_db_path.clone(),
-                gossipsub_registry: self.gossipsub_registry.take().map(std::sync::Mutex::new),
+                gossipsub_registry: self.libp2p_registry.take().map(std::sync::Mutex::new),
                 log: log.clone(),
             });
 

beacon_node/lighthouse_network/Cargo.toml

@@ -39,17 +39,17 @@ directory = { workspace = true }
 regex = { workspace = true }
 strum = { workspace = true }
 superstruct = { workspace = true }
-prometheus-client = "0.21.0"
+prometheus-client = "0.22.0"
 unused_port = { workspace = true }
 delay_map = { workspace = true }
 void = "1"
-libp2p-quic= { version = "0.9.2", features=["tokio"]}
-libp2p-mplex = "0.40.0"
+libp2p-quic= { version = "0.10.1", features=["tokio"]}
+libp2p-mplex = "0.41.0"
 
 [dependencies.libp2p]
-version = "0.52"
+version = "0.53"
 default-features = false
-features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa"]
+features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa", "metrics"]
 
 [dev-dependencies]
 slog-term = { workspace = true }

beacon_node/lighthouse_network/src/config.rs

@@ -457,9 +457,9 @@ pub fn gossipsub_config(
 ) -> gossipsub::Config {
     // The function used to generate a gossipsub message id
     // We use the first 8 bytes of SHA256(topic, data) for content addressing
-    let fast_gossip_message_id = |message: &gossipsub::RawMessage| {
+    let fast_gossip_message_id = |message: &gossipsub::Message| {
         let data = [message.topic.as_str().as_bytes(), &message.data].concat();
-        gossipsub::FastMessageId::from(&Sha256::digest(&data)[..8])
+        gossipsub::MessageId::from(&Sha256::digest(&data)[..8])
     };
     fn prefix(
         prefix: [u8; 4],
@@ -518,7 +518,7 @@ pub fn gossipsub_config(
         .validation_mode(gossipsub::ValidationMode::Anonymous)
         .duplicate_cache_time(DUPLICATE_CACHE_TIME)
         .message_id_fn(gossip_message_id)
-        .fast_message_id_fn(fast_gossip_message_id)
+        .message_id_fn(fast_gossip_message_id)
         .allow_self_origin(true)
         .build()
         .expect("valid gossipsub configuration")

beacon_node/lighthouse_network/src/discovery/mod.rs

@@ -29,7 +29,7 @@ pub use libp2p::{
     identity::PeerId,
     swarm::{
         dummy::ConnectionHandler, ConnectionId, DialError, NetworkBehaviour, NotifyHandler,
-        PollParameters, SubstreamProtocol, ToSwarm,
+        SubstreamProtocol, ToSwarm,
     },
 };
 use lru::LruCache;
@@ -955,11 +955,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
     }
 
     // Main execution loop to drive the behaviour
-    fn poll(
-        &mut self,
-        cx: &mut Context,
-        _: &mut impl PollParameters,
-    ) -> Poll<ToSwarm<Self::ToSwarm, THandlerInEvent<Self>>> {
+    fn poll(&mut self, cx: &mut Context) -> Poll<ToSwarm<Self::ToSwarm, THandlerInEvent<Self>>> {
         if !self.started {
             return Poll::Pending;
         }
@@ -1041,7 +1037,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
         Poll::Pending
     }
 
-    fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+    fn on_swarm_event(&mut self, event: FromSwarm) {
         match event {
             FromSwarm::DialFailure(DialFailure { peer_id, error, .. }) => {
                 self.on_dial_failure(peer_id, error)
@@ -1114,17 +1110,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
                     Err(e) => warn!(self.log, "Failed to update ENR"; "error" => ?e),
                 }
             }
-            FromSwarm::ConnectionEstablished(_)
-            | FromSwarm::ConnectionClosed(_)
-            | FromSwarm::AddressChange(_)
-            | FromSwarm::ListenFailure(_)
-            | FromSwarm::NewListener(_)
-            | FromSwarm::ExpiredListenAddr(_)
-            | FromSwarm::ListenerError(_)
-            | FromSwarm::ListenerClosed(_)
-            | FromSwarm::NewExternalAddrCandidate(_)
-            | FromSwarm::ExternalAddrExpired(_)
-            | FromSwarm::ExternalAddrConfirmed(_) => {
+            _ => {
                 // Ignore events not relevant to discovery
             }
         }

beacon_node/lighthouse_network/src/lib.rs

@@ -115,7 +115,6 @@ pub use config::Config as NetworkConfig;
 pub use discovery::{CombinedKeyExt, EnrExt, Eth2Enr};
 pub use discv5;
 pub use libp2p;
-pub use libp2p::bandwidth::BandwidthSinks;
 pub use libp2p::gossipsub::{IdentTopic, MessageAcceptance, MessageId, Topic, TopicHash};
 pub use libp2p::{core::ConnectedPoint, PeerId, Swarm};
 pub use libp2p::{multiaddr, Multiaddr};

beacon_node/lighthouse_network/src/metrics.rs

@@ -1,6 +1,3 @@
-use libp2p::bandwidth::BandwidthSinks;
-use std::sync::Arc;
-
 pub use lighthouse_metrics::*;
 
 lazy_static! {
@@ -187,46 +184,3 @@ pub fn scrape_discovery_metrics() {
     set_gauge(&DISCOVERY_SENT_BYTES, metrics.bytes_sent as i64);
     set_gauge(&DISCOVERY_RECV_BYTES, metrics.bytes_recv as i64);
 }
-
-/// Aggregated `BandwidthSinks` of tcp and quic transports
-/// used in libp2p.
-pub struct AggregatedBandwidthSinks {
-    tcp_sinks: Arc<BandwidthSinks>,
-    quic_sinks: Option<Arc<BandwidthSinks>>,
-}
-
-impl AggregatedBandwidthSinks {
-    /// Create a new `AggregatedBandwidthSinks`.
-    pub fn new(tcp_sinks: Arc<BandwidthSinks>, quic_sinks: Option<Arc<BandwidthSinks>>) -> Self {
-        AggregatedBandwidthSinks {
-            tcp_sinks,
-            quic_sinks,
-        }
-    }
-
-    /// Total QUIC inbound bandwidth.
-    pub fn total_quic_inbound(&self) -> u64 {
-        self.quic_sinks
-            .as_ref()
-            .map(|q| q.total_inbound())
-            .unwrap_or_default()
-    }
-
-    /// Total TCP inbound bandwidth.
-    pub fn total_tcp_inbound(&self) -> u64 {
-        self.tcp_sinks.total_inbound()
-    }
-
-    /// Total QUIC outbound bandwidth.
-    pub fn total_quic_outbound(&self) -> u64 {
-        self.quic_sinks
-            .as_ref()
-            .map(|q| q.total_outbound())
-            .unwrap_or_default()
-    }
-
-    /// Total TCP outbound bandwidth.
-    pub fn total_tcp_outbound(&self) -> u64 {
-        self.tcp_sinks.total_outbound()
-    }
-}

beacon_node/lighthouse_network/src/peer_manager/network_behaviour.rs

@@ -9,7 +9,7 @@ use libp2p::identity::PeerId;
 use libp2p::swarm::behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm};
 use libp2p::swarm::dial_opts::{DialOpts, PeerCondition};
 use libp2p::swarm::dummy::ConnectionHandler;
-use libp2p::swarm::{ConnectionDenied, ConnectionId, NetworkBehaviour, PollParameters, ToSwarm};
+use libp2p::swarm::{ConnectionDenied, ConnectionId, NetworkBehaviour, ToSwarm};
 use slog::{debug, error, trace};
 use types::EthSpec;
 
@@ -36,11 +36,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for PeerManager<TSpec> {
         // no events from the dummy handler
     }
 
-    fn poll(
-        &mut self,
-        cx: &mut Context<'_>,
-        _params: &mut impl PollParameters,
-    ) -> Poll<ToSwarm<Self::ToSwarm, void::Void>> {
+    fn poll(&mut self, cx: &mut Context<'_>) -> Poll<ToSwarm<Self::ToSwarm, void::Void>> {
         // perform the heartbeat when necessary
         while self.heartbeat.poll_tick(cx).is_ready() {
             self.heartbeat();
@@ -121,7 +117,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for PeerManager<TSpec> {
         Poll::Pending
     }
 
-    fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+    fn on_swarm_event(&mut self, event: FromSwarm) {
         match event {
             FromSwarm::ConnectionEstablished(ConnectionEstablished {
                 peer_id,
@@ -155,15 +151,9 @@ impl<TSpec: EthSpec> NetworkBehaviour for PeerManager<TSpec> {
                 // TODO: we likely want to check this against our assumed external tcp
                 // address
             }
-            FromSwarm::AddressChange(_)
-            | FromSwarm::ListenFailure(_)
-            | FromSwarm::NewListener(_)
-            | FromSwarm::NewListenAddr(_)
-            | FromSwarm::ExpiredListenAddr(_)
-            | FromSwarm::ListenerError(_)
-            | FromSwarm::ListenerClosed(_)
-            | FromSwarm::NewExternalAddrCandidate(_)
-            | FromSwarm::ExternalAddrExpired(_) => {
+            _ => {
+                // NOTE: FromSwarm is a non exhaustive enum so updates should be based on release
+                // notes more than compiler feedback
                 // The rest of the events we ignore since they are handled in their associated
                 // `SwarmEvent`
             }