feat(supervisor/core): preinterop node support

crates/supervisor/core/src/config/rollup_config_set.rs

@@ -29,8 +29,8 @@
         }
     }
 
-    /// Returns the genesis anchor as a [`DerivedRefPair`].
-    pub const fn get_anchor(&self) -> DerivedRefPair {
+    /// Returns the genesis as a [`DerivedRefPair`].
+    pub const fn get_derived_pair(&self) -> DerivedRefPair {
         DerivedRefPair { derived: self.l2, source: self.l1 }
     }
 }
@@ -73,15 +73,36 @@
         })
     }
 
+    /// Returns `true` if the timestamp is at or after the interop activation time.
+    ///
+    /// Interop activates at [`interop_time`](Self::interop_time). This function checks whether the
+    /// provided timestamp is before or after interop timestamp.
+    ///
+    /// Returns `false` if `interop_time` is not configured.
+    pub fn is_interop(&self, timestamp: u64) -> bool {
+        self.interop_time.is_some_and(|t| timestamp >= t)
+    }
+
     /// Returns `true` if the timestamp is strictly after the interop activation block.
     ///
     /// Interop activates at [`interop_time`](Self::interop_time). This function checks whether the
-    /// current block timestamp is *after* that activation, skipping the activation block
+    /// provided timestamp is *after* that activation, skipping the activation block
     /// itself.
     ///
     /// Returns `false` if `interop_time` is not configured.
     pub fn is_post_interop(&self, timestamp: u64) -> bool {
-        self.interop_time.is_some_and(|t| timestamp.saturating_sub(self.block_time) >= t)
+        self.is_interop(timestamp.saturating_sub(self.block_time))
+    }
+
+    /// Returns `true` if given block is the interop activation block.
+    ///
+    /// An interop activation block is defined as the block that is right after the
+    /// interop activation time.
+    ///
+    /// Returns `false` if `interop_time` is not configured.
+    pub fn is_interop_activation_block(&self, block: BlockInfo) -> bool {
+        self.is_interop(block.timestamp) &&
+            !self.is_interop(block.timestamp.saturating_sub(self.block_time))
     }
 }
 
@@ -115,10 +136,15 @@
         Ok(())
     }
 
-    /// returns whether interop is enabled for a chain at given timestamp
+    /// Returns `true` if interop is enabled for the chain at given timestamp.
     pub fn is_interop_enabled(&self, chain_id: ChainId, timestamp: u64) -> bool {
         self.get(chain_id).map(|cfg| cfg.is_post_interop(timestamp)).unwrap_or(false) // if config not found, return false
     }
+
+    /// Returns `true` if given block is the interop activation block for the specified chain.
+    pub fn is_interop_activation_block(&self, chain_id: ChainId, block: BlockInfo) -> bool {
+        self.get(chain_id).map(|cfg| cfg.is_interop_activation_block(block)).unwrap_or(false)
+    }
 }
 
 #[cfg(test)]
@@ -152,4 +178,14 @@
         // Unknown chain_id returns false
         assert!(!set.is_interop_enabled(ChainId::from(999u64), 200));
     }
+
+    #[test]
+    fn test_rollup_config_is_interop_interop_time_zero() {
+        // Interop time is 100, block_time is 10
+        let rollup_config =
+            RollupConfig::new(Genesis::new(dummy_blockinfo(0), dummy_blockinfo(0)), 2, Some(0));
+
+        assert!(rollup_config.is_interop(0));
+        assert!(rollup_config.is_interop(1000));
+    }
 }

crates/supervisor/core/src/logindexer/indexer.rs

