chore(l2): granulize SP1 zkVM cycles report (#5226)

**Motivation**

For SP1 we already have profiling tools like Samply to generate
flamegraphs of the execution and get an idea of the spent cycles during
the execution, but it is not always desired to run those.

As an alternative, granulating the current cycle's report is very
useful.

**Description**

- Decouple L1 stateless validation
- Add `report_cycles!` macro that wraps a block of code with optional
cycle-tracking prints
- Wrap code blocks inside the `report_cycles!` macro to track cycles of
them.

**Example Output**

```shell
2025-11-06T20:27:17.842628Z  INFO ethrex_replay::fetcher: Getting block 23721540 data from cache
2025-11-06T20:27:22.669322Z  INFO execute: sp1_core_executor::syscalls::write: ┌╴read_input
2025-11-06T20:27:23.074825Z  INFO execute: sp1_core_executor::syscalls::write: └╴12,868,356 cycles
2025-11-06T20:27:23.074862Z  INFO execute: sp1_core_executor::syscalls::write: ┌╴execution
2025-11-06T20:27:23.074915Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴GuestProgramState::from(execution_witness)
stderr: WARNING: Using insecure random number generator.
2025-11-06T20:27:28.337580Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴191,414,247 cycles
2025-11-06T20:27:28.337737Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴initialize_block_header_hashes
2025-11-06T20:27:28.338575Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴11,402 cycles
2025-11-06T20:27:28.338592Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴get_first_invalid_block_hash
2025-11-06T20:27:28.338617Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴585 cycles
2025-11-06T20:27:28.338707Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴state_trie_root
2025-11-06T20:27:29.836352Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴38,685,313 cycles
2025-11-06T20:27:29.836390Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴validate_block
2025-11-06T20:27:29.837260Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴16,766 cycles
2025-11-06T20:27:29.837278Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴setup_evm
2025-11-06T20:27:29.837297Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴458 cycles
2025-11-06T20:27:29.837310Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴execute_block
2025-11-06T20:27:57.108787Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴531,651,252 cycles
2025-11-06T20:27:57.108819Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴get_state_transitions
2025-11-06T20:27:57.175020Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴2,383,891 cycles
2025-11-06T20:27:57.175052Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴apply_account_updates
2025-11-06T20:27:59.351855Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴60,042,986 cycles
2025-11-06T20:27:59.381137Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴validate_gas_and_receipts
2025-11-06T20:27:59.381168Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴379 cycles
2025-11-06T20:27:59.381180Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴validate_receipts_root
2025-11-06T20:27:59.621535Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴7,450,196 cycles
2025-11-06T20:27:59.621572Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴validate_requests_hash
2025-11-06T20:27:59.621785Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴2,734 cycles
2025-11-06T20:27:59.621851Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴get_final_state_root
2025-11-06T20:28:00.570636Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴24,414,357 cycles
2025-11-06T20:28:00.570669Z  INFO execute: sp1_core_executor::syscalls::write: │ ┌╴validate_state_root
2025-11-06T20:28:00.570689Z  INFO execute: sp1_core_executor::syscalls::write: │ └╴624 cycles
2025-11-06T20:28:00.652210Z  INFO execute: sp1_core_executor::syscalls::write: └╴858,494,608 cycles
2025-11-06T20:28:00.652242Z  INFO execute: sp1_core_executor::syscalls::write: ┌╴commit_public_inputs
2025-11-06T20:28:00.652577Z  INFO execute: sp1_core_executor::syscalls::write: └╴1,632 cycles
2025-11-06T20:28:00.731639Z  INFO execute: sp1_prover: gas: 1145215937
2025-11-06T20:28:00.733918Z  INFO ethrex_prover_lib::backend::sp1: Successfully executed SP1 program in 38.09s
2025-11-06T20:28:00.734204Z  INFO ethrex_replay::report: [mainnet] Block: 23721540, Gas: 20284615, #Txs: 223, Execution Time: 42s 794ms | https://etherscan.io/block/23721540
```

---------

Co-authored-by: Copilot <[email protected]>
Co-authored-by: Gianbelinche <[email protected]>

Author: 3 people

crates/l2/prover/src/guest_program/Cargo.toml

@@ -39,5 +39,9 @@ sp1 = ["dep:sp1-build", "dep:sp1-sdk"]
 l2 = []
 c-kzg = ["ethrex-vm/c-kzg", "ethrex-common/c-kzg"]
 
+# When this feature is enabled, the cycles used in the code inside the 
+# report_cycles! macro will be reported to stdout when running inside SP1 zkVM.
+sp1-cycles = []
+
 [lib]
 path = "./src/lib.rs"

crates/l2/prover/src/guest_program/src/execution.rs

@@ -1,9 +1,11 @@
 use crate::input::ProgramInput;
 use crate::output::ProgramOutput;
+use crate::report_cycles;
 
 use ethrex_blockchain::error::ChainError;
 use ethrex_blockchain::{
     validate_block, validate_gas_used, validate_receipts_root, validate_requests_hash,
+    validate_state_root,
 };
 use ethrex_common::types::AccountUpdate;
 use ethrex_common::types::block_execution_witness::ExecutionWitness;
@@ -17,7 +19,7 @@ use ethrex_common::{H256, types::Block};
 use ethrex_l2_common::l1_messages::L1Message;
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_vm::{Evm, EvmError, GuestProgramStateWrapper, VmDatabase};
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 
 #[cfg(feature = "l2")]
 use ethrex_common::types::{
@@ -116,35 +118,162 @@ pub fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Stateless
         );
     }
 
