Update libp2p from 0.50.0 to 0.53.1

crates/services/p2p/Cargo.toml

@@ -22,36 +22,35 @@ fuel-core-types = { workspace = true, features = [
 ] }
 futures = { workspace = true }
 ip_network = "0.4"
-libp2p = { version = "=0.50.0", default-features = false, features = [
+libp2p = { version = "=0.52.3", default-features = false, features = [
     "dns",
     "gossipsub",
     "identify",
     "kad",
     "macros",
     "mdns",
-    "mplex",
-    "noise",    
+    "noise",
     "request-response",
     "secp256k1",
     "tcp",
     "tokio",
     "yamux",
     "websocket",
 ] }
-libp2p-core = "=0.38.0"
-libp2p-dns = "=0.38.0"
-libp2p-gossipsub = "=0.43.0"
-libp2p-identify = "=0.41.0"
-libp2p-kad = "=0.42.0"
-libp2p-mdns = "=0.42.0"
-libp2p-mplex = "=0.38.0"
-libp2p-noise = "=0.41.0"
+libp2p-core = "=0.40.1"
+libp2p-dns = "=0.40.0"
+libp2p-gossipsub = "=0.45.1"
+libp2p-identify = "=0.43.0"
+libp2p-kad = "=0.44.5"
+libp2p-mdns = "=0.44.0"
+libp2p-mplex = "=0.40.0"
+libp2p-noise = "=0.43.1"
 libp2p-prom-client = { workspace = true }
-libp2p-request-response = "=0.23.0"
-libp2p-swarm = "=0.41.1"
-libp2p-tcp = "=0.38.0"
-libp2p-websocket = "=0.40.0"
-libp2p-yamux = "=0.42.0"
+libp2p-request-response = "=0.25.1"
+libp2p-swarm = "=0.43.4"
+libp2p-tcp = "=0.40.0"
+libp2p-websocket = "=0.42.1"
+libp2p-yamux = "=0.44.1"
 postcard = { workspace = true, features = ["use-std"] }
 prometheus-client = { workspace = true }
 rand = { workspace = true }

crates/services/p2p/src/behavior.rs

@@ -21,18 +21,18 @@ use crate::{
 use fuel_core_types::fuel_types::BlockHeight;
 use libp2p::{
     gossipsub::{
-        error::PublishError,
-        Gossipsub,
-        GossipsubEvent,
+        Behaviour as Gossipsub,
+        Event as GossipsubEvent,
         MessageAcceptance,
         MessageId,
+        PublishError,
     },
     request_response::{
+        Behaviour as RequestResponse,
+        Config as RequestResponseConfig,
+        Event as RequestResponseEvent,
         ProtocolSupport,
         RequestId,
-        RequestResponse,
-        RequestResponseConfig,
-        RequestResponseEvent,
         ResponseChannel,
     },
     swarm::NetworkBehaviour,
@@ -51,7 +51,7 @@ pub enum FuelBehaviourEvent {
 
 /// Handles all p2p protocols needed for Fuel.
 #[derive(NetworkBehaviour)]
-#[behaviour(out_event = "FuelBehaviourEvent")]
+#[behaviour(to_swarm = "FuelBehaviourEvent")]
 pub struct FuelBehaviour<Codec: NetworkCodec> {
     /// Node discovery
     discovery: DiscoveryBehaviour,

crates/services/p2p/src/codecs.rs

@@ -13,7 +13,7 @@ use crate::{
         ResponseMessage,
     },
 };
-use libp2p::request_response::RequestResponseCodec;
+use libp2p::request_response::Codec as RequestResponseCodec;
 use std::io;
 
 /// Implement this in order to handle serialization & deserialization of Gossipsub messages

crates/services/p2p/src/codecs/postcard.rs

@@ -24,14 +24,11 @@ use futures::{
     AsyncWriteExt,
 };
 use libp2p::{
-    core::{
-        upgrade::{
-            read_length_prefixed,
-            write_length_prefixed,
-        },
-        ProtocolName,
+    core::upgrade::{
+        read_length_prefixed,
+        write_length_prefixed,
     },
-    request_response::RequestResponseCodec,
+    request_response::Codec as RequestResponseCodec,
 };
 use serde::{
     Deserialize,
@@ -266,11 +263,11 @@ impl NetworkCodec for PostcardCodec {
 #[derive(Debug, Clone)]
 pub struct MessageExchangePostcardProtocol;
 
-impl ProtocolName for MessageExchangePostcardProtocol {
-    fn protocol_name(&self) -> &[u8] {
-        REQUEST_RESPONSE_PROTOCOL_ID
-    }
-}
+// impl ProtocolName for MessageExchangePostcardProtocol {
+//     fn protocol_name(&self) -> &[u8] {
+//         REQUEST_RESPONSE_PROTOCOL_ID
+//     }
+// }
 
 #[cfg(test)]
 mod tests {

crates/services/p2p/src/config.rs

@@ -10,22 +10,26 @@ use libp2p::{
         muxing::StreamMuxerBox,
         transport::Boxed,
     },
-    gossipsub::GossipsubConfig,
+    gossipsub::Config as GossipsubConfig,
+    identity,
     identity::{
         secp256k1::SecretKey,
         Keypair,
     },
-    mplex,
-    noise::{self,},
+    noise::{
+        Config as NoiseConfig,
+        {self,},
+    },
     tcp::{
         tokio::Transport as TokioTcpTransport,
         Config as TcpConfig,
     },
-    yamux,
     Multiaddr,
     PeerId,
     Transport,
 };
+use libp2p_mplex::MplexConfig;
+use libp2p_yamux::Config as YamuxConfig;
 use std::{
     collections::HashSet,
     net::{
@@ -272,17 +276,17 @@ pub(crate) fn build_transport(
     .upgrade(libp2p::core::upgrade::Version::V1);
 
     let noise_authenticated = {
-        let dh_keys = noise::Keypair::<noise::X25519Spec>::new()
+        let dh_keys = identity::Keypair::new()
             .into_authentic(&p2p_config.keypair)
             .expect("Noise key generation failed");
 
-        noise::NoiseConfig::xx(dh_keys).into_authenticated()
+        NoiseConfig::xx(dh_keys).into_authenticated()
     };
 
     let multiplex_config = {
-        let mplex_config = mplex::MplexConfig::default();
+        let mplex_config = MplexConfig::default();
 
-        let mut yamux_config = yamux::YamuxConfig::default();
+        let mut yamux_config = YamuxConfig::default();
         yamux_config.set_max_buffer_size(MAX_RESPONSE_SIZE);
         libp2p::core::upgrade::SelectUpgrade::new(yamux_config, mplex_config)
     };

crates/services/p2p/src/config/fuel_authenticated.rs

@@ -1,4 +1,3 @@
-use fuel_core_types::secrecy::Zeroize;
 use futures::{
     future,
     AsyncRead,
@@ -9,10 +8,9 @@ use futures::{
 use libp2p::{
     core::UpgradeInfo,
     noise::{
-        NoiseAuthenticated,
-        NoiseError,
-        NoiseOutput,
-        Protocol,
+        Config as NoiseConfig,
+        Error as NoiseError,
+        Output as NoiseOutput,
     },
     InboundUpgrade,
     OutboundUpgrade,
@@ -26,43 +24,32 @@ pub(crate) trait Approver {
 }
 
 #[derive(Clone)]
-pub(crate) struct FuelAuthenticated<A: Approver, P, C: Zeroize, R> {
-    noise_authenticated: NoiseAuthenticated<P, C, R>,
+pub(crate) struct FuelAuthenticated<A: Approver> {
+    noise_authenticated: NoiseConfig,
     approver: A,
 }
 
-impl<A: Approver, P, C: Zeroize, R> FuelAuthenticated<A, P, C, R> {
-    pub(crate) fn new(
-        noise_authenticated: NoiseAuthenticated<P, C, R>,
-        approver: A,
-    ) -> Self {
+impl<A: Approver> FuelAuthenticated<A> {
+    pub(crate) fn new(noise_authenticated: NoiseConfig, approver: A) -> Self {
         Self {
             noise_authenticated,
             approver,
         }
     }
 }
 
-impl<A: Approver, P, C: Zeroize, R> UpgradeInfo for FuelAuthenticated<A, P, C, R>
-where
-    NoiseAuthenticated<P, C, R>: UpgradeInfo,
-{
-    type Info = <NoiseAuthenticated<P, C, R> as UpgradeInfo>::Info;
-    type InfoIter = <NoiseAuthenticated<P, C, R> as UpgradeInfo>::InfoIter;
+impl<A: Approver> UpgradeInfo for FuelAuthenticated<A> {
+    type Info = <NoiseConfig as UpgradeInfo>::Info;
+    type InfoIter = <NoiseConfig as UpgradeInfo>::InfoIter;
 
     fn protocol_info(&self) -> Self::InfoIter {
         self.noise_authenticated.protocol_info()
     }
 }
 
-impl<A, T, P, C, R> InboundUpgrade<T> for FuelAuthenticated<A, P, C, R>
+impl<A, T> InboundUpgrade<T> for FuelAuthenticated<A>
 where
-    NoiseAuthenticated<P, C, R>: UpgradeInfo
-        + InboundUpgrade<T, Output = (PeerId, NoiseOutput<T>), Error = NoiseError>
-        + 'static,
-    <NoiseAuthenticated<P, C, R> as InboundUpgrade<T>>::Future: Send,
     T: AsyncRead + AsyncWrite + Send + 'static,
-    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
     A: Approver + Send + 'static,
 {
     type Output = (PeerId, NoiseOutput<T>);
@@ -84,14 +71,9 @@ where
     }
 }
 
-impl<A, T, P, C, R> OutboundUpgrade<T> for FuelAuthenticated<A, P, C, R>
+impl<A, T> OutboundUpgrade<T> for FuelAuthenticated<A>
 where
-    NoiseAuthenticated<P, C, R>: UpgradeInfo
-        + OutboundUpgrade<T, Output = (PeerId, NoiseOutput<T>), Error = NoiseError>
-        + 'static,
-    <NoiseAuthenticated<P, C, R> as OutboundUpgrade<T>>::Future: Send,
     T: AsyncRead + AsyncWrite + Send + 'static,
-    C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
     A: Approver + Send + 'static,
 {
     type Output = (PeerId, NoiseOutput<T>);