@@ -272,7 +272,7 @@ mod tests {
         let mut mock_provider = MockBlockProvider::new();
         mock_provider.expect_fetch_receipts().withf(move |hash| *hash == block_hash).returning(
             |_| {
-                Err(ManagedNodeError::Client(ClientError::Authentication(
+                Err(ManagedNodeError::ClientError(ClientError::Authentication(
                     AuthenticationError::InvalidHeader,
                 )))
             },

crates/supervisor/core/src/safety_checker/task.rs

@@ -6,7 +6,7 @@
 use alloy_primitives::ChainId;
 use derive_more::Constructor;
 use kona_protocol::BlockInfo;
-use kona_supervisor_storage::CrossChainSafetyProvider;
+use kona_supervisor_storage::{CrossChainSafetyProvider, StorageError};
 use std::{sync::Arc, time::Duration};
 use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
@@ -114,10 +114,27 @@
 
     // Finds the next block that is eligible for promotion at the configured target level.
     fn find_next_promotable_block(&self) -> Result<BlockInfo, CrossSafetyError> {
-        let current_head =
-            self.provider.get_safety_head_ref(self.chain_id, self.promoter.target_level())?;
-        let upper_head =
-            self.provider.get_safety_head_ref(self.chain_id, self.promoter.lower_bound_level())?;
+        let current_head = self
+            .provider
+            .get_safety_head_ref(self.chain_id, self.promoter.target_level())
+            .map_err(|err| {
+                if matches!(err, StorageError::FutureData) {
+                    CrossSafetyError::NoBlockToPromote
+                } else {
+                    err.into()
+                }
+            })?;
+
+        let upper_head = self
+            .provider
+            .get_safety_head_ref(self.chain_id, self.promoter.lower_bound_level())
+            .map_err(|err| {
+                if matches!(err, StorageError::FutureData) {
+                    CrossSafetyError::NoBlockToPromote
+                } else {
+                    err.into()
+                }
+            })?;
 
         if current_head.number >= upper_head.number {
             return Err(CrossSafetyError::NoBlockToPromote);

crates/supervisor/core/src/supervisor.rs

@@ -143,9 +143,13 @@
         for (chain_id, config) in self.config.rollup_config_set.rollups.iter() {
             // Initialise the database for each chain.
             let db = self.database_factory.get_or_create_db(*chain_id)?;
-            let anchor = config.genesis.get_anchor();
-            db.initialise_log_storage(anchor.derived)?;
-            db.initialise_derivation_storage(anchor)?;
+            let interop_time = config.interop_time;
+            let derived_pair = config.genesis.get_derived_pair();
+            if config.is_interop(derived_pair.derived.timestamp) {
+                info!(target: "supervisor_service", chain_id, interop_time, %derived_pair, "Initialising database for interop activation block");
+                db.initialise_log_storage(derived_pair.derived)?;
+                db.initialise_derivation_storage(derived_pair)?;
+            }
             info!(target: "supervisor_service", chain_id, "Database initialized successfully");
         }
         Ok(())

crates/supervisor/core/src/syncnode/client.rs

@@ -42,6 +42,9 @@
     /// Fetches the [`BlockInfo`] by block number.
     async fn block_ref_by_number(&self, block_number: u64) -> Result<BlockInfo, ClientError>;
 
+    /// Resets the managed node to the pre-interop state.
+    async fn reset_pre_interop(&self) -> Result<(), ClientError>;
+
     /// Resets the node state with the provided block IDs.
     async fn reset(
         &self,
@@ -302,14 +305,29 @@
             Metrics::MANAGED_NODE_RPC_REQUEST_DURATION_SECONDS,
             "block_ref_by_number",
             async {
-              ManagedModeApiClient::block_ref_by_number(client.as_ref(), block_number).await
+              ManagedModeApiClient::l2_block_ref_by_number(client.as_ref(), block_number).await
             },
             "node" => self.config.url.clone()
         )?;
 
         Ok(block_info)
     }
 
+    async fn reset_pre_interop(&self) -> Result<(), ClientError> {
+        let client = self.get_ws_client().await?;
+        observe_metrics_for_result_async!(
+            Metrics::MANAGED_NODE_RPC_REQUESTS_SUCCESS_TOTAL,
+            Metrics::MANAGED_NODE_RPC_REQUESTS_ERROR_TOTAL,
+            Metrics::MANAGED_NODE_RPC_REQUEST_DURATION_SECONDS,
+            "reset_pre_interop",
+            async {
+              ManagedModeApiClient::reset_pre_interop(client.as_ref()).await
+            },
+            "node" => self.config.url.clone()
+        )?;
+        Ok(())
+    }
+
     async fn reset(
         &self,
         unsafe_id: BlockNumHash,

crates/supervisor/core/src/syncnode/error.rs

@@ -7,7 +7,7 @@ use thiserror::Error;
 pub enum ManagedNodeError {
     /// Represents an error that occurred while starting the managed node.
     #[error(transparent)]
-    Client(#[from] ClientError),
+    ClientError(#[from] ClientError),
 
     /// Represents an error that occurred while subscribing to the managed node.
     #[error("subscription error: {0}")]

crates/supervisor/core/src/syncnode/resetter.rs

@@ -1,6 +1,6 @@
 use super::{ManagedNodeClient, ManagedNodeError};
 use alloy_eips::BlockNumHash;
-use kona_supervisor_storage::{DerivationStorageReader, HeadRefStorageReader};
+use kona_supervisor_storage::{DerivationStorageReader, HeadRefStorageReader, StorageError};
 use kona_supervisor_types::SuperHead;
 use std::sync::Arc;
 use tokio::sync::Mutex;
@@ -32,6 +32,11 @@
         let SuperHead { local_unsafe, cross_unsafe, local_safe, cross_safe, finalized, .. } =
             match self.get_latest_valid_super_head().await {
                 Ok(block) => block,
+                // todo: require refactor and corner case handling
+                Err(ManagedNodeError::StorageError(StorageError::DatabaseNotInitialised)) => {
+                    self.reset_pre_interop().await?;
+                    return Ok(());
+                }
                 Err(err) => {
                     error!(target: "resetter", %err, "Failed to get latest valid derived block");
                     return Err(ManagedNodeError::ResetFailed);
@@ -59,7 +64,15 @@
             .inspect_err(|err| {
                 error!(target: "resetter", %err, "Failed to reset managed node");
             })?;
+        Ok(())
+    }
+
+    async fn reset_pre_interop(&self) -> Result<(), ManagedNodeError> {
+        info!(target: "resetter", "Resetting the node to pre-interop state");
 
+        self.client.reset_pre_interop().await.inspect_err(|err| {
+            error!(target: "resetter", %err, "Failed to reset managed node to pre-interop state");
+        })?;
         Ok(())
     }
 
@@ -174,6 +187,7 @@
             async fn pending_output_v0_at_timestamp(&self, timestamp: u64) -> Result<OutputV0, ClientError>;
             async fn l2_block_ref_by_timestamp(&self, timestamp: u64) -> Result<BlockInfo, ClientError>;
             async fn block_ref_by_number(&self, block_number: u64) -> Result<BlockInfo, ClientError>;
+            async fn reset_pre_interop(&self) -> Result<(), ClientError>;
             async fn reset(&self, unsafe_id: BlockNumHash, cross_unsafe_id: BlockNumHash, local_safe_id: BlockNumHash, cross_safe_id: BlockNumHash, finalised_id: BlockNumHash) -> Result<(), ClientError>;
             async fn provide_l1(&self, block_info: BlockInfo) -> Result<(), ClientError>;
             async fn update_finalized(&self, finalized_block_id: BlockNumHash) -> Result<(), ClientError>;
@@ -214,7 +228,7 @@
     #[tokio::test]
     async fn test_reset_db_error() {
         let mut db = MockDb::new();
-        db.expect_get_super_head().returning(|| Err(StorageError::DatabaseNotInitialised));
+        db.expect_get_super_head().returning(|| Err(StorageError::LockPoisoned));
 
         let client = MockClient::new();
 

crates/supervisor/core/src/syncnode/task.rs

@@ -295,6 +295,7 @@ mod tests {
             async fn pending_output_v0_at_timestamp(&self, timestamp: u64) -> Result<OutputV0, ClientError>;
             async fn l2_block_ref_by_timestamp(&self, timestamp: u64) -> Result<BlockInfo, ClientError>;
             async fn block_ref_by_number(&self, block_number: u64) -> Result<BlockInfo, ClientError>;
+            async fn reset_pre_interop(&self) -> Result<(), ClientError>;
             async fn reset(&self, unsafe_id: BlockNumHash, cross_unsafe_id: BlockNumHash, local_safe_id: BlockNumHash, cross_safe_id: BlockNumHash, finalised_id: BlockNumHash) -> Result<(), ClientError>;
             async fn provide_l1(&self, block_info: BlockInfo) -> Result<(), ClientError>;
             async fn update_finalized(&self, finalized_block_id: BlockNumHash) -> Result<(), ClientError>;

crates/supervisor/rpc/src/jsonrpsee.rs

@@ -172,6 +172,10 @@ pub trait ManagedModeApi {
     #[method(name = "anchorPoint")]
     async fn anchor_point(&self) -> RpcResult<DerivedRefPair>;
 
+    /// Reset the managed node to the pre-interop state
+    #[method(name = "resetPreInterop")]
+    async fn reset_pre_interop(&self) -> RpcResult<()>;
+
     /// Reset the managed node to the specified block heads
     #[method(name = "reset")]
     async fn reset(
@@ -189,8 +193,8 @@ pub trait ManagedModeApi {
     async fn fetch_receipts(&self, block_hash: BlockHash) -> RpcResult<Receipts>;
 
     /// Get block infor for a given block number
-    #[method(name = "blockRefByNumber")]
-    async fn block_ref_by_number(&self, number: u64) -> RpcResult<BlockInfo>;
+    #[method(name = "l2BlockRefByNumber")]
+    async fn l2_block_ref_by_number(&self, number: u64) -> RpcResult<BlockInfo>;
 
     /// Get the chain id
     #[method(name = "chainID")]

crates/supervisor/storage/src/providers/head_ref_provider.rs

@@ -33,10 +33,7 @@ where
                 "Failed to seek head reference"
             );
         })?;
-        let block_ref = result.ok_or_else(|| {
-            warn!(target: "supervisor_storage", %safety_level, "No head reference found");
-            StorageError::EntryNotFound("no head reference found".to_string())
-        })?;
+        let block_ref = result.ok_or_else(|| StorageError::FutureData)?;
         Ok(block_ref.into())
     }
 }

tests/devnets/simple-supervisor.yaml

@@ -9,7 +9,7 @@ optimism_package:
             type: op-geth
           cl:
             type: op-node
-            image: us-docker.pkg.dev/oplabs-tools-artifacts/images/op-node:v1.13.3
+            image: us-docker.pkg.dev/oplabs-tools-artifacts/images/op-node:develop
             log_level: debug
       network_params:
         network: "kurtosis"
@@ -32,7 +32,7 @@ optimism_package:
             type: op-geth
           cl:
             type: op-node
-            image: us-docker.pkg.dev/oplabs-tools-artifacts/images/op-node:v1.13.3
+            image: us-docker.pkg.dev/oplabs-tools-artifacts/images/op-node:develop
             log_level: debug
       network_params:
         network: "kurtosis"