add inspector

Author: Naohiro Yoshida

Makefile

@@ -61,11 +61,9 @@ test:
 	L2_GETH_PORT=$$(jq -r '.l2GethPort' hostPort.json);\
 	L2_ROLLUP_ADDR=http://localhost:$$L2_ROLLUP_PORT L2_GETH_ADDR=http://localhost:$$L2_GETH_PORT cargo test --manifest-path=./server/Cargo.toml
 
-.PHONY: test-ignored
-test-ignored:
-	@L2_ROLLUP_PORT=$$(jq -r '.l2RollupPort' hostPort.json);\
-	L2_GETH_PORT=$$(jq -r '.l2GethPort' hostPort.json);\
-	REQUEST_PATH=$(CURDIR)/tool/body.json L2_ROLLUP_PORT=$$L2_ROLLUP_PORT L2_GETH_PORT=$$L2_GETH_PORT cargo test --manifest-path=./server/Cargo.toml -- --ignored
+.PHONY: inspect
+inspect:
+	cargo test --manifest-path=./server/Cargo.toml -- --ignored
 
 .PHONY: devnet-down
 devnet-down:

server/src/client/beacon_client.rs

@@ -61,7 +61,7 @@ where
             E: serde::de::Error,
         {
             v.parse::<u64>()
-                .map_err(|e| E::custom(format!("invalid u64 string: {}", e)))
+                .map_err(|e| E::custom(format!("invalid u64 string: {e}")))
         }
 
         fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
