Squashed reset to unstable

common/eth2/src/lib.rs

@@ -16,12 +16,11 @@ pub mod types;
 
 use self::mixin::{RequestAccept, ResponseOptional};
 use self::types::{Error as ResponseError, *};
-use ::types::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedResponse;
 use derivative::Derivative;
 use either::Either;
 use futures::Stream;
 use futures_util::StreamExt;
-use libp2p_identity::PeerId;
+use lighthouse_network::PeerId;
 use pretty_reqwest_error::PrettyReqwestError;
 pub use reqwest;
 use reqwest::{
@@ -37,6 +36,7 @@ use std::fmt;
 use std::future::Future;
 use std::path::PathBuf;
 use std::time::Duration;
+use store::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedResponse;
 
 pub const V1: EndpointVersion = EndpointVersion(1);
 pub const V2: EndpointVersion = EndpointVersion(2);

common/eth2/src/lighthouse.rs

@@ -6,17 +6,18 @@ mod block_packing_efficiency;
 mod block_rewards;
 mod standard_block_rewards;
 mod sync_committee_rewards;
-pub mod sync_state;
 
-use crate::lighthouse::sync_state::SyncState;
 use crate::{
-    types::{DepositTreeSnapshot, Epoch, FinalizedExecutionBlock, GenericResponse, ValidatorId},
+    types::{
+        DepositTreeSnapshot, Epoch, EthSpec, FinalizedExecutionBlock, GenericResponse, ValidatorId,
+    },
     BeaconNodeHttpClient, DepositData, Error, Eth1Data, Hash256, Slot,
 };
 use proto_array::core::ProtoArray;
 use serde::{Deserialize, Serialize};
 use ssz::four_byte_option_impl;
 use ssz_derive::{Decode, Encode};
+use store::{AnchorInfo, BlobInfo, Split, StoreConfig};
 
 pub use attestation_performance::{
     AttestationPerformance, AttestationPerformanceQuery, AttestationPerformanceStatistics,
@@ -26,6 +27,7 @@ pub use block_packing_efficiency::{
     BlockPackingEfficiency, BlockPackingEfficiencyQuery, ProposerInfo, UniqueAttestation,
 };
 pub use block_rewards::{AttestationRewards, BlockReward, BlockRewardMeta, BlockRewardsQuery};
+pub use lighthouse_network::{types::SyncState, PeerInfo};
 pub use standard_block_rewards::StandardBlockReward;
 pub use sync_committee_rewards::SyncCommitteeReward;
 
@@ -35,12 +37,14 @@ four_byte_option_impl!(four_byte_option_u64, u64);
 four_byte_option_impl!(four_byte_option_hash256, Hash256);
 
 /// Information returned by `peers` and `connected_peers`.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Peer {
+// TODO: this should be deserializable..
+#[derive(Debug, Clone, Serialize)]
+#[serde(bound = "E: EthSpec")]
+pub struct Peer<E: EthSpec> {
     /// The Peer's ID
     pub peer_id: String,
     /// The PeerInfo associated with the peer.
-    pub peer_info: serde_json::Value,
+    pub peer_info: PeerInfo<E>,
 }
 
 /// The results of validators voting during an epoch.
@@ -230,6 +234,15 @@ impl From<Eth1Block> for FinalizedExecutionBlock {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DatabaseInfo {
+    pub schema_version: u64,
+    pub config: StoreConfig,
+    pub split: Split,
+    pub anchor: AnchorInfo,
+    pub blob_info: BlobInfo,
+}
+
 impl BeaconNodeHttpClient {
     /// `GET lighthouse/health`
     pub async fn get_lighthouse_health(&self) -> Result<GenericResponse<Health>, Error> {
@@ -368,7 +381,7 @@ impl BeaconNodeHttpClient {
     }
 
     /// `GET lighthouse/database/info`
-    pub async fn get_lighthouse_database_info(&self) -> Result<serde_json::Value, Error> {
+    pub async fn get_lighthouse_database_info(&self) -> Result<DatabaseInfo, Error> {
         let mut path = self.server.full.clone();
 
         path.path_segments_mut()

common/eth2/src/lighthouse/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"),
-        }
-    }
-}

common/eth2/src/types.rs

@@ -5,9 +5,8 @@ use crate::{
     Error as ServerError, CONSENSUS_BLOCK_VALUE_HEADER, CONSENSUS_VERSION_HEADER,
     EXECUTION_PAYLOAD_BLINDED_HEADER, EXECUTION_PAYLOAD_VALUE_HEADER,
 };
-use enr::{CombinedKey, Enr};
+use lighthouse_network::{ConnectionDirection, Enr, Multiaddr, PeerConnectionStatus};
 use mediatype::{names, MediaType, MediaTypeList};
-use multiaddr::Multiaddr;
 use reqwest::header::HeaderMap;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::Value;
@@ -579,7 +578,7 @@ pub struct ChainHeadData {
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct IdentityData {
     pub peer_id: String,
-    pub enr: Enr<CombinedKey>,
+    pub enr: Enr,
     pub p2p_addresses: Vec<Multiaddr>,
     pub discovery_addresses: Vec<Multiaddr>,
     pub metadata: MetaData,
@@ -862,6 +861,19 @@ pub enum PeerState {
     Disconnecting,
 }
 
+impl PeerState {
+    pub fn from_peer_connection_status(status: &PeerConnectionStatus) -> Self {
+        match status {
+            PeerConnectionStatus::Connected { .. } => PeerState::Connected,
+            PeerConnectionStatus::Dialing { .. } => PeerState::Connecting,
+            PeerConnectionStatus::Disconnecting { .. } => PeerState::Disconnecting,
+            PeerConnectionStatus::Disconnected { .. }
+            | PeerConnectionStatus::Banned { .. }
+            | PeerConnectionStatus::Unknown => PeerState::Disconnected,
+        }
+    }
+}
+
 impl FromStr for PeerState {
     type Err = String;
 
@@ -894,6 +906,15 @@ pub enum PeerDirection {
     Outbound,
 }
 
+impl PeerDirection {
+    pub fn from_connection_direction(direction: &ConnectionDirection) -> Self {
+        match direction {
+            ConnectionDirection::Incoming => PeerDirection::Inbound,
+            ConnectionDirection::Outgoing => PeerDirection::Outbound,
+        }
+    }
+}
+
 impl FromStr for PeerDirection {
     type Err = String;