-    stateless_validation_l1(&blocks, execution_witness, elasticity_multiplier, chain_id)
+    stateless_validation_l1(blocks, execution_witness, elasticity_multiplier, chain_id)
 }
 
 pub fn stateless_validation_l1(
-    blocks: &[Block],
+    blocks: Vec<Block>,
     execution_witness: ExecutionWitness,
     elasticity_multiplier: u64,
     chain_id: u64,
 ) -> Result<ProgramOutput, StatelessExecutionError> {
-    let StatelessResult {
-        initial_state_hash,
-        final_state_hash,
-        last_block_hash,
-        non_privileged_count,
-        ..
-    } = execute_stateless(blocks, execution_witness, elasticity_multiplier, None)?;
+    let guest_program_state: GuestProgramState =
+        report_cycles("guest_program_state_initialization", || {
+            execution_witness
+                .try_into()
+                .map_err(StatelessExecutionError::GuestProgramState)
+        })?;
+
+    let mut wrapped_db = GuestProgramStateWrapper::new(guest_program_state);
+
+    let chain_config = wrapped_db.get_chain_config().map_err(|_| {
+        StatelessExecutionError::Internal("No chain config in execution witness".to_string())
+    })?;
+
+    // Hashing is an expensive operation in zkVMs, this way we avoid hashing twice
+    // (once in get_first_invalid_block_hash(), later in validate_block()).
+    report_cycles("initialize_block_header_hashes", || {
+        wrapped_db.initialize_block_header_hashes(&blocks)
+    })?;
+
+    // Validate execution witness' block hashes, except parent block hash (latest block hash).
+    report_cycles("get_first_invalid_block_hash", || {
+        if let Ok(Some(invalid_block_header)) = wrapped_db.get_first_invalid_block_hash() {
+            return Err(StatelessExecutionError::InvalidBlockHash(
+                invalid_block_header,
+            ));
+        }
+        Ok(())
+    })?;
+
+    // Validate the initial state
+    let parent_block_header = wrapped_db
+        .get_block_parent_header(
+            blocks
+                .first()
+                .ok_or(StatelessExecutionError::EmptyBatchError)?
+                .header
+                .number,
+        )
+        .map_err(StatelessExecutionError::GuestProgramState)?;
+
+    let initial_state_hash = report_cycles("state_trie_root", || {
+        wrapped_db
+            .state_trie_root()
+            .map_err(StatelessExecutionError::GuestProgramState)
+    })?;
+
+    if initial_state_hash != parent_block_header.state_root {
+        return Err(StatelessExecutionError::InvalidInitialStateTrie);
+    }
+
+    // Execute blocks
+    let mut parent_block_header = &parent_block_header;
+    let mut acc_account_updates: BTreeMap<Address, AccountUpdate> = BTreeMap::new();
+    let mut acc_receipts = Vec::new();
+    let mut non_privileged_count = 0;
+
+    for block in blocks.iter() {
+        // Validate the block
+        report_cycles("validate_block", || {
+            validate_block(
+                block,
+                parent_block_header,
+                &chain_config,
+                elasticity_multiplier,
+            )
+            .map_err(StatelessExecutionError::BlockValidationError)
+        })?;
+
+        let mut vm = report_cycles("setup_evm", || {
+            let vm = Evm::new_for_l1(wrapped_db.clone());
+            Ok::<_, StatelessExecutionError>(vm)
+        })?;
+
+        let result = report_cycles("execute_block", || {
+            vm.execute_block(block)
+                .map_err(StatelessExecutionError::EvmError)
+        })?;
+
+        let account_updates = report_cycles("get_state_transitions", || {
+            vm.get_state_transitions()
+                .map_err(StatelessExecutionError::EvmError)
+        })?;
+
+        // Update db for the next block
+        report_cycles("apply_account_updates", || {
+            wrapped_db
+                .apply_account_updates(&account_updates)
+                .map_err(StatelessExecutionError::GuestProgramState)
+        })?;
+        // Update acc_account_updates
+        for account in account_updates {
+            let address = account.address;
+            if let Some(existing) = acc_account_updates.get_mut(&address) {
+                existing.merge(account);
+            } else {
+                acc_account_updates.insert(address, account);
+            }
+        }
+
+        report_cycles("validate_gas_and_receipts", || {
+            validate_gas_used(&result.receipts, &block.header)
+                .map_err(StatelessExecutionError::GasValidationError)
+        })?;
+
+        report_cycles("validate_receipts_root", || {
+            validate_receipts_root(&block.header, &result.receipts)
+                .map_err(StatelessExecutionError::ReceiptsRootValidationError)
+        })?;
+
+        // validate_requests_hash doesn't do anything for l2 blocks as this verifies l1 requests (messages, privileged transactions and consolidations)
+        report_cycles("validate_requests_hash", || {
+            validate_requests_hash(&block.header, &chain_config, &result.requests)
+                .map_err(StatelessExecutionError::RequestsRootValidationError)
+        })?;
+
+        non_privileged_count += block.body.transactions.len();
+        acc_receipts.push(result.receipts);
+        parent_block_header = &block.header;
+    }
+
+    let final_state_root = report_cycles("get_final_state_root", || {
+        wrapped_db
+            .state_trie_root()
+            .map_err(StatelessExecutionError::GuestProgramState)
+    })?;
+
+    let last_block = blocks
+        .last()
+        .ok_or(StatelessExecutionError::EmptyBatchError)?;
+
+    report_cycles("validate_state_root", || {
+        validate_state_root(&last_block.header, final_state_root)
+            .map_err(|_chain_err| StatelessExecutionError::InvalidFinalStateTrie)
+    })?;
 
     Ok(ProgramOutput {
         initial_state_hash,
-        final_state_hash,
+        final_state_hash: final_state_root,
         #[cfg(feature = "l2")]
         l1messages_merkle_root: H256::zero(),
         #[cfg(feature = "l2")]
         privileged_transactions_hash: H256::zero(),
         #[cfg(feature = "l2")]
         blob_versioned_hash: H256::zero(),
-        last_block_hash,
+        last_block_hash: last_block.header.hash(),
         chain_id: chain_id.into(),
-        non_privileged_count,
+        non_privileged_count: non_privileged_count.into(),
     })
 }
 

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

