Merge branch 'unstable' into merge-unstable-to-deneb-20230808

# Conflicts:
#	Cargo.lock
#	beacon_node/beacon_chain/src/lib.rs
#	beacon_node/execution_layer/src/engine_api.rs
#	beacon_node/execution_layer/src/engine_api/http.rs
#	beacon_node/execution_layer/src/test_utils/mod.rs
#	beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs
#	beacon_node/lighthouse_network/src/rpc/handler.rs
#	beacon_node/lighthouse_network/src/rpc/protocol.rs
#	beacon_node/lighthouse_network/src/service/utils.rs
#	beacon_node/lighthouse_network/tests/rpc_tests.rs
#	beacon_node/network/Cargo.toml
#	beacon_node/network/src/network_beacon_processor/tests.rs
#	lcli/src/parse_ssz.rs
#	scripts/cross/Dockerfile
#	validator_client/src/block_service.rs
#	validator_client/src/validator_store.rs

beacon_node/lighthouse_network/src/service/utils.rs

@@ -4,13 +4,11 @@ use crate::types::{
     error, EnrAttestationBitfield, EnrSyncCommitteeBitfield, GossipEncoding, GossipKind,
 };
 use crate::{GossipTopic, NetworkConfig};
-use libp2p::bandwidth::{BandwidthLogging, BandwidthSinks};
-use libp2p::core::{
-    identity::Keypair, multiaddr::Multiaddr, muxing::StreamMuxerBox, transport::Boxed,
-};
-use libp2p::gossipsub::subscription_filter::WhitelistSubscriptionFilter;
-use libp2p::gossipsub::IdentTopic as Topic;
-use libp2p::{core, noise, PeerId, Transport};
+use libp2p::bandwidth::BandwidthSinks;
+use libp2p::core::{multiaddr::Multiaddr, muxing::StreamMuxerBox, transport::Boxed};
+use libp2p::gossipsub;
+use libp2p::identity::{secp256k1, Keypair};
+use libp2p::{core, noise, yamux, PeerId, Transport, TransportExt};
 use prometheus_client::registry::Registry;
 use slog::{debug, warn};
 use ssz::Decode;
@@ -52,30 +50,19 @@ pub fn build_transport(
         transport.or_transport(libp2p::websocket::WsConfig::new(trans_clone))
     };
 
-    let (transport, bandwidth) = BandwidthLogging::new(transport);
-
-    // mplex config
-    let mut mplex_config = libp2p::mplex::MplexConfig::new();
-    mplex_config.set_max_buffer_size(256);
-    mplex_config.set_max_buffer_behaviour(libp2p::mplex::MaxBufferBehaviour::Block);
-
     // yamux config
-    let mut yamux_config = libp2p::yamux::YamuxConfig::default();
-    yamux_config.set_window_update_mode(libp2p::yamux::WindowUpdateMode::on_read());
+    let mut yamux_config = yamux::Config::default();
+    yamux_config.set_window_update_mode(yamux::WindowUpdateMode::on_read());
+    let (transport, bandwidth) = transport
+        .upgrade(core::upgrade::Version::V1)
+        .authenticate(generate_noise_config(&local_private_key))
+        .multiplex(yamux_config)
+        .timeout(Duration::from_secs(10))
+        .boxed()
+        .with_bandwidth_logging();
 
     // Authentication
-    Ok((
-        transport
-            .upgrade(core::upgrade::Version::V1)
-            .authenticate(generate_noise_config(&local_private_key))
-            .multiplex(core::upgrade::SelectUpgrade::new(
-                yamux_config,
-                mplex_config,
-            ))
-            .timeout(Duration::from_secs(10))
-            .boxed(),
-        bandwidth,
-    ))
+    Ok((transport, bandwidth))
 }
 
 // Useful helper functions for debugging. Currently not used in the client.
