Reduce eth2 dependency space (#8524)

Remove certain dependencies from `eth2`, and feature-gate others which are only used by certain endpoints.

| Removed | Optional | Dev only |
| -------- | -------- | -------- |
| `either` `enr` `libp2p-identity` `multiaddr` | `protoarray` `eth2_keystore` `eip_3076` `zeroize` `reqwest-eventsource` `futures` `futures-util` | `rand` `test_random_derive` |

This is done by adding an `events` feature which enables the events endpoint and its associated dependencies.
The `lighthouse` feature also enables its associated dependencies making them optional.

The networking-adjacent dependencies were removed by just having certain fields use a `String` instead of an explicit network type. This means the user should handle conversion at the call site instead. This is a bit spicy, but I believe `PeerId`, `Enr` and `Multiaddr` are easily converted to and from `String`s so I think it's fine and reduces our dependency space by a lot. The alternative is to feature gate these types behind a `network` feature instead.


Co-Authored-By: Mac L <[email protected]>

Author: macladson

Cargo.lock

@@ -19,7 +19,7 @@ alloy-primitives = { workspace = true }
 bitvec = { workspace = true }
 bls = { workspace = true }
 educe = { workspace = true }
-eth2 = { workspace = true }
+eth2 = { workspace = true, features = ["lighthouse"] }
 eth2_network_config = { workspace = true }
 ethereum_hashing = { workspace = true }
 ethereum_serde_utils = { workspace = true }

beacon_node/beacon_chain/Cargo.toml

@@ -12,7 +12,7 @@ alloy-rpc-types-eth = { workspace = true }
 arc-swap = "1.6.0"
 builder_client = { path = "../builder_client" }
 bytes = { workspace = true }
-eth2 = { workspace = true }
+eth2 = { workspace = true, features = ["events", "lighthouse"] }
 ethereum_serde_utils = { workspace = true }
 ethereum_ssz = { workspace = true }
 fixed_bytes = { workspace = true }

beacon_node/execution_layer/Cargo.toml

@@ -12,7 +12,7 @@ bs58 = "0.4.0"
 bytes = { workspace = true }
 directory = { workspace = true }
 either = { workspace = true }
-eth2 = { workspace = true }
+eth2 = { workspace = true, features = ["lighthouse"] }
 ethereum_serde_utils = { workspace = true }
 ethereum_ssz = { workspace = true }
 execution_layer = { workspace = true }

beacon_node/http_api/Cargo.toml

@@ -2118,9 +2118,12 @@ pub fn serve<T: BeaconChainTypes>(
                     let discovery_addresses = enr.multiaddr_p2p_udp();
                     Ok(api_types::GenericResponse::from(api_types::IdentityData {
                         peer_id: network_globals.local_peer_id().to_base58(),
-                        enr,
-                        p2p_addresses,
-                        discovery_addresses,
+                        enr: enr.to_base64(),
+                        p2p_addresses: p2p_addresses.iter().map(|a| a.to_string()).collect(),
+                        discovery_addresses: discovery_addresses
+                            .iter()
+                            .map(|a| a.to_string())
+                            .collect(),
                         metadata: utils::from_meta_data::<T::EthSpec>(
                             &network_globals.local_metadata,
                             &chain.spec,

beacon_node/http_api/src/lib.rs

@@ -2853,9 +2853,19 @@ impl ApiTester {
 
         let expected = IdentityData {
             peer_id: self.local_enr.peer_id().to_string(),
-            enr: self.local_enr.clone(),
-            p2p_addresses: self.local_enr.multiaddr_p2p_tcp(),
-            discovery_addresses: self.local_enr.multiaddr_p2p_udp(),
+            enr: self.local_enr.to_base64(),
+            p2p_addresses: self
+                .local_enr
+                .multiaddr_p2p_tcp()
+                .iter()
+                .map(|a| a.to_string())
+                .collect(),
+            discovery_addresses: self
+                .local_enr
+                .multiaddr_p2p_udp()
+                .iter()
+                .map(|a| a.to_string())
+                .collect(),
             metadata: MetaData::V2(MetaDataV2 {
                 seq_number: 0,
                 attnets: "0x0000000000000000".to_string(),
@@ -2884,7 +2894,7 @@ impl ApiTester {
     pub async fn test_get_node_peers_by_id(self) -> Self {
         let result = self
             .client
-            .get_node_peers_by_id(self.external_peer_id)
+            .get_node_peers_by_id(&self.external_peer_id.to_string())
             .await
             .unwrap()
             .data;

beacon_node/http_api/tests/tests.rs

@@ -17,7 +17,7 @@ directory = { workspace = true }
 dirs = { workspace = true }
 discv5 = { workspace = true }
 either = { workspace = true }
-eth2 = { workspace = true }
+eth2 = { workspace = true, features = ["lighthouse"] }
 ethereum_ssz = { workspace = true }
 ethereum_ssz_derive = { workspace = true }
 fnv = { workspace = true }

beacon_node/lighthouse_network/Cargo.toml

@@ -5,36 +5,33 @@ authors = ["Paul Hauner <[email protected]>"]
 edition = { workspace = true }
 
 [features]
-default = ["lighthouse"]
-lighthouse = []
+default = []
+lighthouse = ["proto_array", "eth2_keystore", "eip_3076", "zeroize"]
+events = ["reqwest-eventsource", "futures", "futures-util"]
 
 [dependencies]
 context_deserialize = { workspace = true }
 educe = { workspace = true }
-eip_3076 = { workspace = true }
-either = { workspace = true }
-enr = { version = "0.13.0", features = ["ed25519"] }
-eth2_keystore = { workspace = true }
+eip_3076 = { workspace = true, optional = true }
+eth2_keystore = { workspace = true, optional = true }
 ethereum_serde_utils = { workspace = true }
 ethereum_ssz = { workspace = true }
 ethereum_ssz_derive = { workspace = true }
-futures = { workspace = true }
-futures-util = "0.3.8"
-libp2p-identity = { version = "0.2", features = ["peerid"] }
+futures = { workspace = true, optional = true }
+futures-util = { version = "0.3.8", optional = true }
 mediatype = "0.19.13"
-multiaddr = "0.18.2"
 pretty_reqwest_error = { workspace = true }
-proto_array = { workspace = true }
-rand = { workspace = true }
+proto_array = { workspace = true, optional = true }
 reqwest = { workspace = true }
-reqwest-eventsource = "0.6.0"
+reqwest-eventsource = { version = "0.6.0", optional = true }
 sensitive_url = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 ssz_types = { workspace = true }
-test_random_derive = { path = "../../common/test_random_derive" }
 types = { workspace = true }
-zeroize = { workspace = true }
+zeroize = { workspace = true, optional = true }
 
 [dev-dependencies]
+rand = { workspace = true }
+test_random_derive = { path = "../../common/test_random_derive" }
 tokio = { workspace = true }

common/eth2/Cargo.toml

@@ -14,6 +14,7 @@ use std::{fmt, path::PathBuf};
 pub enum Error {
     /// The `reqwest` client raised an error.
     HttpClient(PrettyReqwestError),
+    #[cfg(feature = "events")]
     /// The `reqwest_eventsource` client raised an error.
     SseClient(Box<reqwest_eventsource::Error>),
     /// The server returned an error message where the body was able to be parsed.
@@ -91,6 +92,7 @@ impl Error {
     pub fn status(&self) -> Option<StatusCode> {
         match self {
             Error::HttpClient(error) => error.inner().status(),
+            #[cfg(feature = "events")]
             Error::SseClient(error) => {
                 if let reqwest_eventsource::Error::InvalidStatusCode(status, _) = error.as_ref() {
                     Some(*status)

common/eth2/src/error.rs

@@ -22,20 +22,23 @@ pub use beacon_response::{
 };
 
 pub use self::error::{Error, ok_or_error, success_or_error};
+pub use reqwest;
+pub use reqwest::{StatusCode, Url};
+pub use sensitive_url::SensitiveUrl;
+
 use self::mixin::{RequestAccept, ResponseOptional};
 use self::types::*;
 use educe::Educe;
+#[cfg(feature = "events")]
 use futures::Stream;
+#[cfg(feature = "events")]
 use futures_util::StreamExt;
-use libp2p_identity::PeerId;
-pub use reqwest;
 use reqwest::{
     Body, IntoUrl, RequestBuilder, Response,
     header::{HeaderMap, HeaderValue},
 };
-pub use reqwest::{StatusCode, Url};
+#[cfg(feature = "events")]
 use reqwest_eventsource::{Event, EventSource};
-pub use sensitive_url::SensitiveUrl;
 use serde::{Serialize, de::DeserializeOwned};
 use ssz::Encode;
 use std::fmt;
@@ -1978,15 +1981,15 @@ impl BeaconNodeHttpClient {
     /// `GET node/peers/{peer_id}`
     pub async fn get_node_peers_by_id(
         &self,
-        peer_id: PeerId,
+        peer_id: &str,
     ) -> Result<GenericResponse<PeerData>, Error> {
         let mut path = self.eth_path(V1)?;
 
         path.path_segments_mut()
             .map_err(|()| Error::InvalidUrl(self.server.clone()))?
             .push("node")
             .push("peers")
-            .push(&peer_id.to_string());
+            .push(peer_id);
 
         self.get(path).await
     }
@@ -2761,6 +2764,7 @@ impl BeaconNodeHttpClient {
     }
 
     /// `GET events?topics`
+    #[cfg(feature = "events")]
     pub async fn get_events<E: EthSpec>(
         &self,
         topic: &[EventTopic],