Switch libp2p sigp gossipsub fork (#4999)

* switch libp2p source to sigp fork * Shift the connection closing inside RPC behaviour * Tag specific commits * Add slow peer scoring * Fix test * Use default yamux config * Pin discv5 to our libp2p fork and cargo update * Upgrade libp2p to enable yamux gains * Add a comment specifying the branch being used * cleanup build output from within container (prevents CI warnings related to fs permissions) * Remove revision tags add branches for testing, will revert back once we're happy * Update to latest rust-libp2p version * Pin forks * Update cargo.lock * Re-pin to panic-free rust --------- Co-authored-by: Age Manning <[email protected]> Co-authored-by: Pawan Dhananjay <[email protected]> Co-authored-by: antondlr <[email protected]> Co-authored-by: Michael Sproul <[email protected]>
sigp · Jan 10, 2024 · 38df87c · 38df87c
1 parent be79f74
commit 38df87c
Show file tree

Hide file tree

Showing 17 changed files with 1,046 additions and 976 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -105,7 +105,7 @@ criterion = "0.3"
 delay_map = "0.3"
 derivative = "2"
 dirs = "3"
-discv5 = { version = "0.3", features = ["libp2p"] }
+discv5 = { git="https://github.com/sigp/discv5", rev="dbb4a718cd32eaed8127c3c8241bfd0fde9eb908", features = ["libp2p"] }
 env_logger = "0.9"
 error-chain = "0.12"
 ethereum-types = "0.14"
@@ -149,7 +149,7 @@ slog = { version = "2", features = ["max_level_trace", "release_max_level_trace"
 slog-async = "2"
 slog-term = "2"
 sloggers = { version = "2", features = ["json"] }
-smallvec = "1"
+smallvec = "1.11.2"
 snap = "1"
 ssz_types = "0.5"
 strum = { version = "0.24", features = ["derive"] }

diff --git a/Makefile b/Makefile
@@ -210,7 +210,7 @@ cli:
 # `cargo`.
 cli-local:
 	make && ./scripts/cli.sh
-	
+
 # Runs the entire test suite, downloading test vectors if required.
 test-full: cargo-fmt test-release test-debug test-ef test-exec-engine
 

diff --git a/beacon_node/http_api/src/test_utils.rs b/beacon_node/http_api/src/test_utils.rs
@@ -7,7 +7,7 @@ use beacon_processor::{BeaconProcessor, BeaconProcessorChannels, BeaconProcessor
 use directory::DEFAULT_ROOT_DIR;
 use eth2::{BeaconNodeHttpClient, Timeouts};
 use lighthouse_network::{
-    discv5::enr::{CombinedKey, EnrBuilder},
+    discv5::enr::CombinedKey,
     libp2p::swarm::{
         behaviour::{ConnectionEstablished, FromSwarm},
         ConnectionId, NetworkBehaviour,
@@ -138,7 +138,7 @@ pub async fn create_api_server<T: BeaconChainTypes>(
         syncnets: EnrSyncCommitteeBitfield::<T::EthSpec>::default(),
     });
     let enr_key = CombinedKey::generate_secp256k1();
-    let enr = EnrBuilder::new("v4").build(&enr_key).unwrap();
+    let enr = Enr::builder().build(&enr_key).unwrap();
     let network_globals = Arc::new(NetworkGlobals::new(
         enr.clone(),
         meta_data,

diff --git a/beacon_node/lighthouse_network/Cargo.toml b/beacon_node/lighthouse_network/Cargo.toml
@@ -43,10 +43,11 @@ prometheus-client = "0.22.0"
 unused_port = { workspace = true }
 delay_map = { workspace = true }
 void = "1"
-libp2p-mplex = "0.41.0"
+libp2p-mplex = { git = "https://github.com/sigp/rust-libp2p/", rev = "b96b90894faab0a1eed78e1c82c6452138a3538a" }
 
 [dependencies.libp2p]
-version = "0.53"
+git = "https://github.com/sigp/rust-libp2p/"
+rev = "b96b90894faab0a1eed78e1c82c6452138a3538a"
 default-features = false
 features = ["identify", "yamux", "noise", "gossipsub", "dns", "tcp", "tokio", "plaintext", "secp256k1", "macros", "ecdsa", "metrics", "quic"]
 

diff --git a/beacon_node/lighthouse_network/src/config.rs b/beacon_node/lighthouse_network/src/config.rs
@@ -5,7 +5,6 @@ use crate::{Enr, PeerIdSerialized};
 use directory::{
     DEFAULT_BEACON_NODE_DIR, DEFAULT_HARDCODED_NETWORK, DEFAULT_NETWORK_DIR, DEFAULT_ROOT_DIR,
 };
-use discv5::{Discv5Config, Discv5ConfigBuilder};
 use libp2p::gossipsub;
 use libp2p::Multiaddr;
 use serde::{Deserialize, Serialize};
@@ -91,7 +90,7 @@ pub struct Config {
 
     /// Discv5 configuration parameters.
     #[serde(skip)]
-    pub discv5_config: Discv5Config,
+    pub discv5_config: discv5::Config,
 
     /// List of nodes to initially connect to.
     pub boot_nodes_enr: Vec<Enr>,
@@ -324,7 +323,7 @@ impl Default for Config {
             discv5::ListenConfig::from_ip(Ipv4Addr::UNSPECIFIED.into(), 9000);
 
         // discv5 configuration
-        let discv5_config = Discv5ConfigBuilder::new(discv5_listen_config)
+        let discv5_config = discv5::ConfigBuilder::new(discv5_listen_config)
             .enable_packet_filter()
             .session_cache_capacity(5000)
             .request_timeout(Duration::from_secs(1))

diff --git a/beacon_node/lighthouse_network/src/discovery/enr.rs b/beacon_node/lighthouse_network/src/discovery/enr.rs
@@ -1,12 +1,11 @@
 //! Helper functions and an extension trait for Ethereum 2 ENRs.
 
-pub use discv5::enr::{CombinedKey, EnrBuilder};
+pub use discv5::enr::CombinedKey;
 
 use super::enr_ext::CombinedKeyExt;
 use super::ENR_FILENAME;
 use crate::types::{Enr, EnrAttestationBitfield, EnrSyncCommitteeBitfield};
 use crate::NetworkConfig;
-use discv5::enr::EnrKey;
 use libp2p::identity::Keypair;
 use slog::{debug, warn};
 use ssz::{Decode, Encode};
@@ -142,11 +141,13 @@ pub fn build_or_load_enr<T: EthSpec>(
     Ok(local_enr)
 }
 
-pub fn create_enr_builder_from_config<T: EnrKey>(
+/// Builds a lighthouse ENR given a `NetworkConfig`.
+pub fn build_enr<T: EthSpec>(
+    enr_key: &CombinedKey,
     config: &NetworkConfig,
-    enable_libp2p: bool,
-) -> EnrBuilder<T> {
-    let mut builder = EnrBuilder::new("v4");
+    enr_fork_id: &EnrForkId,
+) -> Result<Enr, String> {
+    let mut builder = discv5::enr::Enr::builder();
     let (maybe_ipv4_address, maybe_ipv6_address) = &config.enr_address;
 
     if let Some(ip) = maybe_ipv4_address {
@@ -165,63 +166,51 @@ pub fn create_enr_builder_from_config<T: EnrKey>(
         builder.udp6(udp6_port.get());
     }
 
-    if enable_libp2p {
-        // Add QUIC fields to the ENR.
-        // Since QUIC is used as an alternative transport for the libp2p protocols,
-        // the related fields should only be added when both QUIC and libp2p are enabled
-        if !config.disable_quic_support {
-            // If we are listening on ipv4, add the quic ipv4 port.
-            if let Some(quic4_port) = config.enr_quic4_port.or_else(|| {
-                config
-                    .listen_addrs()
-                    .v4()
-                    .and_then(|v4_addr| v4_addr.quic_port.try_into().ok())
-            }) {
-                builder.add_value(QUIC_ENR_KEY, &quic4_port.get());
-            }
-
-            // If we are listening on ipv6, add the quic ipv6 port.
-            if let Some(quic6_port) = config.enr_quic6_port.or_else(|| {
-                config
-                    .listen_addrs()
-                    .v6()
-                    .and_then(|v6_addr| v6_addr.quic_port.try_into().ok())
-            }) {
-                builder.add_value(QUIC6_ENR_KEY, &quic6_port.get());
-            }
-        }
-
-        // If the ENR port is not set, and we are listening over that ip version, use the listening port instead.
-        let tcp4_port = config.enr_tcp4_port.or_else(|| {
+    // Add QUIC fields to the ENR.
+    // Since QUIC is used as an alternative transport for the libp2p protocols,
+    // the related fields should only be added when both QUIC and libp2p are enabled
+    if !config.disable_quic_support {
+        // If we are listening on ipv4, add the quic ipv4 port.
+        if let Some(quic4_port) = config.enr_quic4_port.or_else(|| {
             config
                 .listen_addrs()
                 .v4()
-                .and_then(|v4_addr| v4_addr.tcp_port.try_into().ok())
-        });
-        if let Some(tcp4_port) = tcp4_port {
-            builder.tcp4(tcp4_port.get());
+                .and_then(|v4_addr| v4_addr.quic_port.try_into().ok())
+        }) {
+            builder.add_value(QUIC_ENR_KEY, &quic4_port.get());
         }
 
-        let tcp6_port = config.enr_tcp6_port.or_else(|| {
+        // If we are listening on ipv6, add the quic ipv6 port.
+        if let Some(quic6_port) = config.enr_quic6_port.or_else(|| {
             config
                 .listen_addrs()
                 .v6()
-                .and_then(|v6_addr| v6_addr.tcp_port.try_into().ok())
-        });
-        if let Some(tcp6_port) = tcp6_port {
-            builder.tcp6(tcp6_port.get());
+                .and_then(|v6_addr| v6_addr.quic_port.try_into().ok())
+        }) {
+            builder.add_value(QUIC6_ENR_KEY, &quic6_port.get());
         }
     }
-    builder
-}
 
-/// Builds a lighthouse ENR given a `NetworkConfig`.
-pub fn build_enr<T: EthSpec>(
-    enr_key: &CombinedKey,
-    config: &NetworkConfig,
-    enr_fork_id: &EnrForkId,
-) -> Result<Enr, String> {
-    let mut builder = create_enr_builder_from_config(config, true);
+    // If the ENR port is not set, and we are listening over that ip version, use the listening port instead.
+    let tcp4_port = config.enr_tcp4_port.or_else(|| {
+        config
+            .listen_addrs()
+            .v4()
+            .and_then(|v4_addr| v4_addr.tcp_port.try_into().ok())
+    });
+    if let Some(tcp4_port) = tcp4_port {
+        builder.tcp4(tcp4_port.get());
+    }
+
+    let tcp6_port = config.enr_tcp6_port.or_else(|| {
+        config
+            .listen_addrs()
+            .v6()
+            .and_then(|v6_addr| v6_addr.tcp_port.try_into().ok())
+    });
+    if let Some(tcp6_port) = tcp6_port {
+        builder.tcp6(tcp6_port.get());
+    }
 
     // set the `eth2` field on our ENR
     builder.add_value(ETH2_ENR_KEY, &enr_fork_id.as_ssz_bytes());

diff --git a/beacon_node/lighthouse_network/src/discovery/enr_ext.rs b/beacon_node/lighthouse_network/src/discovery/enr_ext.rs
@@ -366,9 +366,7 @@ mod tests {
         let libp2p_kp: Keypair = secp256k1_kp.into();
         let peer_id = libp2p_kp.public().to_peer_id();
 
-        let enr = discv5::enr::EnrBuilder::new("v4")
-            .build(&secret_key)
-            .unwrap();
+        let enr = discv5::enr::Enr::builder().build(&secret_key).unwrap();
         let node_id = peer_id_to_node_id(&peer_id).unwrap();
 
         assert_eq!(enr.node_id(), node_id);
@@ -387,9 +385,7 @@ mod tests {
         let libp2p_kp: Keypair = secp256k1_kp.into();
         let peer_id = libp2p_kp.public().to_peer_id();
 
-        let enr = discv5::enr::EnrBuilder::new("v4")
-            .build(&secret_key)
-            .unwrap();
+        let enr = discv5::enr::Enr::builder().build(&secret_key).unwrap();
         let node_id = peer_id_to_node_id(&peer_id).unwrap();
 
         assert_eq!(enr.node_id(), node_id);

diff --git a/beacon_node/lighthouse_network/src/discovery/mod.rs b/beacon_node/lighthouse_network/src/discovery/mod.rs
@@ -10,11 +10,8 @@ pub mod enr_ext;
 use crate::service::TARGET_SUBNET_PEERS;
 use crate::{error, Enr, NetworkConfig, NetworkGlobals, Subnet, SubnetDiscovery};
 use crate::{metrics, ClearDialError};
-use discv5::{enr::NodeId, Discv5, Discv5Event};
-pub use enr::{
-    build_enr, create_enr_builder_from_config, load_enr_from_disk, use_or_load_enr, CombinedKey,
-    Eth2Enr,
-};
+use discv5::{enr::NodeId, Discv5};
+pub use enr::{build_enr, load_enr_from_disk, use_or_load_enr, CombinedKey, Eth2Enr};
 pub use enr_ext::{peer_id_to_node_id, CombinedKeyExt, EnrExt};
 pub use libp2p::identity::{Keypair, PublicKey};
 
@@ -147,15 +144,10 @@ enum EventStream {
     /// Awaiting an event stream to be generated. This is required due to the poll nature of
     /// `Discovery`
     Awaiting(
-        Pin<
-            Box<
-                dyn Future<Output = Result<mpsc::Receiver<Discv5Event>, discv5::Discv5Error>>
-                    + Send,
-            >,
-        >,
+        Pin<Box<dyn Future<Output = Result<mpsc::Receiver<discv5::Event>, discv5::Error>> + Send>>,
     ),
     /// The future has completed.
-    Present(mpsc::Receiver<Discv5Event>),
+    Present(mpsc::Receiver<discv5::Event>),
     // The future has failed or discv5 has been disabled. There are no events from discv5.
     InActive,
 }
@@ -996,7 +988,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
                     match event {
                         // We filter out unwanted discv5 events here and only propagate useful results to
                         // the peer manager.
-                        Discv5Event::Discovered(_enr) => {
+                        discv5::Event::Discovered(_enr) => {
                             // Peers that get discovered during a query but are not contactable or
                             // don't match a predicate can end up here. For debugging purposes we
                             // log these to see if we are unnecessarily dropping discovered peers
@@ -1009,7 +1001,7 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
                             }
                             */
                         }
-                        Discv5Event::SocketUpdated(socket_addr) => {
+                        discv5::Event::SocketUpdated(socket_addr) => {
                             info!(self.log, "Address updated"; "ip" => %socket_addr.ip(), "udp_port" => %socket_addr.port());
                             metrics::inc_counter(&metrics::ADDRESS_UPDATE_COUNT);
                             metrics::check_nat();
@@ -1030,10 +1022,10 @@ impl<TSpec: EthSpec> NetworkBehaviour for Discovery<TSpec> {
                             // NOTE: We assume libp2p itself can keep track of IP changes and we do
                             // not inform it about IP changes found via discovery.
                         }
-                        Discv5Event::EnrAdded { .. }
-                        | Discv5Event::TalkRequest(_)
-                        | Discv5Event::NodeInserted { .. }
-                        | Discv5Event::SessionEstablished { .. } => {} // Ignore all other discv5 server events
+                        discv5::Event::EnrAdded { .. }
+                        | discv5::Event::TalkRequest(_)
+                        | discv5::Event::NodeInserted { .. }
+                        | discv5::Event::SessionEstablished { .. } => {} // Ignore all other discv5 server events
                     }
                 }
             }
@@ -1144,7 +1136,6 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
 mod tests {
     use super::*;
     use crate::rpc::methods::{MetaData, MetaDataV2};
-    use enr::EnrBuilder;
     use libp2p::identity::secp256k1;
     use slog::{o, Drain};
     use types::{BitVector, MinimalEthSpec, SubnetId};
@@ -1227,7 +1218,7 @@ mod tests {
     }
 
     fn make_enr(subnet_ids: Vec<usize>) -> Enr {
-        let mut builder = EnrBuilder::new("v4");
+        let mut builder = Enr::builder();
         let keypair = secp256k1::Keypair::generate();
         let enr_key: CombinedKey = CombinedKey::from_secp256k1(&keypair);