Osiris/monotonic timestamps (#251)

* feat: implement monotonic unix timestamp for reliability

* test: add more tests

* chore: clp

* fix: devnet

* docs: fix comments

---------

Co-authored-by: 0xKitsune <[email protected]>

Author: 0xOsiris

scripts/ci/kurtosis-params.yaml

@@ -22,7 +22,7 @@ optimism_package:
 ethereum_package:
   participants:
   - el_type: geth
-    cl_type: lighthouse
+    cl_type: teku
   network_params:
     preset: minimal
     genesis_delay: 5

src/cli.rs

@@ -97,7 +97,7 @@ impl Args {
 
         // Handle commands if present
         if let Some(cmd) = self.command {
-            let debug_addr = format!("http://{}", debug_addr);
+            let debug_addr = format!("http://{debug_addr}");
             return match cmd {
                 Commands::Debug { command } => match command {
                     DebugCommands::SetExecutionMode { execution_mode } => {

src/health.rs

@@ -15,7 +15,7 @@ use crate::{Health, Probes, RpcClient};
 pub struct HealthHandle {
     pub probes: Arc<Probes>,
     pub builder_client: Arc<RpcClient>,
-    pub health_check_interval: u64,
+    pub health_check_interval: Duration,
     pub max_unsafe_interval: u64,
 }
 
@@ -24,6 +24,8 @@ impl HealthHandle {
     /// the current time minus the max_unsafe_interval.
     pub fn spawn(self) -> JoinHandle<()> {
         tokio::spawn(async move {
+            let mut timestamp = MonotonicTimestamp::new();
+
             loop {
                 let latest_unsafe = match self
                     .builder_client
@@ -34,32 +36,70 @@ impl HealthHandle {
                     Err(e) => {
                         warn!(target: "rollup_boost::health", "Failed to get unsafe block from builder client: {} - updating health status", e);
                         self.probes.set_health(Health::PartialContent);
-                        sleep_until(
-                            Instant::now() + Duration::from_secs(self.health_check_interval),
-                        )
-                        .await;
+                        sleep_until(Instant::now() + self.health_check_interval).await;
                         continue;
                     }
                 };
 
-                let now = SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .expect("Time went backwards")
-                    .as_secs();
-
-                if now - latest_unsafe.header.timestamp > self.max_unsafe_interval {
-                    warn!(target: "rollup_boost::health", "Unsafe block timestamp is too old ({} seconds - updating health status)", now - latest_unsafe.header.timestamp);
+                let t = timestamp.tick();
+                if t.saturating_sub(latest_unsafe.header.timestamp)
+                    .gt(&self.max_unsafe_interval)
+                {
+                    warn!(target: "rollup_boost::health", curr_unix = %t, unsafe_unix = %latest_unsafe.header.timestamp, "Unsafe block timestamp is too old updating health status");
                     self.probes.set_health(Health::PartialContent);
                 } else {
                     self.probes.set_health(Health::Healthy);
                 }
 
-                sleep_until(Instant::now() + Duration::from_secs(self.health_check_interval)).await;
+                sleep_until(Instant::now() + self.health_check_interval).await;
             }
         })
     }
 }
 
+/// A monotonic wall-clock timestamp tracker that resists system clock changes.
+///
+/// This struct provides a way to generate wall-clock-like timestamps that are
+/// guaranteed to be monotonic (i.e., never go backward), even if the system
+/// time is adjusted (e.g., via NTP, manual clock changes, or suspend/resume).
+///
+/// - It tracks elapsed time using `Instant` to ensure monotonic progression.
+/// - It produces a synthetic wall-clock timestamp that won't regress.
+pub struct MonotonicTimestamp {
+    /// The last known UNIX timestamp in seconds.
+    pub last_unix: u64,
+
+    /// The last monotonic time reference.
+    pub last_instant: Instant,
+}
+
+impl Default for MonotonicTimestamp {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl MonotonicTimestamp {
+    pub fn new() -> Self {
+        let last_unix = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time went backwards")
+            .as_secs();
+        let last_instant = Instant::now();
+        Self {
+            last_unix,
+            last_instant,
+        }
+    }
+
+    fn tick(&mut self) -> u64 {
+        let elapsed = self.last_instant.elapsed().as_secs();
+        self.last_unix += elapsed;
+        self.last_instant = Instant::now();
+        self.last_unix
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::net::SocketAddr;
@@ -214,7 +254,7 @@ mod tests {
         let health_handle = HealthHandle {
             probes: probes.clone(),
             builder_client: builder_client.clone(),
-            health_check_interval: 60,
+            health_check_interval: Duration::from_secs(60),
             max_unsafe_interval: 5,
         };
 
@@ -244,7 +284,7 @@ mod tests {
         let health_handle = HealthHandle {
             probes: probes.clone(),
             builder_client: builder_client.clone(),
-            health_check_interval: 60,
+            health_check_interval: Duration::from_secs(60),
             max_unsafe_interval: 5,
         };
 
@@ -268,7 +308,7 @@ mod tests {
         let health_handle = HealthHandle {
             probes: probes.clone(),
             builder_client: builder_client.clone(),
-            health_check_interval: 60,
+            health_check_interval: Duration::from_secs(60),
             max_unsafe_interval: 5,
         };
 
@@ -277,4 +317,34 @@ mod tests {
         assert!(matches!(probes.health(), Health::PartialContent));
         Ok(())
     }
+
+    #[tokio::test]
+    async fn tick_advances_after_sleep() {
+        let mut ts = MonotonicTimestamp::new();
+        let t1 = ts.tick();
+        tokio::time::sleep(Duration::from_secs(1)).await;
+        let t2 = ts.tick();
+
+        assert!(t2 >= t1 + 1,);
+    }
+
+    #[tokio::test]
+    async fn tick_matches_system_clock() {
+        let mut ts = MonotonicTimestamp::new();
+        let unix = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time went backwards")
+            .as_secs();
+
+        assert_eq!(ts.last_unix, unix);
+
+        std::thread::sleep(Duration::from_secs(5));
+
+        let t1 = ts.tick();
+        let unix = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("Time went backwards")
+            .as_secs();
+        assert_eq!(t1, unix);
+    }
 }

src/server.rs

@@ -28,6 +28,7 @@ use op_alloy_rpc_types_engine::{
 use opentelemetry::trace::SpanKind;
 use parking_lot::Mutex;
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::task::JoinHandle;
 use tracing::{info, instrument};
 
@@ -52,7 +53,7 @@ impl RollupBoostServer {
         let health_handle = HealthHandle {
             probes: probes.clone(),
             builder_client: Arc::new(builder_client.clone()),
-            health_check_interval,
+            health_check_interval: Duration::from_secs(health_check_interval),
             max_unsafe_interval,
         }
         .spawn();