@@ -16,3 +16,16 @@ pub static ZKVM_RISC0_PROGRAM_VK: &str = include_str!(concat!("./risc0/out/riscv
 // To avoid compilation errors, we override it with an empty slice.
 #[cfg(any(clippy, not(feature = "risc0")))]
 pub const ZKVM_RISC0_PROGRAM_VK: &str = "";
+
+/// Report cycles used in a code block when running inside SP1 zkVM.
+///
+/// When the feature "sp1-cycles" is enabled, it will print start and end cycle
+/// tracking messages that are compatible with SP1's cycle tracking system.
+pub fn report_cycles<T, E>(_label: &str, block: impl FnOnce() -> Result<T, E>) -> Result<T, E> {
+    #[cfg(feature = "sp1-cycles")]
+    println!("cycle-tracker-report-start: {_label}");
+    let result = block();
+    #[cfg(feature = "sp1-cycles")]
+    println!("cycle-tracker-report-end: {_label}");
+    result
+}

crates/l2/prover/src/guest_program/src/sp1/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2024"
 sp1-zkvm = { version = "=5.0.8" }
 rkyv = { version = "0.8.10", features = ["std", "unaligned"] }
 
-guest_program = { path = "../../" }
+guest_program = { path = "../../", features = ["sp1-cycles"] }
 
 ethrex-common = { path = "../../../../../../common", default-features = false }
 ethrex-storage = { path = "../../../../../../storage", default-features = false }