@@ -94,10 +81,10 @@ fn keypair_from_hex(hex_bytes: &str) -> error::Result<Keypair> {
 
 #[allow(dead_code)]
 fn keypair_from_bytes(mut bytes: Vec<u8>) -> error::Result<Keypair> {
-    libp2p::core::identity::secp256k1::SecretKey::from_bytes(&mut bytes)
+    secp256k1::SecretKey::try_from_bytes(&mut bytes)
         .map(|secret| {
-            let keypair: libp2p::core::identity::secp256k1::Keypair = secret.into();
-            Keypair::Secp256k1(keypair)
+            let keypair: secp256k1::Keypair = secret.into();
+            keypair.into()
         })
         .map_err(|e| format!("Unable to parse p2p secret key: {:?}", e).into())
 }
@@ -115,12 +102,10 @@ pub fn load_private_key(config: &NetworkConfig, log: &slog::Logger) -> Keypair {
             Err(_) => debug!(log, "Could not read network key file"),
             Ok(_) => {
                 // only accept secp256k1 keys for now
-                if let Ok(secret_key) =
-                    libp2p::core::identity::secp256k1::SecretKey::from_bytes(&mut key_bytes)
-                {
-                    let kp: libp2p::core::identity::secp256k1::Keypair = secret_key.into();
+                if let Ok(secret_key) = secp256k1::SecretKey::try_from_bytes(&mut key_bytes) {
+                    let kp: secp256k1::Keypair = secret_key.into();
                     debug!(log, "Loaded network key from disk.");
-                    return Keypair::Secp256k1(kp);
+                    return kp.into();
                 } else {
                     debug!(log, "Network key file is not a valid secp256k1 key");
                 }
@@ -129,34 +114,27 @@ pub fn load_private_key(config: &NetworkConfig, log: &slog::Logger) -> Keypair {
     }
 
     // if a key could not be loaded from disk, generate a new one and save it
-    let local_private_key = Keypair::generate_secp256k1();
-    if let Keypair::Secp256k1(key) = local_private_key.clone() {
-        let _ = std::fs::create_dir_all(&config.network_dir);
-        match File::create(network_key_f.clone())
-            .and_then(|mut f| f.write_all(&key.secret().to_bytes()))
-        {
-            Ok(_) => {
-                debug!(log, "New network key generated and written to disk");
-            }
-            Err(e) => {
-                warn!(
-                    log,
-                    "Could not write node key to file: {:?}. error: {}", network_key_f, e
-                );
-            }
+    let local_private_key = secp256k1::Keypair::generate();
+    let _ = std::fs::create_dir_all(&config.network_dir);
+    match File::create(network_key_f.clone())
+        .and_then(|mut f| f.write_all(&local_private_key.secret().to_bytes()))
+    {
+        Ok(_) => {
+            debug!(log, "New network key generated and written to disk");
+        }
+        Err(e) => {
+            warn!(
+                log,
+                "Could not write node key to file: {:?}. error: {}", network_key_f, e
+            );
         }
     }
-    local_private_key
+    local_private_key.into()
 }
 
 /// Generate authenticated XX Noise config from identity keys
-fn generate_noise_config(
-    identity_keypair: &Keypair,
-) -> noise::NoiseAuthenticated<noise::XX, noise::X25519Spec, ()> {
-    let static_dh_keys = noise::Keypair::<noise::X25519Spec>::new()
-        .into_authentic(identity_keypair)
-        .expect("signing can fail only once during starting a node");
-    noise::NoiseConfig::xx(static_dh_keys).into_authenticated()
+fn generate_noise_config(identity_keypair: &Keypair) -> noise::Config {
+    noise::Config::new(identity_keypair).expect("signing can fail only once during starting a node")
 }
 
 /// For a multiaddr that ends with a peer id, this strips this suffix. Rust-libp2p
@@ -237,11 +215,11 @@ pub(crate) fn create_whitelist_filter(
     attestation_subnet_count: u64,
     sync_committee_subnet_count: u64,
     blob_sidecar_subnet_count: u64,
-) -> WhitelistSubscriptionFilter {
+) -> gossipsub::WhitelistSubscriptionFilter {
     let mut possible_hashes = HashSet::new();
     for fork_digest in possible_fork_digests {
         let mut add = |kind| {
-            let topic: Topic =
+            let topic: gossipsub::IdentTopic =
                 GossipTopic::new(kind, GossipEncoding::SSZSnappy, fork_digest).into();
             possible_hashes.insert(topic.hash());
         };
@@ -266,7 +244,7 @@ pub(crate) fn create_whitelist_filter(
             add(BlobSidecar(id));
         }
     }
-    WhitelistSubscriptionFilter(possible_hashes)
+    gossipsub::WhitelistSubscriptionFilter(possible_hashes)
 }
 
 /// Persist metadata to disk