test (supervisor/rpc): supervisor_finalizedL1 and supervisor_superRootAtTimestamp

crates/supervisor/core/src/rpc/server.rs

@@ -5,12 +5,12 @@
 use alloy_primitives::{B256, ChainId, map::HashMap};
 use async_trait::async_trait;
 use jsonrpsee::{core::RpcResult, types::ErrorObject};
-use kona_interop::{
-    DependencySet, DerivedIdPair, ExecutingDescriptor, SafetyLevel, SuperRootOutput,
-};
+use kona_interop::{DependencySet, DerivedIdPair, ExecutingDescriptor, SafetyLevel};
 use kona_protocol::BlockInfo;
-use kona_supervisor_rpc::{SupervisorApiServer, SupervisorChainSyncStatus, SupervisorSyncStatus};
-use kona_supervisor_types::{HexChainId, SuperHead};
+use kona_supervisor_rpc::{
+    SuperRootOutputRpc, SupervisorApiServer, SupervisorChainSyncStatus, SupervisorSyncStatus,
+};
+use kona_supervisor_types::{HexStringU64, SuperHead};
 use std::sync::Arc;
 use tracing::{trace, warn};
 
@@ -39,7 +39,7 @@
 {
     async fn cross_derived_to_source(
         &self,
-        chain_id_hex: HexChainId,
+        chain_id_hex: HexStringU64,
         derived: BlockNumHash,
     ) -> RpcResult<BlockInfo> {
         let chain_id = ChainId::from(chain_id_hex);
@@ -71,7 +71,7 @@
         )
     }
 
-    async fn local_unsafe(&self, chain_id_hex: HexChainId) -> RpcResult<BlockNumHash> {
+    async fn local_unsafe(&self, chain_id_hex: HexStringU64) -> RpcResult<BlockNumHash> {
         let chain_id = ChainId::from(chain_id_hex);
         crate::observe_rpc_call!(
             "local_unsafe",
@@ -101,7 +101,7 @@
         )
     }
 
-    async fn cross_safe(&self, chain_id_hex: HexChainId) -> RpcResult<DerivedIdPair> {
+    async fn cross_safe(&self, chain_id_hex: HexStringU64) -> RpcResult<DerivedIdPair> {
         let chain_id = ChainId::from(chain_id_hex);
         crate::observe_rpc_call!(
             "cross_safe",
@@ -120,7 +120,7 @@
         )
     }
 
-    async fn finalized(&self, chain_id_hex: HexChainId) -> RpcResult<BlockNumHash> {
+    async fn finalized(&self, chain_id_hex: HexStringU64) -> RpcResult<BlockNumHash> {
         let chain_id = ChainId::from(chain_id_hex);
         crate::observe_rpc_call!(
             "finalized",
@@ -147,22 +147,27 @@
         )
     }
 
-    async fn super_root_at_timestamp(&self, timestamp: u64) -> RpcResult<SuperRootOutput> {
+    async fn super_root_at_timestamp(
+        &self,
+        timestamp_hex: HexStringU64,
+    ) -> RpcResult<SuperRootOutputRpc> {
         crate::observe_rpc_call!(
             "super_root_at_timestamp",
             async {
-            trace!(target: "supervisor_rpc",
-                %timestamp,
-                "Received super_root_at_timestamp request"
-            );
-
-            self.supervisor.super_root_at_timestamp(timestamp)
-                .await
-                .map_err(|err| {
-                    warn!(target: "supervisor_rpc", %err, "Error from core supervisor super_root_at_timestamp");
-                    ErrorObject::from(err)
-                })
-        }.await)
+                let timestamp = u64::from(timestamp_hex);
+                trace!(target: "supervisor_rpc",
+                    %timestamp,
+                    "Received super_root_at_timestamp request"
+                );
+
+                self.supervisor.super_root_at_timestamp(timestamp)
+                    .await
+                    .map_err(|err| {
+                        warn!(target: "supervisor_rpc", %err, "Error from core supervisor super_root_at_timestamp");
+                        ErrorObject::from(err)
+                    })
+            }.await
+        )
     }
 
     async fn check_access_list(
@@ -175,19 +180,20 @@
         crate::observe_rpc_call!(
             "check_access_list", 
             async {
-            trace!(target: "supervisor_rpc", 
-                num_inbox_entries = inbox_entries.len(),
-                ?min_safety,
-                ?executing_descriptor,
-                "Received check_access_list request",
-            );
-            self.supervisor
-                .check_access_list(inbox_entries, min_safety, executing_descriptor)
-                .map_err(|err| {
-                    warn!(target: "supervisor_rpc", %err, "Error from core supervisor check_access_list");
-                    ErrorObject::from(err)
-                })
-        }.await)
+                trace!(target: "supervisor_rpc", 
+                    num_inbox_entries = inbox_entries.len(),
+                    ?min_safety,
+                    ?executing_descriptor,
+                    "Received check_access_list request",
+                );
+                self.supervisor
+                    .check_access_list(inbox_entries, min_safety, executing_descriptor)
+                    .map_err(|err| {
+                        warn!(target: "supervisor_rpc", %err, "Error from core supervisor check_access_list");
+                        ErrorObject::from(err)
+                    })
+            }.await
+        )
     }
 
     async fn sync_status(&self) -> RpcResult<SupervisorSyncStatus> {
@@ -361,7 +367,7 @@
         async fn super_root_at_timestamp(
             &self,
             _timestamp: u64,
-        ) -> Result<SuperRootOutput, SupervisorError> {
+        ) -> Result<SuperRootOutputRpc, SupervisorError> {
             unimplemented!()
         }
     }

