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?

beacon_node/lighthouse_network/Cargo.toml

@@ -13,6 +13,7 @@ directory = { workspace = true }
 dirs = { workspace = true }
 discv5 = { workspace = true }
 either = { workspace = true }
+eth2 = { workspace = true }
 ethereum_ssz = { workspace = true }
 ethereum_ssz_derive = { workspace = true }
 fnv = { workspace = true }

beacon_node/lighthouse_network/src/peer_manager/peerdb/peer_info.rs

@@ -4,6 +4,7 @@ use super::sync_status::SyncStatus;
 use crate::discovery::Eth2Enr;
 use crate::{rpc::MetaData, types::Subnet};
 use discv5::Enr;
+use eth2::types::{PeerDirection, PeerState};
 use libp2p::core::multiaddr::{Multiaddr, Protocol};
 use serde::{
     ser::{SerializeStruct, Serializer},
@@ -522,7 +523,7 @@ impl<E: EthSpec> PeerInfo<E> {
 }
 
 /// Connection Direction of connection.
-#[derive(Debug, Clone, Serialize, AsRefStr)]
+#[derive(Debug, Clone, Copy, Serialize, AsRefStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum ConnectionDirection {
     /// The connection was established by a peer dialing us.
@@ -531,6 +532,15 @@ pub enum ConnectionDirection {
     Outgoing,
 }
 
+impl From<ConnectionDirection> for PeerDirection {
+    fn from(direction: ConnectionDirection) -> Self {
+        match direction {
+            ConnectionDirection::Incoming => PeerDirection::Inbound,
+            ConnectionDirection::Outgoing => PeerDirection::Outbound,
+        }
+    }
+}
+
 /// Connection Status of the peer.
 #[derive(Debug, Clone, Default)]
 pub enum PeerConnectionStatus {
@@ -624,3 +634,14 @@ impl Serialize for PeerConnectionStatus {
         }
     }
 }
+
+impl From<PeerConnectionStatus> for PeerState {
+    fn from(status: PeerConnectionStatus) -> Self {
+        match status {
+            Connected { .. } => PeerState::Connected,
+            Dialing { .. } => PeerState::Connecting,
+            Disconnecting { .. } => PeerState::Disconnecting,
+            Disconnected { .. } | Banned { .. } | Unknown => PeerState::Disconnected,
+        }
+    }
+}

beacon_node/lighthouse_network/src/types/mod.rs

@@ -1,7 +1,6 @@
 mod globals;
 mod pubsub;
 mod subnet;
-mod sync_state;
 mod topics;
 
 use types::{BitVector, EthSpec};
@@ -11,10 +10,10 @@ pub type EnrSyncCommitteeBitfield<E> = BitVector<<E as EthSpec>::SyncCommitteeSu
 
 pub type Enr = discv5::enr::Enr<discv5::enr::CombinedKey>;
 
+pub use eth2::lighthouse::sync_state::{BackFillState, SyncState};
 pub use globals::NetworkGlobals;
 pub use pubsub::{PubsubMessage, SnappyTransform};
 pub use subnet::{Subnet, SubnetDiscovery};
