feat: add chain head metrics (#1863)

Author: morph-dev

Cargo.lock

@@ -1,7 +1,7 @@
 use std::{
     cmp::Ordering,
     sync::{Arc, Mutex as StdMutex},
-    time::{Instant, SystemTime},
+    time::{Duration, Instant},
 };
 
 use alloy::primitives::B256;
@@ -22,6 +22,7 @@ use ethportal_api::{
             ForkVersionedHistoricalSummariesWithProof, LightClientUpdatesByRange,
         },
         network::Subnetwork,
+        network_spec::network_spec,
         portal_wire::OfferTrace,
     },
     BeaconContentKey, BeaconContentValue, ContentValue, LightClientBootstrapKey,
@@ -30,19 +31,14 @@ use ethportal_api::{
 use ssz_types::VariableList;
 use tokio::{
     sync::Mutex,
-    time::{interval, sleep, timeout, Duration, MissedTickBehavior},
+    time::{interval_at, sleep, timeout, Instant as TokioInstant, MissedTickBehavior},
 };
 use tracing::{error, info, warn, Instrument};
 use trin_beacon::network::BeaconNetwork;
 use trin_metrics::bridge::BridgeMetricsReporter;
 
 use super::{constants::SERVE_BLOCK_TIMEOUT, offer_report::OfferReport};
-use crate::{
-    census::Census,
-    constants::BEACON_GENESIS_TIME,
-    types::mode::BridgeMode,
-    utils::{duration_until_next_update, expected_current_slot},
-};
+use crate::{census::Census, types::mode::BridgeMode, utils::duration_until_next_update};
 
 /// A helper struct to hold the finalized beacon state metadata.
 #[derive(Clone, Debug, Default)]
@@ -119,14 +115,12 @@ impl BeaconBridge {
 
         // Sleep until next update becomes available. This sets up the interval to update as soon as
         // the following slot becomes available.
-        let now = SystemTime::now();
-        let next_update = duration_until_next_update(BEACON_GENESIS_TIME, now)
-            .to_std()
-            .expect("failed to convert chrono duration to std duration");
-        sleep(next_update).await;
-
-        // Run the beacon bridge update once every slot
-        let mut interval = interval(Duration::from_secs(12));
+        let until_next_update = duration_until_next_update();
+        let mut interval = interval_at(
+            TokioInstant::now() + until_next_update,
+            Duration::from_secs(12),
+        );
+
         // If serving takes a little too long, then we want to serve the next one as soon as
         // possible, but not serve any extras until the following slot. "Skip" gets this behavior.
         interval.set_missed_tick_behavior(MissedTickBehavior::Skip);
@@ -314,9 +308,7 @@ impl BeaconBridge {
         metrics: BridgeMetricsReporter,
         census: Census,
     ) -> anyhow::Result<()> {
-        let now = SystemTime::now();
-        let expected_current_period =
-            expected_current_slot(BEACON_GENESIS_TIME, now) / SLOTS_PER_HISTORICAL_ROOT;
+        let expected_current_period = network_spec().current_slot() / SLOTS_PER_HISTORICAL_ROOT;
         match expected_current_period.cmp(&*current_period.lock().await) {
             Ordering::Equal => {
                 // We already gossiped the latest data from the current period, no need to serve it

bin/portal-bridge/src/bridge/beacon.rs

@@ -4,9 +4,6 @@ pub const HEADER_WITH_PROOF_CONTENT_KEY: &str =
 pub const HEADER_WITH_PROOF_CONTENT_VALUE: &str =
     "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";
 
-// Beacon chain mainnet genesis time: Tue Dec 01 2020 12:00:23 GMT+0000
-pub const BEACON_GENESIS_TIME: u64 = 1606824023;
-
 // The maximum number of concurrent offer jsonrpc requests that can be made simultaneously.
 // Currently, this is only used in the state bridge.
 pub const DEFAULT_OFFER_LIMIT: usize = 64;

bin/portal-bridge/src/constants.rs

@@ -1,9 +1,11 @@
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime};
 
 use alloy::primitives::B256;
-use chrono::Duration;
 use discv5::enr::{CombinedKey, Enr, NodeId};
-use ethportal_api::{types::network_spec::network_spec, utils::bytes::hex_encode};
+use ethportal_api::{
+    consensus::constants::SECONDS_PER_SLOT, types::network_spec::network_spec,
+    utils::bytes::hex_encode,
+};
 
 /// Generates a set of N private keys, with node ids that are equally spaced
 /// around the 256-bit keys space.
@@ -51,41 +53,31 @@ fn random_node_id() -> (NodeId, CombinedKey) {
 
 /// Gets the duration until the next light client update
 /// Updates are scheduled for 4 seconds into each slot
-pub fn duration_until_next_update(genesis_time: u64, now: SystemTime) -> Duration {
-    let current_slot = expected_current_slot(genesis_time, now);
-    let next_slot = current_slot + 1;
-    let next_slot_timestamp = network_spec().slot_to_timestamp(next_slot);
+pub fn duration_until_next_update() -> Duration {
+    let current_slot_timestamp = network_spec().slot_to_timestamp(network_spec().current_slot());
 
-    let now = now
-        .duration_since(UNIX_EPOCH)
-        .expect("Time went backwards")
-        .as_secs();
+    // Calculate the update timestamp for current timestamp
+    let mut next_update_timestamp = current_slot_timestamp + Duration::from_secs(4);
 
-    let time_to_next_slot = next_slot_timestamp - now;
-    let next_update = time_to_next_slot + 4;
-
-    Duration::seconds(next_update as i64)
-}
-
-pub fn expected_current_slot(genesis_time: u64, now: SystemTime) -> u64 {
-    let now = now.duration_since(UNIX_EPOCH).expect("Time went backwards");
-    let since_genesis = now - std::time::Duration::from_secs(genesis_time);
-
-    since_genesis.as_secs() / 12
+    // 4 seconds into current slot might have passed already, so we should try next slot
+    loop {
+        if let Ok(until_next_update) = next_update_timestamp.duration_since(SystemTime::now()) {
+            return until_next_update;
+        }
+        next_update_timestamp += SECONDS_PER_SLOT;
+    }
 }
 
 #[cfg(test)]
 #[allow(clippy::unwrap_used)]
 mod tests {
-    use chrono::{DateTime, TimeZone, Utc};
     use ethportal_api::{
         types::distance::{Metric, XorMetric},
         utils::bytes::hex_decode,
     };
     use rstest::rstest;
 
     use super::*;
-    use crate::constants::BEACON_GENESIS_TIME;
 
     #[rstest]
     #[case(2)]
@@ -113,24 +105,4 @@ mod tests {
             "{distance} vs {min_spread}, first bytes: {first_byte1} vs {first_byte2}"
         );
     }
-
-    #[rstest]
-    #[case(10, 5)]
-    #[case(11, 16)]
-    fn test_duration_until_next_update(#[case] seconds: u32, #[case] expected_duration: i64) {
-        let date: DateTime<Utc> = Utc.with_ymd_and_hms(2023, 8, 23, 11, 00, seconds).unwrap();
-        let now = SystemTime::from(date);
-        let duration = duration_until_next_update(BEACON_GENESIS_TIME, now);
-        assert_eq!(duration, Duration::seconds(expected_duration));
-    }
-
-    #[rstest]
-    #[case(10, 7163698)]
-    #[case(11, 7163699)]
-    fn test_expected_current_slot(#[case] seconds: u32, #[case] expected_slot: u64) {
-        let date: DateTime<Utc> = Utc.with_ymd_and_hms(2023, 8, 23, 11, 00, seconds).unwrap();
-        let now = SystemTime::from(date);
-        let slot = expected_current_slot(BEACON_GENESIS_TIME, now);
-        assert_eq!(slot, expected_slot);
-    }
 }

bin/portal-bridge/src/utils.rs

@@ -1,9 +1,14 @@
 //! Consensus specs constants.
 //!
-//! Mostly taken from: https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/presets/mainnet/phase0.yaml
+//! Mostly taken from:
+//! https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/presets/mainnet/phase0.yaml
+//! or
+//! https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/configs/mainnet.yaml
 //!
 //! These should eventually be part of the Chain configuration parameters.
 
+use std::time::Duration;
+
 /// Number of slots per Epoch.
 ///
 /// 2**5 (= 32) slots 6.4 minutes
@@ -14,20 +19,22 @@ pub const SLOTS_PER_EPOCH: u64 = 32;
 /// 2**13 (= 8,192) slots ~27 hours
 pub const SLOTS_PER_HISTORICAL_ROOT: u64 = 8192;
 
+/// Seconds per slot
+///
+/// 12 seconds
+pub const SECONDS_PER_SLOT: Duration = Duration::from_secs(12);
+
 /// The Epoch of the mainnet Capella fork.
 ///
 /// April 12, 2023, 10:27:35pm UTC
-/// Source: https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/configs/mainnet.yaml
 pub const CAPELLA_FORK_EPOCH: u64 = 194_048;
 
 /// The Epoch of the mainnet Deneb fork.
 ///
 /// March 13, 2024, 01:55:35pm UTC
-/// Source: https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/configs/mainnet.yaml
 pub const DENEB_FORK_EPOCH: u64 = 269_568;
 
 /// The Epoch of the mainnet Electra fork.
 ///
 /// May 7, 2025, 10:05:11am UTC
-/// Source: https://github.com/ethereum/consensus-specs/blob/d8cfdf2626c1219a40048f8fa3dd103ae8c0b040/configs/mainnet.yaml
 pub const ELECTRA_FORK_EPOCH: u64 = 364_032;

crates/ethportal-api/src/types/consensus/constants.rs

@@ -1,4 +1,7 @@
-use std::sync::{Arc, LazyLock};
+use std::{
+    sync::{Arc, LazyLock},
+    time::{Duration, SystemTime},
+};
 
 use alloy_hardforks::{EthereumChainHardforks, EthereumHardfork, EthereumHardforks, ForkCondition};
 use anyhow::anyhow;
@@ -8,6 +11,7 @@ use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 
 use super::{
+    consensus::constants::SECONDS_PER_SLOT,
     network::{Network, Subnetwork},
     protocol_versions::{
         ProtocolVersion, ProtocolVersionError, ProtocolVersionList, ENR_PROTOCOL_VERSION_KEY,
@@ -51,7 +55,7 @@ pub struct NetworkSpec {
     portal_subnetworks: BiHashMap<Subnetwork, String>,
     supported_protocol_versions: ProtocolVersionList,
     hardforks: EthereumChainHardforks,
-    beacon_genesis_timestamp: u64,
+    beacon_genesis_timestamp: SystemTime,
 }
 
 impl NetworkSpec {
@@ -70,7 +74,8 @@ impl NetworkSpec {
             network,
             supported_protocol_versions,
             hardforks,
-            beacon_genesis_timestamp,
+            beacon_genesis_timestamp: SystemTime::UNIX_EPOCH
+                + Duration::from_secs(beacon_genesis_timestamp),
         })
     }
 
@@ -123,8 +128,24 @@ impl NetworkSpec {
             .ok_or(ProtocolVersionError::NoMatchingVersion)
     }
 
-    pub fn slot_to_timestamp(&self, slot: u64) -> u64 {
-        self.beacon_genesis_timestamp + slot * 12
+    pub fn slot_to_timestamp(&self, slot: u64) -> SystemTime {
+        self.beacon_genesis_timestamp + (SECONDS_PER_SLOT * slot as u32)
+    }
+
+    pub fn slot_to_timestamp_u64(&self, slot: u64) -> u64 {
+        self.slot_to_timestamp(slot)
+            .duration_since(SystemTime::UNIX_EPOCH)
+            .expect("Slot's timestamp must be after UNIX EPOCH timestamp")
+            .as_secs()
+    }
+
+    pub fn current_slot(&self) -> u64 {
+        let seconds_since_genesis = self
+            .beacon_genesis_timestamp
+            .elapsed()
+            .expect("Genesis timestamp must be in the past")
+            .as_secs();
+        seconds_since_genesis / SECONDS_PER_SLOT.as_secs()
     }
 }