Update libp2p from 0.50.0 to 0.53.1

Cargo.toml

@@ -109,9 +109,8 @@ proptest = "1.1"
 pin-project-lite = "0.2"
 axum = "0.5"
 lazy_static = "1.4"
-libp2p-prom-client = { package = "prometheus-client", version = "0.18" }
 once_cell = "1.16"
-prometheus-client = "0.20"
+prometheus-client = "0.22.0"
 itertools = "0.10"
 insta = "1.8"
 tempfile = "3.4"

crates/fuel-core/src/p2p_test_helpers.rs

@@ -378,11 +378,11 @@ pub fn make_config(name: String, mut node_config: Config) -> Config {
 pub async fn make_node(node_config: Config, test_txs: Vec<Transaction>) -> Node {
     let db = Database::in_memory();
     let node = tokio::time::timeout(
-        Duration::from_secs(1),
+        Duration::from_secs(2),
         FuelService::from_database(db.clone(), node_config),
     )
     .await
-    .expect("All services should start in less than 1 second")
+    .expect("All services should start in less than 2 second")
     .expect("The `FuelService should start without error");
 
     let config = node.shared.config.clone();

crates/fuel-core/src/service/adapters/producer.rs

@@ -22,9 +22,7 @@ use fuel_core_storage::{
 use fuel_core_types::{
     blockchain::{
         block::CompressedBlock,
-        primitives::{
-            self,
-        },
+        primitives,
     },
     fuel_tx,
     fuel_tx::Receipt,

crates/metrics/Cargo.toml

@@ -12,7 +12,6 @@ description = "Fuel metrics"
 
 [dependencies]
 axum = { workspace = true }
-libp2p-prom-client = { workspace = true }
 once_cell = { workspace = true }
 pin-project-lite = { workspace = true }
 prometheus-client = { workspace = true }

crates/metrics/src/p2p_metrics.rs

@@ -1,8 +1,8 @@
-use libp2p_prom_client::{
+use once_cell::race::OnceBox;
+use prometheus_client::{
     metrics::counter::Counter,
     registry::Registry,
 };
-use once_cell::race::OnceBox;
 use std::sync::OnceLock;
 
 pub struct P2PMetrics {
@@ -27,7 +27,7 @@ impl P2PMetrics {
         metrics.peer_metrics.register(
             "Peer_Counter",
             "A Counter which keeps track of each unique peer the p2p service has connected to",
-            Box::new(metrics.unique_peers.clone()),
+            metrics.unique_peers.clone(),
         );
 
         metrics

crates/metrics/src/response.rs

@@ -13,23 +13,20 @@ use axum::{
     },
 };
 use core::ops::Deref;
-use libp2p_prom_client::encoding::text::encode as libp2p_encode;
 use prometheus_client::encoding::text::encode;
 
 pub fn encode_metrics_response() -> impl IntoResponse {
     // encode libp2p metrics using older prometheus
-    let mut libp2p_bytes = Vec::<u8>::new();
+    let mut encoded = String::new();
     if let Some(value) = p2p_metrics().gossip_sub_registry.get() {
-        if libp2p_encode(&mut libp2p_bytes, value).is_err() {
+        if encode(&mut encoded, value).is_err() {
             return error_body()
         }
     }
-    if libp2p_encode(&mut libp2p_bytes, &p2p_metrics().peer_metrics).is_err() {
+    if encode(&mut encoded, &p2p_metrics().peer_metrics).is_err() {
         return error_body()
     }
 
-    let mut encoded = String::from_utf8_lossy(&libp2p_bytes).into_owned();
-
     // encode the rest of the fuel-core metrics using latest prometheus
     {
         let lock = services_metrics()

crates/services/p2p/Cargo.toml

@@ -21,46 +21,50 @@ fuel-core-types = { workspace = true, features = [
     "serde",
 ] }
 futures = { workspace = true }
+hex = "0.4"
 ip_network = "0.4"
-libp2p = { version = "=0.50.0", default-features = false, features = [
+libp2p = { version = "=0.53.1", 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-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-allow-block-list = "=0.3.0"
+libp2p-core = "=0.41.1"
+libp2p-dns = "=0.41.0"
+libp2p-gossipsub = "=0.46.0"
+libp2p-identify = "=0.44.0"
+libp2p-kad = "=0.45.1"
+libp2p-mdns = "=0.45.1"
+libp2p-mplex = "=0.41.0"
+libp2p-noise = "=0.44.0"
+libp2p-request-response = "=0.26.0"
+libp2p-swarm = "=0.44.0"
+libp2p-tcp = "=0.41.0"
+libp2p-tls = "0.3.0"
+libp2p-websocket = "=0.43.0"
+libp2p-yamux = "=0.45.0"
 postcard = { workspace = true, features = ["use-std"] }
 prometheus-client = { workspace = true }
+quick-protobuf = "0.8.1"
+quick-protobuf-codec = "0.3.0"
 rand = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_with = "1.11"
 sha2 = "0.10"
 thiserror = "1.0.47"
 tokio = { workspace = true, features = ["sync"] }
 tracing = { workspace = true }
+void = "1"
 
 [dev-dependencies]
 ctor = "0.1"
@@ -75,5 +79,8 @@ tokio = { workspace = true, features = ["full", "test-util"] }
 tracing-attributes = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
+[dev-dependencies.libp2p-swarm-test]
+version = "0.3.0"
+
 [features]
 test-helpers = ["fuel-core-types/test-helpers"]

crates/services/p2p/src/behavior.rs

@@ -9,6 +9,7 @@ use crate::{
         config::build_gossipsub_behaviour,
         topics::GossipTopic,
     },
+    heartbeat,
     peer_report::{
         PeerReportBehaviour,
         PeerReportEvent,
@@ -21,47 +22,63 @@ 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,
     },
+    identify,
     request_response::{
+        Behaviour as RequestResponse,
+        Config as RequestResponseConfig,
+        Event as RequestResponseEvent,
         ProtocolSupport,
-        RequestId,
-        RequestResponse,
-        RequestResponseConfig,
-        RequestResponseEvent,
         ResponseChannel,
     },
     swarm::NetworkBehaviour,
     Multiaddr,
     PeerId,
 };
-use libp2p_kad::KademliaEvent;
+use libp2p_allow_block_list as allow_block_list;
+use libp2p_kad::Event as KademliaEvent;
+use libp2p_request_response::OutboundRequestId;
 
 #[derive(Debug)]
 pub enum FuelBehaviourEvent {
     Discovery(KademliaEvent),
     PeerReport(PeerReportEvent),
     Gossipsub(GossipsubEvent),
     RequestResponse(RequestResponseEvent<RequestMessage, NetworkResponse>),
+    BlockedPeers(void::Void),
+    Identify(identify::Event),
+    Heartbeat(heartbeat::HeartbeatEvent),
 }
 
 /// 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,
+    /// **WARNING**: The order of the behaviours is important and fragile, at least for the tests.
 
-    /// Identifies and periodically requests `BlockHeight` from connected nodes
-    peer_report: PeerReportBehaviour,
+    /// The Behaviour to manage connections to blocked peers.
+    blocked_peer: allow_block_list::Behaviour<allow_block_list::BlockedPeers>,
 
     /// Message propagation for p2p
     gossipsub: Gossipsub,
 
+    /// Handles regular heartbeats from peers
+    heartbeat: heartbeat::Heartbeat,
+
+    /// The Behaviour to identify peers.
+    identify: identify::Behaviour,
+
+    /// Identifies and periodically requests `BlockHeight` from connected nodes
+    peer_report: PeerReportBehaviour,
+
+    /// Node discovery
+    discovery: DiscoveryBehaviour,
+
     /// RequestResponse protocol
     request_response: RequestResponse<Codec>,
 }
@@ -77,8 +94,7 @@ impl<Codec: NetworkCodec> FuelBehaviour<Codec> {
 
             discovery_config
                 .enable_mdns(p2p_config.enable_mdns)
-                .discovery_limit(p2p_config.max_peers_connected as usize)
-                .allow_private_addresses(p2p_config.allow_private_addresses)
+                .max_peers_connected(p2p_config.max_peers_connected as usize)
                 .with_bootstrap_nodes(p2p_config.bootstrap_nodes.clone())
                 .with_reserved_nodes(p2p_config.reserved_nodes.clone())
                 .enable_reserved_nodes_only_mode(p2p_config.reserved_nodes_only_mode);
@@ -98,21 +114,42 @@ impl<Codec: NetworkCodec> FuelBehaviour<Codec> {
 
         let peer_report = PeerReportBehaviour::new(p2p_config);
 
+        let identify = {
+            let identify_config = identify::Config::new(
+                "/fuel/1.0".to_string(),
+                p2p_config.keypair.public(),
+            );
+            if let Some(interval) = p2p_config.identify_interval {
+                identify::Behaviour::new(identify_config.with_interval(interval))
+            } else {
+                identify::Behaviour::new(identify_config)
+            }
+        };
+
+        let heartbeat = heartbeat::Heartbeat::new(
+            p2p_config.heartbeat_config.clone(),
+            BlockHeight::default(),
+        );
+
         let req_res_protocol =
-            std::iter::once((codec.get_req_res_protocol(), ProtocolSupport::Full));
+            core::iter::once((codec.get_req_res_protocol(), ProtocolSupport::Full));
 
-        let mut req_res_config = RequestResponseConfig::default();
-        req_res_config.set_request_timeout(p2p_config.set_request_timeout);
-        req_res_config.set_connection_keep_alive(p2p_config.set_connection_keep_alive);
+        let req_res_config = RequestResponseConfig::default();
+        req_res_config
+            .clone()
+            .with_request_timeout(p2p_config.set_request_timeout);
 
         let request_response =
-            RequestResponse::new(codec, req_res_protocol, req_res_config);
+            RequestResponse::with_codec(codec, req_res_protocol, req_res_config);
 
         Self {
             discovery: discovery_config.finish(),
             gossipsub,
             peer_report,
             request_response,
+            blocked_peer: Default::default(),
+            identify,
+            heartbeat,
         }
     }
 
@@ -138,7 +175,7 @@ impl<Codec: NetworkCodec> FuelBehaviour<Codec> {
         &mut self,
         message_request: RequestMessage,
         peer_id: &PeerId,
-    ) -> RequestId {
+    ) -> OutboundRequestId {
         self.request_response.send_request(peer_id, message_request)
     }
 
@@ -181,13 +218,17 @@ impl<Codec: NetworkCodec> FuelBehaviour<Codec> {
     }
 
     pub fn update_block_height(&mut self, block_height: BlockHeight) {
-        self.peer_report.update_block_height(block_height);
+        self.heartbeat.update_block_height(block_height);
     }
 
     #[cfg(test)]
     pub fn get_peer_score(&self, peer_id: &PeerId) -> Option<f64> {
         self.gossipsub.peer_score(peer_id)
     }
+
+    pub fn block_peer(&mut self, peer_id: PeerId) {
+        self.blocked_peer.block_peer(peer_id)
+    }
 }
 
 impl From<KademliaEvent> for FuelBehaviourEvent {
@@ -213,3 +254,21 @@ impl From<RequestResponseEvent<RequestMessage, NetworkResponse>> for FuelBehavio
         FuelBehaviourEvent::RequestResponse(event)
     }
 }
+
+impl From<identify::Event> for FuelBehaviourEvent {
+    fn from(event: identify::Event) -> Self {
+        FuelBehaviourEvent::Identify(event)
+    }
+}
+
+impl From<heartbeat::HeartbeatEvent> for FuelBehaviourEvent {
+    fn from(event: heartbeat::HeartbeatEvent) -> Self {
+        FuelBehaviourEvent::Heartbeat(event)
+    }
+}
+
+impl From<void::Void> for FuelBehaviourEvent {
+    fn from(event: void::Void) -> Self {
+        FuelBehaviourEvent::BlockedPeers(event)
+    }
+}

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