@@ -83,7 +83,7 @@ impl BeaconClient {
     pub async fn get_raw_light_client_finality_update(&self) -> anyhow::Result<String> {
         let client = reqwest::Client::new();
         let response = client
-            .get(&format!(
+            .get(format!(
                 "{}/eth/v1/beacon/light_client/finality_update",
                 self.beacon_addr
             ))
@@ -93,7 +93,7 @@ impl BeaconClient {
         response
             .text()
             .await
-            .map_err(|e| anyhow::anyhow!("Failed to get finality update: {:?}", e))
+            .map_err(|e| anyhow::anyhow!("Failed to get finality update: {e:?}"))
     }
 
     async fn check_response(&self, response: Response) -> anyhow::Result<Response> {

server/src/collector.rs

@@ -116,10 +116,7 @@ impl<T: PreimageRepository, F: FinalizedL1Repository> PreimageCollector<T, F> {
         }
 
         for batch in batches {
-            match self
-                .parallel_collect(l1_head_hash.clone(), batch.to_vec())
-                .await
-            {
+            match self.parallel_collect(l1_head_hash, batch.to_vec()).await {
                 Ok(end) => latest_l2 = end.unwrap_or(latest_l2),
                 Err(e) => {
                     error!(

server/src/data/file_finalized_l1_repository.rs

@@ -20,7 +20,7 @@ impl FileFinalizedL1Repository {
     }
 
     fn path(&self, l1_head_hash: &B256) -> String {
-        format!("{}/{}.json", self.dir, l1_head_hash.to_string())
+        format!("{}/{}.json", self.dir, l1_head_hash)
     }
 
     async fn entries(dir: &str) -> anyhow::Result<Vec<DirEntry>> {

server/tests/e2e.rs

@@ -1,3 +1,5 @@
+//! These tests are required to run the preimage server.
+
 use optimism_derivation::derivation::Derivation;
 use optimism_derivation::oracle::MemoryOracleClient;
 use optimism_derivation::types::Preimages;
@@ -9,22 +11,19 @@ use optimism_preimage_maker::web::{
 };
 use prost::Message;
 use std::env;
-use tracing::metadata;
 use tracing_subscriber::filter;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
-/// These tests are required to run the preimage server.
-
-fn init() {
+pub fn init() {
     let filter = filter::EnvFilter::from_default_env().add_directive("info".parse().unwrap());
     let _ = tracing_subscriber::registry()
         .with(tracing_subscriber::fmt::layer())
         .with(filter)
         .try_init();
 }
 
-fn get_l2_client() -> L2Client {
+pub fn get_l2_client() -> L2Client {
     let op_node_addr = env::var("L2_ROLLUP_ADDR").unwrap();
     let op_geth_addr = env::var("L2_GETH_ADDR").unwrap();
     tracing::info!(
@@ -62,7 +61,7 @@ pub async fn test_derivation_success() {
         .json()
         .await
         .unwrap();
-    assert!(metadata_list.len() > 0, "No metadata found");
+    assert!(!metadata_list.is_empty(), "No metadata found");
 
     for metadata in metadata_list {
         assert!(metadata.claimed > 100);

server/tests/inspect.rs

@@ -0,0 +1,102 @@
+use optimism_preimage_maker::derivation::host::single::config::Config;
+use optimism_preimage_maker::derivation::host::single::handler::{
+    Derivation, DerivationConfig, DerivationRequest,
+};
+use serde_json::Value;
+use serial_test::serial;
+use std::env;
+use std::sync::Arc;
+use tracing::info;
+
+mod e2e;
+use e2e::get_l2_client;
+use e2e::init;
+use optimism_preimage_maker::client::l2_client::{Block, RpcResult};
+
+#[derive(Debug, Clone, serde::Serialize, Default)]
+struct RpcRequest {
+    jsonrpc: String,
+    method: String,
+    params: Vec<Value>,
+    id: i64,
+}
+
+async fn get_block_by_number(number: u64, l1_geth_addr: &str) -> anyhow::Result<Block> {
+    let client = reqwest::Client::new();
+    let body = RpcRequest {
+        method: "eth_getBlockByNumber".into(),
+        params: vec![format!("0x{number:X}").into(), false.into()],
+        ..Default::default()
+    };
+    let response = client
+        .post(l1_geth_addr)
+        .header("Content-Type", "application/json")
+        .json(&body)
+        .send()
+        .await?;
+    let result: RpcResult<Block> = response.json().await?;
+    Ok(result.result)
+}
+
+/*
+ex)
+export L2_ROLLUP_ADDR=http://localhost:9545
+export L2_GETH_ADDR=http://localhost:8546
+export L1_GETH_ADDR=http://localhost:8545
+export L1_BEACON_ADDR=http://localhost:9596
+export CLAIMED=104
+export AGREED=103
+*/
+#[serial]
+#[tokio::test(flavor = "multi_thread")]
+#[ignore]
+async fn test_derivation() {
+    init();
+    let claimed: u64 = env::var("CLAIMED").unwrap().parse().unwrap();
+    let agreed: u64 = env::var("AGREED").unwrap().parse().unwrap();
+    let l2_client = get_l2_client();
+    let chain_id = l2_client.chain_id().await.unwrap();
+
+    let op_geth_addr = env::var("L2__ADDR").unwrap();
+    let op_node_addr = env::var("L2_ROLLUP_ADDR").unwrap();
+    let l1_geth_addr = env::var("L1_GETH_ADDR").unwrap();
+    let l1_beacon_addr = env::var("L1_BEACON_ADDR").unwrap();
+
+    let claimed_output = l2_client.output_root_at(claimed).await.unwrap();
+    let agreed_output = l2_client.output_root_at(agreed).await.unwrap();
+    let l1_hash = get_block_by_number(
+        claimed_output.block_ref.l1_origin.number + 100,
+        &l1_geth_addr,
+    )
+    .await
+    .unwrap()
+    .hash;
+    let request = DerivationRequest {
+        l1_head_hash: l1_hash,
+        agreed_l2_head_hash: agreed_output.block_ref.hash,
+        agreed_l2_output_root: agreed_output.output_root,
+        l2_output_root: claimed_output.output_root,
+        l2_block_number: claimed,
+    };
+
+    let config = Arc::new(DerivationConfig {
+        config: Config {
+            l2_node_address: op_geth_addr.to_string(),
+            l1_node_address: l1_geth_addr.to_string(),
+            l1_beacon_address: l1_beacon_addr.to_string(),
+            l2_rollup_address: op_node_addr.to_string(),
+            ..Default::default()
+        },
+        rollup_config: None,
+        l2_chain_id: chain_id,
+        l1_chain_config: None,
+    });
+
+    info!("derivation start : {:?}", &request);
+    let derivation = Derivation { config, request };
+    let result = derivation.start().await;
+    match result {
+        Ok(_) => info!("derivation success"),
+        Err(e) => panic!("derivation failed: {e:?}"),
+    }
+}