decouple eth2 from store and lighthouse_network (#6680)

- #6452 (partially)


  Remove dependencies on `store` and `lighthouse_network`  from `eth2`. This was achieved as follows:

- depend on `enr` and `multiaddr` directly instead of using `lighthouse_network`'s reexports.
- make `lighthouse_network` responsible for converting between API and internal types.
- in two cases, remove complex internal types and use the generic `serde_json::Value` instead - this is not ideal, but should be fine for now, as this affects two internal non-spec endpoints which are meant for debugging, unstable, and subject to change without notice anyway. Inspired by #6679. The alternative is to move all relevant types to `eth2` or `types` instead - what do you think?

Author: dknopik

Cargo.lock

@@ -1,7 +1,7 @@
 use crate::{BeaconChain, BeaconChainError, BeaconChainTypes};
-use eth2::lighthouse::attestation_rewards::{IdealAttestationRewards, TotalAttestationRewards};
-use eth2::lighthouse::StandardAttestationRewards;
-use eth2::types::ValidatorId;
+use eth2::types::{
+    IdealAttestationRewards, StandardAttestationRewards, TotalAttestationRewards, ValidatorId,
+};
 use safe_arith::SafeArith;
 use serde_utils::quoted_u64::Quoted;
 use state_processing::common::base::{self, SqrtTotalActiveBalance};

beacon_node/beacon_chain/src/attestation_rewards.rs

@@ -1,6 +1,6 @@
 use crate::{BeaconChain, BeaconChainError, BeaconChainTypes, StateSkipConfig};
 use attesting_indices_base::get_attesting_indices;
-use eth2::lighthouse::StandardBlockReward;
+use eth2::types::StandardBlockReward;
 use safe_arith::SafeArith;
 use state_processing::common::attesting_indices_base;
 use state_processing::{

beacon_node/beacon_chain/src/beacon_block_reward.rs

@@ -1,6 +1,6 @@
 use crate::{BeaconChain, BeaconChainError, BeaconChainTypes};
 
-use eth2::lighthouse::SyncCommitteeReward;
+use eth2::types::SyncCommitteeReward;
 use safe_arith::SafeArith;
 use state_processing::per_block_processing::altair::sync_committee::compute_sync_aggregate_rewards;
 use std::collections::HashMap;

beacon_node/beacon_chain/src/sync_committee_rewards.rs

@@ -9,9 +9,7 @@ use beacon_chain::{
     types::{Epoch, EthSpec, Keypair, MinimalEthSpec},
     BlockError, ChainConfig, StateSkipConfig, WhenSlotSkipped,
 };
-use eth2::lighthouse::attestation_rewards::TotalAttestationRewards;
-use eth2::lighthouse::StandardAttestationRewards;
-use eth2::types::ValidatorId;
+use eth2::types::{StandardAttestationRewards, TotalAttestationRewards, ValidatorId};
 use state_processing::{BlockReplayError, BlockReplayer};
 use std::array::IntoIter;
 use std::collections::HashMap;

beacon_node/beacon_chain/tests/rewards.rs

@@ -12,7 +12,6 @@ arc-swap = "1.6.0"
 builder_client = { path = "../builder_client" }
 bytes = { workspace = true }
 eth2 = { workspace = true }
-eth2_network_config = { workspace = true }
 ethereum_serde_utils = { workspace = true }
 ethereum_ssz = { workspace = true }
 ethers-core = { workspace = true }

beacon_node/execution_layer/Cargo.toml

@@ -50,7 +50,6 @@ warp_utils = { workspace = true }
 [dev-dependencies]
 genesis = { workspace = true }
 proto_array = { workspace = true }
-serde_json = { workspace = true }
 
 [[test]]
 name = "bn_http_api_tests"

beacon_node/http_api/Cargo.toml

@@ -1,7 +1,17 @@
 use beacon_chain::store::metadata::CURRENT_SCHEMA_VERSION;
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2::lighthouse::DatabaseInfo;
+use serde::Serialize;
 use std::sync::Arc;
+use store::{AnchorInfo, BlobInfo, Split, StoreConfig};
+
+#[derive(Debug, Serialize)]
+pub struct DatabaseInfo {
+    pub schema_version: u64,
+    pub config: StoreConfig,
+    pub split: Split,
+    pub anchor: AnchorInfo,
+    pub blob_info: BlobInfo,
+}
 
 pub fn info<T: BeaconChainTypes>(
     chain: Arc<BeaconChain<T>>,

beacon_node/http_api/src/database.rs

@@ -16,6 +16,7 @@ mod builder_states;
 mod database;
 mod light_client;
 mod metrics;
+mod peer;
 mod produce_block;
 mod proposer_duties;
 mod publish_attestations;
@@ -3022,15 +3023,13 @@ pub fn serve<T: BeaconChainTypes>(
                         };
 
                         // the eth2 API spec implies only peers we have been connected to at some point should be included.
-                        if let Some(dir) = peer_info.connection_direction().as_ref() {
+                        if let Some(&dir) = peer_info.connection_direction() {
                             return Ok(api_types::GenericResponse::from(api_types::PeerData {
                                 peer_id: peer_id.to_string(),
                                 enr: peer_info.enr().map(|enr| enr.to_base64()),
                                 last_seen_p2p_address: address,
-                                direction: api_types::PeerDirection::from_connection_direction(dir),
-                                state: api_types::PeerState::from_peer_connection_status(
-                                    peer_info.connection_status(),
-                                ),
+                                direction: dir.into(),
+                                state: peer_info.connection_status().clone().into(),
                             }));
                         }
                     }
@@ -3071,12 +3070,9 @@ pub fn serve<T: BeaconChainTypes>(
                                 };
 
                             // the eth2 API spec implies only peers we have been connected to at some point should be included.
-                            if let Some(dir) = peer_info.connection_direction() {
-                                let direction =
-                                    api_types::PeerDirection::from_connection_direction(dir);
-                                let state = api_types::PeerState::from_peer_connection_status(
-                                    peer_info.connection_status(),
-                                );
+                            if let Some(&dir) = peer_info.connection_direction() {
+                                let direction = dir.into();
+                                let state = peer_info.connection_status().clone().into();
 
                                 let state_matches = query.state.as_ref().is_none_or(|states| {
                                     states.iter().any(|state_param| *state_param == state)
@@ -3128,9 +3124,8 @@ pub fn serve<T: BeaconChainTypes>(
                         .read()
                         .peers()
                         .for_each(|(_, peer_info)| {
-                            let state = api_types::PeerState::from_peer_connection_status(
-                                peer_info.connection_status(),
-                            );
+                            let state =
+                                api_types::PeerState::from(peer_info.connection_status().clone());
                             match state {
                                 api_types::PeerState::Connected => connected += 1,
                                 api_types::PeerState::Connecting => connecting += 1,
@@ -4089,7 +4084,7 @@ pub fn serve<T: BeaconChainTypes>(
                         .peers
                         .read()
                         .peers()
-                        .map(|(peer_id, peer_info)| eth2::lighthouse::Peer {
+                        .map(|(peer_id, peer_info)| peer::Peer {
                             peer_id: peer_id.to_string(),
                             peer_info: peer_info.clone(),
                         })
@@ -4109,15 +4104,14 @@ pub fn serve<T: BeaconChainTypes>(
             |task_spawner: TaskSpawner<T::EthSpec>,
              network_globals: Arc<NetworkGlobals<T::EthSpec>>| {
                 task_spawner.blocking_json_task(Priority::P1, move || {
-                    Ok(network_globals
-                        .peers
-                        .read()
-                        .connected_peers()
-                        .map(|(peer_id, peer_info)| eth2::lighthouse::Peer {
+                    let mut peers = vec![];
+                    for (peer_id, peer_info) in network_globals.peers.read().connected_peers() {
+                        peers.push(peer::Peer {
                             peer_id: peer_id.to_string(),
                             peer_info: peer_info.clone(),
-                        })
-                        .collect::<Vec<_>>())
+                        });
+                    }
+                    Ok(peers)
                 })
             },
         );

beacon_node/http_api/src/lib.rs

@@ -0,0 +1,13 @@
+use lighthouse_network::PeerInfo;
+use serde::Serialize;
+use types::EthSpec;
+
+/// Information returned by `peers` and `connected_peers`.
+#[derive(Debug, Clone, Serialize)]
+#[serde(bound = "E: EthSpec")]
+pub(crate) struct Peer<E: EthSpec> {
+    /// The Peer's ID
+    pub peer_id: String,
+    /// The PeerInfo associated with the peer.
+    pub peer_info: PeerInfo<E>,
+}