-pub use sync_state::{BackFillState, SyncState};
 pub use topics::{
     all_topics_at_fork, core_topics_to_subscribe, is_fork_non_core_topic, subnet_from_topic_hash,
     GossipEncoding, GossipKind, GossipTopic, TopicConfig,

beacon_node/lighthouse_network/src/types/sync_state.rs

@@ -1,113 +0,0 @@
-use serde::{Deserialize, Serialize};
-use types::Slot;
-
-/// The current state of the node.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum SyncState {
-    /// The node is performing a long-range (batch) sync over a finalized chain.
-    /// In this state, parent lookups are disabled.
-    SyncingFinalized { start_slot: Slot, target_slot: Slot },
-    /// The node is performing a long-range (batch) sync over one or many head chains.
-    /// In this state parent lookups are disabled.
-    SyncingHead { start_slot: Slot, target_slot: Slot },
-    /// The node is undertaking a backfill sync. This occurs when a user has specified a trusted
-    /// state. The node first syncs "forward" by downloading blocks up to the current head as
-    /// specified by its peers. Once completed, the node enters this sync state and attempts to
-    /// download all required historical blocks.
-    BackFillSyncing { completed: usize, remaining: usize },
-    /// The node has completed syncing a finalized chain and is in the process of re-evaluating
-    /// which sync state to progress to.
-    SyncTransition,
-    /// The node is up to date with all known peers and is connected to at least one
-    /// fully synced peer. In this state, parent lookups are enabled.
-    Synced,
-    /// No useful peers are connected. Long-range sync's cannot proceed and we have no useful
-    /// peers to download parents for. More peers need to be connected before we can proceed.
-    Stalled,
-}
-
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
-/// The state of the backfill sync.
-pub enum BackFillState {
-    /// The sync is partially completed and currently paused.
-    Paused,
-    /// We are currently backfilling.
-    Syncing,
-    /// A backfill sync has completed.
-    Completed,
-    /// Too many failed attempts at backfilling. Consider it failed.
-    Failed,
-}
-
-impl PartialEq for SyncState {
-    fn eq(&self, other: &Self) -> bool {
-        matches!(
-            (self, other),
-            (
-                SyncState::SyncingFinalized { .. },
-                SyncState::SyncingFinalized { .. }
-            ) | (SyncState::SyncingHead { .. }, SyncState::SyncingHead { .. })
-                | (SyncState::Synced, SyncState::Synced)
-                | (SyncState::Stalled, SyncState::Stalled)
-                | (SyncState::SyncTransition, SyncState::SyncTransition)
-                | (
-                    SyncState::BackFillSyncing { .. },
-                    SyncState::BackFillSyncing { .. }
-                )
-        )
-    }
-}
-
-impl SyncState {
-    /// Returns a boolean indicating the node is currently performing a long-range sync.
-    pub fn is_syncing(&self) -> bool {
-        match self {
-            SyncState::SyncingFinalized { .. } => true,
-            SyncState::SyncingHead { .. } => true,
-            SyncState::SyncTransition => true,
-            // Backfill doesn't effect any logic, we consider this state, not syncing.
-            SyncState::BackFillSyncing { .. } => false,
-            SyncState::Synced => false,
-            SyncState::Stalled => false,
-        }
-    }
-
-    pub fn is_syncing_finalized(&self) -> bool {
-        match self {
-            SyncState::SyncingFinalized { .. } => true,
-            SyncState::SyncingHead { .. } => false,
-            SyncState::SyncTransition => false,
-            SyncState::BackFillSyncing { .. } => false,
-            SyncState::Synced => false,
-            SyncState::Stalled => false,
-        }
-    }
-
-    /// Returns true if the node is synced.
-    ///
-    /// NOTE: We consider the node synced if it is fetching old historical blocks.
-    pub fn is_synced(&self) -> bool {
-        matches!(self, SyncState::Synced | SyncState::BackFillSyncing { .. })
-    }
-
-    /// Returns true if the node is *stalled*, i.e. has no synced peers.
-    ///
-    /// Usually this state is treated as unsynced, except in some places where we make an exception
-    /// for single-node testnets where having 0 peers is desired.
-    pub fn is_stalled(&self) -> bool {
-        matches!(self, SyncState::Stalled)
-    }
-}
-
-impl std::fmt::Display for SyncState {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SyncState::SyncingFinalized { .. } => write!(f, "Syncing Finalized Chain"),
-            SyncState::SyncingHead { .. } => write!(f, "Syncing Head Chain"),
-            SyncState::Synced { .. } => write!(f, "Synced"),
-            SyncState::Stalled { .. } => write!(f, "Stalled"),
-            SyncState::SyncTransition => write!(f, "Evaluating known peers"),
-            SyncState::BackFillSyncing { .. } => write!(f, "Syncing Historical Blocks"),
-        }
-    }
-}