Add client support for the lighthouse/peers route

Cargo.toml

@@ -38,6 +38,7 @@ members = [
     "common/oneshot_broadcast",
     "common/pretty_reqwest_error",
     "common/sensitive_url",
+    "common/serde_utils",
     "common/slot_clock",
     "common/system_health",
     "common/task_executor",

beacon_node/lighthouse_network/Cargo.toml

@@ -5,6 +5,7 @@ authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = { workspace = true }
 
 [dependencies]
+serde_utils = { path = "../../common/serde_utils" }
 discv5 = { workspace = true }
 unsigned-varint = { version = "0.6", features = ["codec"] }
 ssz_types = { workspace = true }

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

@@ -3,11 +3,11 @@
 //! Currently using identify to fingerprint.
 
 use libp2p::identify::Info as IdentifyInfo;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, EnumIter, IntoStaticStr};
 
 /// Various client and protocol information related to a node.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Client {
     /// The client's name (Ex: lighthouse, prism, nimbus, etc)
     pub kind: ClientKind,
@@ -21,7 +21,9 @@ pub struct Client {
     pub agent_string: Option<String>,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, PartialEq, AsRefStr, IntoStaticStr, EnumIter)]
+#[derive(
+    Clone, Copy, Debug, Deserialize, Serialize, PartialEq, AsRefStr, IntoStaticStr, EnumIter,
+)]
 pub enum ClientKind {
     /// A lighthouse node (the best kind).
     Lighthouse,

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

@@ -7,7 +7,7 @@ use discv5::Enr;
 use libp2p::core::multiaddr::{Multiaddr, Protocol};
 use serde::{
     ser::{SerializeStruct, Serializer},
-    Serialize,
+    Deserialize, Serialize,
 };
 use std::collections::HashSet;
 use std::net::IpAddr;
@@ -16,8 +16,10 @@ use strum::AsRefStr;
 use types::EthSpec;
 use PeerConnectionStatus::*;
 
+use serde_utils::approx_instant;
+
 /// Information about a given connected peer.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(bound = "T: EthSpec")]
 pub struct PeerInfo<T: EthSpec> {
     /// The peers reputation
@@ -35,6 +37,7 @@ pub struct PeerInfo<T: EthSpec> {
     /// The current syncing state of the peer. The state may be determined after it's initial
     /// connection.
     sync_status: SyncStatus,
+    #[serde(skip)]
     /// The ENR subnet bitfield of the peer. This may be determined after it's initial
     /// connection.
     meta_data: Option<MetaData<T>>,
@@ -473,7 +476,7 @@ impl<T: EthSpec> PeerInfo<T> {
 }
 
 /// Connection Direction of connection.
-#[derive(Debug, Clone, Serialize, AsRefStr)]
+#[derive(Debug, Clone, Deserialize, Serialize, AsRefStr)]
 #[strum(serialize_all = "snake_case")]
 pub enum ConnectionDirection {
     /// The connection was established by a peer dialing us.
@@ -483,7 +486,7 @@ pub enum ConnectionDirection {
 }
 
 /// Connection Status of the peer.
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, Deserialize)]
 pub enum PeerConnectionStatus {
     /// The peer is connected.
     Connected {
@@ -499,16 +502,19 @@ pub enum PeerConnectionStatus {
     },
     /// The peer has disconnected.
     Disconnected {
+        #[serde(with = "approx_instant")]
         /// last time the peer was connected or discovered.
         since: Instant,
     },
     /// The peer has been banned and is disconnected.
     Banned {
+        #[serde(with = "approx_instant")]
         /// moment when the peer was banned.
         since: Instant,
     },
     /// We are currently dialing this peer.
     Dialing {
+        #[serde(with = "approx_instant")]
         /// time since we last communicated with the peer.
         since: Instant,
     },

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

@@ -6,11 +6,13 @@
 //!
 //! The scoring algorithms are currently experimental.
 use crate::service::gossipsub_scoring_parameters::GREYLIST_THRESHOLD as GOSSIPSUB_GREYLIST_THRESHOLD;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use strum::AsRefStr;
 use tokio::time::Duration;
 
+use serde_utils::approx_instant;
+
 lazy_static! {
     static ref HALFLIFE_DECAY: f64 = -(2.0f64.ln()) / SCORE_HALFLIFE;
 }
@@ -124,7 +126,7 @@ impl std::fmt::Display for ScoreState {
 ///
 /// This simplistic version consists of a global score per peer which decays to 0 over time. The
 /// decay rate applies equally to positive and negative scores.
-#[derive(PartialEq, Clone, Debug, Serialize)]
+#[derive(PartialEq, Clone, Debug, Deserialize, Serialize)]
 pub struct RealScore {
     /// The global score.
     // NOTE: In the future we may separate this into sub-scores involving the RPC, Gossipsub and
@@ -136,7 +138,7 @@ pub struct RealScore {
     ignore_negative_gossipsub_score: bool,
     score: f64,
     /// The time the score was last updated to perform time-based adjustments such as score-decay.
-    #[serde(skip)]
+    #[serde(with = "approx_instant")]
     last_updated: Instant,
 }
 
@@ -261,7 +263,7 @@ impl RealScore {
     }
 }
 
-#[derive(PartialEq, Clone, Debug, Serialize)]
+#[derive(PartialEq, Clone, Debug, Deserialize, Serialize)]
 pub enum Score {
     Max,
     Real(RealScore),

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

@@ -1,9 +1,9 @@
 //! Handles individual sync status for peers.
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use types::{Epoch, Hash256, Slot};
 
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 /// The current sync status of the peer.
 pub enum SyncStatus {
     /// At the current state as our node or ahead of us.
@@ -19,7 +19,7 @@ pub enum SyncStatus {
 }
 
 /// A relevant peer's sync information.
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct SyncInfo {
     pub head_slot: Slot,
     pub head_root: Hash256,

beacon_node/lighthouse_network/src/types/subnet.rs

@@ -1,12 +1,12 @@
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use types::{SubnetId, SyncSubnetId};
 
 /// Represents a subnet on an attestation or sync committee `SubnetId`.
 ///
 /// Used for subscribing to the appropriate gossipsub subnets and mark
 /// appropriate metadata bitfields.
-#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, Hash)]
 pub enum Subnet {
     /// Represents a gossipsub attestation subnet and the metadata `attnets` field.
     Attestation(SubnetId),

common/eth2/src/lighthouse.rs

@@ -11,7 +11,7 @@ use crate::{
     ok_or_error,
     types::{
         BeaconState, ChainSpec, DepositTreeSnapshot, Epoch, EthSpec, FinalizedExecutionBlock,
-        GenericResponse, ValidatorId,
+        GenericResponse, PeersData, ValidatorId,
     },
     BeaconNodeHttpClient, DepositData, Error, Eth1Data, Hash256, Slot, StateId, StatusCode,
 };
@@ -41,7 +41,7 @@ four_byte_option_impl!(four_byte_option_hash256, Hash256);
 
 /// Information returned by `peers` and `connected_peers`.
 // TODO: this should be deserializable..
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(bound = "T: EthSpec")]
 pub struct Peer<T: EthSpec> {
     /// The Peer's ID
@@ -413,13 +413,16 @@ impl BeaconNodeHttpClient {
         self.get(path).await
     }
 
-    /*
-     * Note:
-     *
-     * The `lighthouse/peers` endpoints do not have functions here. We are yet to implement
-     * `Deserialize` on the `PeerInfo` struct since it contains use of `Instant`. This could be
-     * fairly simply achieved, if desired.
-     */
+    pub async fn get_lighthouse_peers(&self) -> Result<GenericResponse<PeersData>, Error> {
+        let mut path = self.server.full.clone();
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("lighthouse")
+            .push("peers");
+
+        self.get(path).await
+    }
 
     /// `GET lighthouse/proto_array`
     pub async fn get_lighthouse_proto_array(&self) -> Result<GenericResponse<ProtoArray>, Error> {

common/serde_utils/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "serde_utils"
+version = "0.1.0"
+authors = ["Jack McPherson <jack@sigmaprime.io>"]
+edition = { workspace = true }
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde = { workspace = true }

common/serde_utils/src/approx_instant.rs

@@ -0,0 +1,27 @@
+use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
+/// Serialise and deserialise `std::time::Instant`s
+///
+/// Due to David Tolnay via: https://github.com/serde-rs/serde/issues/1375#issuecomment-419688068
+use std::time::{Instant, SystemTime};
+
+pub fn serialize<S>(instant: &Instant, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let system_now = SystemTime::now();
+    let instant_now = Instant::now();
+    let approx = system_now - (instant_now - *instant);
+    approx.serialize(serializer)
+}
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Instant, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let de = SystemTime::deserialize(deserializer)?;
+    let system_now = SystemTime::now();
+    let instant_now = Instant::now();
+    let duration = system_now.duration_since(de).map_err(Error::custom)?;
+    let approx = instant_now - duration;
+    Ok(approx)
+}

common/serde_utils/src/lib.rs

@@ -0,0 +1 @@
+pub mod approx_instant;