perf(l2): add prover benchmarks from RPC downloaded blocks

Cargo.toml

@@ -18,6 +18,7 @@ members = [
     "crates/vm/levm/bench/revm_comparison",
     "crates/l2/",
     "crates/l2/prover",
+    "crates/l2/prover/bench",
     "crates/l2/contracts",
     "crates/l2/sdk",
     "cmd/loc",

crates/l2/proposer/prover_server.rs

@@ -19,7 +19,11 @@ use ethrex_l2_sdk::{
     eth_client::{eth_sender::Overrides, EthClient, WrappedTransaction},
 };
 use ethrex_storage::Store;
-use ethrex_vm::{execution_db::ExecutionDB, EvmError};
+use ethrex_vm::{
+    db::StoreWrapper,
+    execution_db::{ExecutionDB, ToExecDB},
+    EvmError,
+};
 use secp256k1::SecretKey;
 use serde::{Deserialize, Serialize};
 use std::{
@@ -405,12 +409,16 @@ impl ProverServer {
 
         let block = Block::new(header, body);
 
-        let db =
-            ExecutionDB::from_store(&block, self.store.clone()).map_err(EvmError::ExecutionDB)?;
+        let parent_hash = block.header.parent_hash;
+        let store = StoreWrapper {
+            store: self.store.clone(),
+            block_hash: parent_hash,
+        };
+        let db = store.to_exec_db(&block).map_err(EvmError::ExecutionDB)?;
 
         let parent_block_header = self
             .store
-            .get_block_header_by_hash(block.header.parent_hash)?
+            .get_block_header_by_hash(parent_hash)?
             .ok_or(ProverServerError::StorageDataIsNone)?;
 
         debug!("Created prover input for block {block_number}");

crates/l2/prover/bench/Cargo.toml

@@ -0,0 +1,53 @@
+[package]
+name = "bench"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ethrex-core.workspace = true
+ethrex-rlp.workspace = true
+ethrex-vm.workspace = true
+ethrex-prover.workspace = true
+ethrex-l2.workspace = true
+ethrex-trie.workspace = true
+ethrex-storage.workspace = true
+
+zkvm_interface = { path = "../zkvm/interface", default-features = false }
+
+serde.workspace = true
+hex.workspace = true
+serde_json.workspace = true
+bytes.workspace = true
+
+tokio = { version = "1.21", default-features = false, features = ["full"] }
+reqwest = { version = "0.12.9", features = [
+  "json",
+  "rustls-tls",
+], default-features = false }
+clap = { version = "4.5.21", features = ["derive"] }
+
+revm = { version = "14.0.3", features = [
+  "serde",
+  "std",
+  "serde-json",
+  "optional_no_base_fee",
+  "optional_block_gas_limit",
+], default-features = false }
+
+# These dependencies must be kept up to date with the corresponding revm version, otherwise errors may pop up because of trait implementation mismatches
+revm-inspectors = { version = "0.8.1" }
+revm-primitives = { version = "10.0.0", features = [
+  "std",
+], default-features = false }
+futures-util = "0.3.31"
+tokio-utils = "0.1.2"
+again = "0.1.2"
+lazy_static = "1.5.0"
+bincode = "1.3.3"
+
+[features]
+## risc0
+build_risc0 = ["zkvm_interface/build_risc0", "ethrex-prover/build_risc0"]
+gpu = ["ethrex-prover/gpu"]
+## sp1
+build_sp1 = ["zkvm_interface/build_sp1", "zkvm_interface/build_risc0"]

crates/l2/prover/bench/src/constants.rs

@@ -0,0 +1,39 @@
+// Blockchain related constants
+
+use std::time::Duration;
+
+use ethrex_core::types::ChainConfig;
+use revm_primitives::SpecId;
+
+// Chain config for different forks as defined on https://ethereum.github.io/execution-spec-tests/v3.0.0/consuming_tests/common_types/#fork
+pub static CANCUN_CONFIG: ChainConfig = ChainConfig {
+    chain_id: 1_u64,
+    homestead_block: Some(0),
+    dao_fork_block: Some(0),
+    dao_fork_support: true,
+    eip150_block: Some(0),
+    eip155_block: Some(0),
+    eip158_block: Some(0),
+    byzantium_block: Some(0),
+    constantinople_block: Some(0),
+    petersburg_block: Some(0),
+    istanbul_block: Some(0),
+    muir_glacier_block: Some(0),
+    berlin_block: Some(0),
+    london_block: Some(0),
+    arrow_glacier_block: Some(0),
+    gray_glacier_block: Some(0),
+    merge_netsplit_block: Some(0),
+    terminal_total_difficulty: Some(0),
+    shanghai_time: Some(0),
+    cancun_time: Some(0),
+    prague_time: None,
+    terminal_total_difficulty_passed: false,
+    verkle_time: None,
+};
+pub const MAINNET_CHAIN_ID: u64 = 0x1;
+pub const MAINNET_SPEC_ID: SpecId = SpecId::CANCUN;
+
+// RPC related constants
+
+pub const RPC_RATE_LIMIT: usize = 100; // requests per second

crates/l2/prover/bench/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod constants;
+pub mod rpc;

crates/l2/prover/bench/src/main.rs

@@ -0,0 +1,85 @@
+use std::{fs::File, io::Write};
+
+use bench::{
+    constants::{CANCUN_CONFIG, MAINNET_CHAIN_ID},
+    rpc::{db::RpcDB, get_block, get_latest_block_number},
+};
+use clap::Parser;
+use ethrex_l2::utils::prover::proving_systems::ProverType;
+use ethrex_prover_lib::prover::create_prover;
+use ethrex_vm::execution_db::ToExecDB;
+use zkvm_interface::io::ProgramInput;
+
+#[derive(Parser, Debug)]
+struct Args {
+    #[arg(short, long)]
+    rpc_url: String,
+    #[arg(short, long)]
+    block_number: Option<usize>,
+}
+
+#[tokio::main]
+async fn main() {
+    let Args {
+        rpc_url,
+        block_number,
+    } = Args::parse();
+
+    let block_number = match block_number {
+        Some(n) => n,
+        None => {
+            println!("fetching latest block number");
+            get_latest_block_number(&rpc_url)
+                .await
+                .expect("failed to fetch latest block number")
+        }
+    };
+
+    println!("fetching block {block_number} and its parent header");
+    let block = get_block(&rpc_url, block_number)
+        .await
+        .expect("failed to fetch block");
+    let parent_block_header = get_block(&rpc_url, block_number - 1)
+        .await
+        .expect("failed to fetch block")
+        .header;
+
+    let db = if let Ok(file) = File::open("db.bin") {
+        println!("db file found");
+        bincode::deserialize_from(file).expect("failed to deserialize db from file")
+    } else {
+        println!("db file not found");
+
+        println!("populating rpc db cache");
+        let rpc_db = RpcDB::with_cache(&rpc_url, block_number - 1, &block)
+            .await
+            .expect("failed to create rpc db");
+
+        println!("pre-executing to build execution db");
+        let db = rpc_db
+            .to_exec_db(&block)
+            .expect("failed to build execution db");
+
+        println!("writing db to file db.bin");
+        let mut file = File::create("db.bin").expect("failed to create db file");
+        file.write_all(
+            bincode::serialize(&db)
+                .expect("failed to serialize db")
+                .as_slice(),
+        )
+        .expect("failed to write db to file");
+
+        db
+    };
+
+    println!("proving");
+    let mut prover = create_prover(ProverType::SP1);
+    let receipt = prover
+        .prove(ProgramInput {
+            block,
+            parent_block_header,
+            db,
+        })
+        .expect("proving failed");
+    let execution_gas = prover.get_gas().expect("failed to get execution gas");
+}