crates/supervisor/core/src/supervisor.rs

@@ -6,10 +6,11 @@
 use async_trait::async_trait;
 use core::fmt::Debug;
 use kona_interop::{
-    ChainRootInfo, DependencySet, ExecutingDescriptor, OutputRootWithChain, SUPER_ROOT_VERSION,
-    SafetyLevel, SuperRoot, SuperRootOutput,
+    DependencySet, ExecutingDescriptor, OutputRootWithChain, SUPER_ROOT_VERSION, SafetyLevel,
+    SuperRoot,
 };
 use kona_protocol::BlockInfo;
+use kona_supervisor_rpc::{ChainRootInfoRpc, SuperRootOutputRpc};
 use kona_supervisor_storage::{
     ChainDb, ChainDbFactory, DerivationStorageReader, DerivationStorageWriter, FinalizedL1Storage,
     HeadRefStorageReader, LogStorageReader, LogStorageWriter,
@@ -86,7 +87,7 @@
     async fn super_root_at_timestamp(
         &self,
         timestamp: u64,
-    ) -> Result<SuperRootOutput, SupervisorError>;
+    ) -> Result<SuperRootOutputRpc, SupervisorError>;
 
     /// Verifies if an access-list references only valid messages
     fn check_access_list(
@@ -393,12 +394,12 @@
     async fn super_root_at_timestamp(
         &self,
         timestamp: u64,
-    ) -> Result<SuperRootOutput, SupervisorError> {
+    ) -> Result<SuperRootOutputRpc, SupervisorError> {
         let mut chain_ids = self.config.dependency_set.dependencies.keys().collect::<Vec<_>>();
         // Sorting chain ids for deterministic super root hash
         chain_ids.sort();
 
-        let mut chain_infos = Vec::<ChainRootInfo>::with_capacity(chain_ids.len());
+        let mut chain_infos = Vec::<ChainRootInfoRpc>::with_capacity(chain_ids.len());
         let mut super_root_chains = Vec::<OutputRootWithChain>::with_capacity(chain_ids.len());
         let mut cross_safe_source = BlockNumHash::default();
 
@@ -413,7 +414,7 @@
                 serde_json::to_string(&pending_output_v0).unwrap().as_bytes(),
             );
 
-            chain_infos.push(ChainRootInfo {
+            chain_infos.push(ChainRootInfoRpc {
                 chain_id: *id,
                 canonical: canonical_root,
                 pending: pending_output_v0_bytes,
@@ -424,11 +425,9 @@
 
             let l2_block = managed_node.l2_block_ref_by_timestamp(timestamp).await?;
             let source = self
-                .get_db(*id)?
-                .derived_to_source(l2_block.id())
-                .map_err(|err| {
+                .derived_to_source_block(*id, l2_block.id())
+                .inspect_err(|err| {
                     error!(target: "supervisor_service", %id, %err, "Failed to get derived to source block for chain");
-                    SpecError::from(err)
                 })?;
 
             if cross_safe_source.number == 0 || cross_safe_source.number < source.number {
@@ -437,10 +436,9 @@
         }
 
         let super_root = SuperRoot { timestamp, output_roots: super_root_chains };
-
         let super_root_hash = super_root.hash();
 
-        Ok(SuperRootOutput {
+        Ok(SuperRootOutputRpc {
             cross_safe_derived_from: cross_safe_source,
             timestamp,
             super_root: super_root_hash,

crates/supervisor/rpc/Cargo.toml

@@ -23,16 +23,15 @@ kona-supervisor-types.workspace = true
 
 # jsonrpsee
 serde.workspace = true
+serde_json.workspace = true
 jsonrpsee = { workspace = true, optional = true, features = ["macros", "server"] }
 
 # Alloy
 alloy-eips.workspace = true
+alloy-serde.workspace = true
 alloy-primitives = { workspace = true, features = ["map", "rlp", "serde"] }
 op-alloy-consensus.workspace = true
 
-#[dev-dependencies]
-serde_json.workspace = true
-
 [features]
 serde = [
 	"alloy-eips/serde",

crates/supervisor/rpc/src/jsonrpsee.rs

@@ -5,16 +5,15 @@ pub use jsonrpsee::{
     types::{ErrorCode, ErrorObjectOwned},
 };
 
-use crate::SupervisorSyncStatus;
+use crate::{SuperRootOutputRpc, SupervisorSyncStatus};
 use alloy_eips::BlockNumHash;
 use alloy_primitives::{B256, BlockHash, ChainId, map::HashMap};
 use jsonrpsee::proc_macros::rpc;
 use kona_interop::{
     DependencySet, DerivedIdPair, DerivedRefPair, ExecutingDescriptor, ManagedEvent, SafetyLevel,
-    SuperRootOutput,
 };
 use kona_protocol::BlockInfo;
-use kona_supervisor_types::{BlockSeal, HexChainId, OutputV0, Receipts, SubscriptionEvent};
+use kona_supervisor_types::{BlockSeal, HexStringU64, OutputV0, Receipts, SubscriptionEvent};
 use serde::{Deserialize, Serialize};
 
 /// Supervisor API for interop.
@@ -28,7 +27,7 @@ pub trait SupervisorApi {
     #[method(name = "crossDerivedToSource")]
     async fn cross_derived_to_source(
         &self,
-        chain_id: HexChainId,
+        chain_id: HexStringU64,
         block_id: BlockNumHash,
     ) -> RpcResult<BlockInfo>;
 
@@ -38,23 +37,23 @@ pub trait SupervisorApi {
     ///
     /// [`LocalUnsafe`]: SafetyLevel::LocalUnsafe
     #[method(name = "localUnsafe")]
-    async fn local_unsafe(&self, chain_id: HexChainId) -> RpcResult<BlockNumHash>;
+    async fn local_unsafe(&self, chain_id: HexStringU64) -> RpcResult<BlockNumHash>;
 
     /// Returns the [`CrossSafe`] block for given chain.
     ///
     /// Spec: <https://github.com/ethereum-optimism/specs/blob/main/specs/interop/supervisor.md#supervisor_crosssafe>
     ///
     /// [`CrossSafe`]: SafetyLevel::CrossSafe
     #[method(name = "crossSafe")]
-    async fn cross_safe(&self, chain_id: HexChainId) -> RpcResult<DerivedIdPair>;
+    async fn cross_safe(&self, chain_id: HexStringU64) -> RpcResult<DerivedIdPair>;
 
     /// Returns the [`Finalized`] block for the given chain.
     ///
     /// Spec: <https://github.com/ethereum-optimism/specs/blob/main/specs/interop/supervisor.md#supervisor_finalized>
     ///
     /// [`Finalized`]: SafetyLevel::Finalized
     #[method(name = "finalized")]
-    async fn finalized(&self, chain_id: HexChainId) -> RpcResult<BlockNumHash>;
+    async fn finalized(&self, chain_id: HexStringU64) -> RpcResult<BlockNumHash>;
 
     /// Returns the finalized L1 block that the supervisor is synced to.
     ///
@@ -75,7 +74,10 @@ pub trait SupervisorApi {
     /// [`SuperRoot`]: kona_interop::SuperRoot
     /// [`ChainRootInfo`]: kona_interop::ChainRootInfo
     #[method(name = "superRootAtTimestamp")]
-    async fn super_root_at_timestamp(&self, timestamp: u64) -> RpcResult<SuperRootOutput>;
+    async fn super_root_at_timestamp(
+        &self,
+        timestamp: HexStringU64,
+    ) -> RpcResult<SuperRootOutputRpc>;
 
     /// Verifies if an access-list references only valid messages w.r.t. locally configured minimum
     /// [`SafetyLevel`].

crates/supervisor/rpc/src/lib.rs

@@ -11,6 +11,8 @@ pub use jsonrpsee::SupervisorApiServer;
 pub use jsonrpsee::ManagedModeApiClient;
 
 pub mod response;
-pub use response::{SupervisorChainSyncStatus, SupervisorSyncStatus};
+pub use response::{
+    ChainRootInfoRpc, SuperRootOutputRpc, SupervisorChainSyncStatus, SupervisorSyncStatus,
+};
 
 pub use kona_protocol::BlockInfo;