refactor: extract eth2wrap (#214)

* Use `fetch_genesis_time`

* Add `fetch_slots_config`

* Remove clippy overrides

* Add `fetch_fork_config`

* Move `eth2api` to actual crate

* Consistent error case naming

* Consistent erro case names

* Reuse `fetch_slots_config`

* Extract Beacon node setup

* Rename test

* Test `fetch_genesis_time`

* Test `fetch_slots_config`

- Fixes deserialization issues

* Test `fetch_fork_config`

- Fix serialization issues

* Apply clippy suggestions

* Do not lose error information

* Reuse containers when possible

* Inline variable

* Prefer `LazyLock`

Author: emlautarom1

Cargo.lock

@@ -1,10 +1,5 @@
-// TODO: Requires `eth2client`
-#![allow(unreachable_code)]
-#![allow(unused_variables)]
-#![allow(clippy::diverging_sub_expression)]
-
 use pluto_core::types::{Duty, DutyType};
-use std::time;
+use pluto_eth2api::{EthBeaconNodeApiClient, EthBeaconNodeApiClientError};
 
 /// Defines the fraction of the slot duration to use as a margin.
 /// This is to consider network delays and other factors that may affect the
@@ -16,16 +11,19 @@ pub type DeadlineFunc = Box<dyn Fn(Duty) -> Option<chrono::DateTime<chrono::Utc>
 
 /// Error type for deadline-related operations.
 #[derive(Debug, thiserror::Error)]
-pub enum DeadlineError {}
+pub enum DeadlineError {
+    /// Beacon client API error.
+    #[error("Beacon client error: {0}")]
+    BeaconClientError(#[from] EthBeaconNodeApiClientError),
+}
 
 type Result<T> = std::result::Result<T, DeadlineError>;
 
 /// Create a function that provides duty deadline or [`None`] if the duty never
 /// deadlines.
-pub fn new_duty_deadline_func() -> Result<DeadlineFunc> {
-    let genesis_time: chrono::DateTime<chrono::Utc> = todo!("Fetch genesis time from eth2 client");
-
-    let slot_duration: time::Duration = todo!("Fetch slot duration from eth2 client");
+pub async fn new_duty_deadline_func(eth2_cl: &EthBeaconNodeApiClient) -> Result<DeadlineFunc> {
+    let genesis_time = eth2_cl.fetch_genesis_time().await?;
+    let (slot_duration, _) = eth2_cl.fetch_slots_config().await?;
 
     #[allow(
         clippy::arithmetic_side_effects,

crates/app/src/deadline/mod.rs

@@ -3,9 +3,3 @@ pub mod version;
 
 /// Cache of Validators retrieved from the Beacon node
 pub mod valcache;
-
-/// Extensions module to the Eth2Api crate
-///
-/// Includes additional data types and functions to reduce the boilerplate when
-/// interacting with `eth2api`.
-pub mod eth2api;

crates/app/src/eth2wrap/eth2api.rs

@@ -1,9 +1,9 @@
-use crate::eth2wrap::eth2api::{EthBeaconNodeApiClientError, ValidatorIndex, ValidatorStatusExt};
 use pluto_core::types::PubKey;
 use pluto_eth2api::{
-    EthBeaconNodeApiClient, GetStateValidatorsResponseResponse,
+    EthBeaconNodeApiClient, EthBeaconNodeApiClientError, GetStateValidatorsResponseResponse,
     GetStateValidatorsResponseResponseDatum, PostStateValidatorsRequest,
-    PostStateValidatorsRequestPath, PostStateValidatorsResponse, ValidatorRequestBody,
+    PostStateValidatorsRequestPath, PostStateValidatorsResponse, ValidatorIndex,
+    ValidatorRequestBody,
 };
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;
@@ -13,9 +13,9 @@ type Result<T> = std::result::Result<T, ValidatorCacheError>;
 /// Errors that can occur when interacting with the validator cache.
 #[derive(Debug, thiserror::Error)]
 pub enum ValidatorCacheError {
-    /// Beacon client API error.
-    #[error("Beacon client error: {0}")]
-    BeaconClientError(#[from] EthBeaconNodeApiClientError),
+    /// Beacon Node API client error.
+    #[error("Beacon Node API client error: {0}")]
+    EthBeaconNodeApiClientError(#[from] EthBeaconNodeApiClientError),
 }
 
 /// Active validators as [`PubKey`] indexed by their validator index.

crates/app/src/eth2wrap/mod.rs

@@ -16,6 +16,9 @@ reqwest.workspace = true
 serde_json.workspace = true
 serde_with.workspace = true
 serde.workspace = true
+thiserror.workspace = true
+chrono.workspace = true
+hex.workspace = true
 validator.workspace = true
 
 [dev-dependencies]

crates/app/src/eth2wrap/valcache.rs

@@ -0,0 +1,160 @@
+use crate::{
+    ConsensusVersion, EthBeaconNodeApiClient, GetGenesisRequest, GetGenesisResponse,
+    GetSpecRequest, GetSpecResponse, ValidatorStatus,
+};
+use chrono::{DateTime, Utc};
+use std::{collections::HashMap, time};
+
+/// Error that can occur when using the
+/// [`EthBeaconNodeApiClient`].
+#[derive(Debug, thiserror::Error)]
+pub enum EthBeaconNodeApiClientError {
+    /// Underlying error from [`EthBeaconNodeApiClient`] when
+    /// making a request.
+    #[error("Request error: {0}")]
+    RequestError(#[from] anyhow::Error),
+
+    /// Unexpected response, e.g, got an error when an Ok response was expected
+    #[error("Unexpected response")]
+    UnexpectedResponse,
+
+    /// Unexpected type in response
+    #[error("Unexpected type in response")]
+    UnexpectedType,
+
+    /// Zero slot duration or slots per epoch in network spec
+    #[error("Zero slot duration or slots per epoch in network spec")]
+    ZeroSlotDurationOrSlotsPerEpoch,
+}
+
+/// Type alias for validator index.
+pub type ValidatorIndex = u64;
+
+const FORKS: [ConsensusVersion; 6] = [
+    ConsensusVersion::Altair,
+    ConsensusVersion::Bellatrix,
+    ConsensusVersion::Capella,
+    ConsensusVersion::Deneb,
+    ConsensusVersion::Electra,
+    ConsensusVersion::Fulu,
+];
+
+/// The schedule of given fork, containing the fork version and the epoch at
+/// which it activates.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ForkSchedule {
+    /// The fork version, as a 4-byte array.
+    pub version: [u8; 4],
+    /// The epoch at which the fork activates.
+    pub epoch: u64,
+}
+
+impl ValidatorStatus {
+    /// Returns true if the validator is in one of the active states.
+    pub fn is_active(&self) -> bool {
+        matches!(
+            self,
+            ValidatorStatus::ActiveOngoing
+                | ValidatorStatus::ActiveExiting
+                | ValidatorStatus::ActiveSlashed
+        )
+    }
+}
+
+impl EthBeaconNodeApiClient {
+    /// Fetches the genesis time.
+    pub async fn fetch_genesis_time(&self) -> Result<DateTime<Utc>, EthBeaconNodeApiClientError> {
+        let genesis = match self.get_genesis(GetGenesisRequest {}).await? {
+            GetGenesisResponse::Ok(genesis) => genesis,
+            _ => return Err(EthBeaconNodeApiClientError::UnexpectedResponse),
+        };
+
+        genesis
+            .data
+            .genesis_time
+            .parse()
+            .map_err(|_| EthBeaconNodeApiClientError::UnexpectedType)
+            .and_then(|timestamp| {
+                DateTime::from_timestamp(timestamp, 0)
+                    .ok_or(EthBeaconNodeApiClientError::UnexpectedType)
+            })
+    }
+
+    /// Fetches the slot duration and slots per epoch.
+    pub async fn fetch_slots_config(
+        &self,
+    ) -> Result<(time::Duration, u64), EthBeaconNodeApiClientError> {
+        let spec = match self.get_spec(GetSpecRequest {}).await? {
+            GetSpecResponse::Ok(spec) => spec,
+            _ => return Err(EthBeaconNodeApiClientError::UnexpectedResponse),
+        };
+
+        let slot_duration = spec
+            .data
+            .as_object()
+            .and_then(|o| o.get("SECONDS_PER_SLOT"))
+            .and_then(|v| v.as_str())
+            .and_then(|s| s.parse::<u64>().ok())
+            .ok_or(EthBeaconNodeApiClientError::UnexpectedType)
+            .map(time::Duration::from_secs)?;
+
+        let slots_per_epoch = spec
+            .data
+            .as_object()
+            .and_then(|o| o.get("SLOTS_PER_EPOCH"))
+            .and_then(|v| v.as_str())
+            .and_then(|s| s.parse::<u64>().ok())
+            .ok_or(EthBeaconNodeApiClientError::UnexpectedType)?;
+
+        if slot_duration == time::Duration::ZERO || slots_per_epoch == 0 {
+            return Err(EthBeaconNodeApiClientError::ZeroSlotDurationOrSlotsPerEpoch);
+        }
+
+        Ok((slot_duration, slots_per_epoch))
+    }
+
+    /// Fetches the fork schedule for all known forks.
+    pub async fn fetch_fork_config(
+        &self,
+    ) -> Result<HashMap<ConsensusVersion, ForkSchedule>, EthBeaconNodeApiClientError> {
+        fn fetch_fork(
+            fork: &ConsensusVersion,
+            spec_data: &serde_json::Value,
+        ) -> Result<ForkSchedule, EthBeaconNodeApiClientError> {
+            let version_field = format!("{}_FORK_VERSION", fork.to_string().to_uppercase());
+            let version = spec_data
+                .as_object()
+                .and_then(|o| o.get(&version_field))
+                .and_then(|f| f.as_str())
+                .and_then(|hex| {
+                    let hex = hex.strip_prefix("0x").unwrap_or(hex);
+                    hex::decode(hex).ok()
+                })
+                .and_then(|bytes| bytes.try_into().ok())
+                .ok_or(EthBeaconNodeApiClientError::UnexpectedType)?;
+
+            let epoch_field = format!("{}_FORK_EPOCH", fork.to_string().to_uppercase());
+            let epoch = spec_data
+                .as_object()
+                .and_then(|o| o.get(&epoch_field))
+                .and_then(|v| v.as_str())
+                .and_then(|s| s.parse::<u64>().ok())
+                .ok_or(EthBeaconNodeApiClientError::UnexpectedType)?;
+
+            Ok(ForkSchedule { version, epoch })
+        }
+
+        let spec = match self.get_spec(GetSpecRequest {}).await? {
+            GetSpecResponse::Ok(spec) => spec,
+            _ => return Err(EthBeaconNodeApiClientError::UnexpectedResponse),
+        };
+
+        let mut result = HashMap::new();
+        for fork in FORKS.into_iter() {
+            let fork_schedule = fetch_fork(&fork, &spec.data)?;
+            result.insert(fork, fork_schedule);
+        }
+
+        Ok(result)
+    }
+}