refactor(l1): rename ExecutionDB to ProverDB. (#2770)

**Motivation**
To have a clearer name.

Author: mpaulucci

crates/l2/docs/prover.md

@@ -258,14 +258,14 @@ These inputs are required for proof generation, but not all of them are committe
 #### Execution witness
 The purpose of the execution witness is to allow executing the blocks without having access to the whole Ethereum state, as it wouldn't fit in a zkVM program. It contains only the state values needed during the execution.
 
-An execution witness (represented by the `ExecutionDB` type) contains:
+An execution witness (represented by the `ProverDB` type) contains:
 1. all the initial state values (accounts, code, storage, block hashes) that will be read or written to during the blocks' execution.
 2. Merkle Patricia Trie (MPT) proofs that prove the inclusion or exclusion of each initial value in the initial world state trie.
 
 An execution witness is created from a prior execution of the blocks. Before proving, we need to:
 1. execute the blocks (also called "pre-execution").
 2. log every initial state value accessed or updated during this execution.
-3. store each logged value in an in-memory key-value database (`ExecutionDB`, implemented just using hash maps).
+3. store each logged value in an in-memory key-value database (`ProverDB`, implemented just using hash maps).
 4. retrieve an MPT proof for each value, linking it (or its non-existence) to the initial state root hash.
 
 Steps 1-3 are straightforward. Step 4 involves more complex logic due to potential issues when restructuring the pruned state trie after value removals. In sections [initial state validation](#step-1-initial-state-validation) and [final state validation](#step-3-final-state-validation) we explain what are pruned tries and in which case they get restructured.
@@ -319,7 +319,7 @@ These three components are specific additions for ethrex's L2 protocol, layered
 For more details, refer to [Overview](overview.md), [Withdrawals](withdrawals.md), and [State diffs](state_diffs.md).
 
 #### Step 1: initial state validation
-The program validates the `ExecutionDB` by iterating over each provided state value (stored in hash maps) and verifying its MPT proof against the initial state hash (obtained from the first block's parent block header input). This is the role of the `verify_db()` function (to link the values with the proofs). We could instead directly decode the data from the MPT proofs on each EVM read/write, although this would incur performance costs.
+The program validates the `ProverDB` by iterating over each provided state value (stored in hash maps) and verifying its MPT proof against the initial state hash (obtained from the first block's parent block header input). This is the role of the `verify_db()` function (to link the values with the proofs). We could instead directly decode the data from the MPT proofs on each EVM read/write, although this would incur performance costs.
 
 Having the initial state proofs (paths from the root to each relevant leaf) is equivalent to having a relevant subset of the world state trie and storage tries – a set of "pruned tries". This allows operating directly on these pruned tries (adding, removing, modifying values) during execution.
 

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

@@ -4,15 +4,15 @@ use std::{
 };
 
 use ethrex_common::types::{Block, BlockHeader};
-use ethrex_vm::ExecutionDB;
+use ethrex_vm::ProverDB;
 
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
 pub struct Cache {
     pub block: Block,
     pub parent_block_header: BlockHeader,
-    pub db: ExecutionDB,
+    pub db: ProverDB,
 }
 
 pub fn load_cache(block_number: usize) -> Result<Cache, String> {

crates/l2/prover/bench/src/rpc/db.rs

@@ -13,7 +13,7 @@ use ethrex_levm::db::Database as LevmDatabase;
 use ethrex_storage::{hash_address, hash_key};
 use ethrex_trie::{Node, PathRLP, Trie};
 use ethrex_vm::backends::levm::{CacheDB, LEVM};
-use ethrex_vm::{ExecutionDB, ExecutionDBError};
+use ethrex_vm::{ProverDB, ProverDBError};
 use futures_util::future::join_all;
 use tokio_utils::RateLimiter;
 
@@ -234,7 +234,7 @@ impl RpcDB {
         })
     }
 
-    pub fn to_exec_db(&self, block: &Block) -> Result<ethrex_vm::ExecutionDB, ExecutionDBError> {
+    pub fn to_exec_db(&self, block: &Block) -> Result<ethrex_vm::ProverDB, ProverDBError> {
         // TODO: Simplify this function and potentially merge with the implementation for
         // StoreWrapper.
 
@@ -409,7 +409,7 @@ impl RpcDB {
             })
             .collect();
 
-        Ok(ExecutionDB {
+        Ok(ProverDB {
             accounts,
             code,
             storage,

crates/l2/prover/src/backends/exec.rs

@@ -81,7 +81,7 @@ fn execution_program(input: ProgramInput) -> Result<ProgramOutput, Box<dyn std::
         )?;
 
         // Execute block
-        let mut vm = Evm::from_execution_db(db.clone());
+        let mut vm = Evm::from_prover_db(db.clone());
         let result = vm.execute_block(&block)?;
         let receipts = result.receipts;
         let account_updates = vm.get_state_transitions()?;

crates/l2/prover/tests/perf_zkvm.rs

@@ -64,7 +64,7 @@ async fn setup() -> (ProgramInput, Block) {
         .unwrap()
         .unwrap();
 
-    let db = Evm::to_execution_db(&store.clone(), &vec![block_to_prove.clone()])
+    let db = Evm::to_prover_db(&store.clone(), &vec![block_to_prove.clone()])
         .await
         .unwrap();
 

crates/l2/prover/zkvm/interface/pico/src/main.rs

@@ -61,7 +61,7 @@ pub fn main() {
         .expect("invalid block");
 
         // Execute block
-        let mut vm = Evm::from_execution_db(db.clone());
+        let mut vm = Evm::from_prover_db(db.clone());
         let result = vm.execute_block(&block).expect("failed to execute block");
         let receipts = result.receipts;
         let account_updates = vm.get_state_transitions()?;

crates/l2/prover/zkvm/interface/risc0/src/main.rs

@@ -53,7 +53,7 @@ fn main() {
         validate_block(&block, &parent_header, &db.chain_config).expect("invalid block");
 
         // Execute block
-        let mut vm = Evm::from_execution_db(db.clone());
+        let mut vm = Evm::from_prover_db(db.clone());
         let result = vm.execute_block(&block).expect("failed to execute block");
         let receipts = result.receipts;
         let account_updates = vm

crates/l2/prover/zkvm/interface/sp1/src/main.rs

@@ -60,7 +60,7 @@ pub fn main() {
         .expect("invalid block");
 
         // Execute block
-        let mut vm = Evm::from_execution_db(db.clone());
+        let mut vm = Evm::from_prover_db(db.clone());
         let result = vm.execute_block(&block).expect("failed to execute block");
         let receipts = result.receipts;
         let account_updates = vm

crates/l2/prover/zkvm/interface/src/lib.rs

@@ -24,7 +24,7 @@ pub mod io {
         types::{Block, BlockHeader},
         H256,
     };
-    use ethrex_vm::ExecutionDB;
+    use ethrex_vm::ProverDB;
     use serde::{de::DeserializeOwned, Deserialize, Serialize};
     use serde_with::{serde_as, DeserializeAs, SerializeAs};
 
@@ -39,7 +39,7 @@ pub mod io {
         #[serde_as(as = "SerdeJSON")]
         pub parent_block_header: BlockHeader,
         /// database containing only the data necessary to execute
-        pub db: ExecutionDB,
+        pub db: ProverDB,
         /// value used to calculate base fee
         pub elasticity_multiplier: u64,
     }
@@ -110,7 +110,7 @@ pub mod trie {
     use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode, error::RLPDecodeError};
     use ethrex_storage::{hash_address, hash_key, AccountUpdate};
     use ethrex_trie::{Trie, TrieError};
-    use ethrex_vm::ExecutionDB;
+    use ethrex_vm::ProverDB;
     use thiserror::Error;
 
     #[derive(Debug, Error)]
@@ -126,7 +126,7 @@ pub mod trie {
     }
 
     pub fn verify_db(
-        db: &ExecutionDB,
+        db: &ProverDB,
         state_trie: &Trie,
         storage_tries: &HashMap<H160, Trie>,
     ) -> Result<bool, Error> {

crates/l2/sequencer/proof_coordinator.rs

@@ -13,7 +13,7 @@ use ethrex_common::{
 use ethrex_rpc::clients::eth::EthClient;
 use ethrex_storage::Store;
 use ethrex_storage_rollup::StoreRollup;
-use ethrex_vm::{Evm, EvmError, ExecutionDB};
+use ethrex_vm::{Evm, EvmError, ProverDB};
 use serde::{Deserialize, Serialize};
 use std::{fmt::Debug, net::IpAddr};
 use tokio::{
@@ -30,7 +30,7 @@ use super::utils::sleep_random;
 pub struct ProverInputData {
     pub blocks: Vec<Block>,
     pub parent_block_header: BlockHeader,
-    pub db: ExecutionDB,
+    pub db: ProverDB,
     pub elasticity_multiplier: u64,
 }
 
@@ -321,10 +321,10 @@ impl ProofCoordinator {
 
         let blocks = self.fetch_blocks(block_numbers).await?;
 
-        // Create execution_db
-        let db = Evm::to_execution_db(&self.store.clone(), &blocks)
+        // Create prover_db
+        let db = Evm::to_prover_db(&self.store.clone(), &blocks)
             .await
-            .map_err(EvmError::ExecutionDB)?;
+            .map_err(EvmError::ProverDB)?;
 
         // Get the block_header of the parent of the first block
         let parent_hash = blocks

crates/l2/utils/error.rs

@@ -1,6 +1,6 @@
 use ethrex_blockchain::error::ChainError;
 use ethrex_storage::error::StoreError;
-use ethrex_vm::ExecutionDBError;
+use ethrex_vm::ProverDBError;
 use keccak_hash::H256;
 
 use super::config::errors::ConfigError;
@@ -15,8 +15,8 @@ pub enum ProverInputError {
     StoreError(#[from] StoreError),
     #[error("Chain error: {0}")]
     ChainError(#[from] ChainError),
-    #[error("ExecutionDB error: {0}")]
-    ExecutionDBError(#[from] ExecutionDBError),
+    #[error("ProverDB error: {0}")]
+    ProverDBError(#[from] ProverDBError),
     #[error("Invalid Environment variable: {0}")]
     InvalidEnvVar(#[from] ConfigError),
 }

crates/l2/utils/test_data_io.rs

@@ -87,7 +87,7 @@ pub async fn generate_program_input(
     read_env_file_by_config().map_err(ProverInputError::InvalidEnvVar)?;
     let elasticity_multiplier = ELASTICITY_MULTIPLIER;
     let blocks = vec![block];
-    let db = Evm::to_execution_db(&store, &blocks).await?;
+    let db = Evm::to_prover_db(&store, &blocks).await?;
 
     Ok(ProgramInput {
         db,

crates/vm/backends/levm/db.rs

@@ -4,7 +4,8 @@ use ethrex_common::{Address as CoreAddress, H256 as CoreH256};
 use ethrex_levm::constants::EMPTY_CODE_HASH;
 use ethrex_levm::db::Database as LevmDatabase;
 
-use crate::db::{ExecutionDB, StoreWrapper};
+use crate::db::StoreWrapper;
+use crate::ProverDB;
 use ethrex_levm::db::error::DatabaseError;
 use std::collections::HashMap;
 use std::result::Result;
@@ -160,7 +161,7 @@ impl LevmDatabase for StoreWrapper {
     }
 }
 
-impl LevmDatabase for ExecutionDB {
+impl LevmDatabase for ProverDB {
     fn get_account(&self, address: CoreAddress) -> Result<Account, DatabaseError> {
         let Some(acc_info) = self.accounts.get(&address) else {
             return Ok(Account::default());

crates/vm/backends/levm/mod.rs

@@ -7,7 +7,7 @@ use crate::constants::{
     BEACON_ROOTS_ADDRESS, CONSOLIDATION_REQUEST_PREDEPLOY_ADDRESS, HISTORY_STORAGE_ADDRESS,
     SYSTEM_ADDRESS, WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS,
 };
-use crate::{EvmError, ExecutionDB, ExecutionDBError, ExecutionResult, StoreWrapper};
+use crate::{EvmError, ExecutionResult, ProverDB, ProverDBError, StoreWrapper};
 use bytes::Bytes;
 use ethrex_common::{
     types::{
@@ -320,7 +320,7 @@ impl LEVM {
             TxResult::Success => Ok(report),
             // EIP-7002 specifies that a failed system call invalidates the entire block.
             TxResult::Revert(vm_error) => Err(EvmError::Custom(format!(
-                "REVERT when reading withdrawal requests with error: {:?}. According to EIP-7002, the revert of this system call invalidates the block.", 
+                "REVERT when reading withdrawal requests with error: {:?}. According to EIP-7002, the revert of this system call invalidates the block.",
                 vm_error
             ))),
         }
@@ -349,7 +349,7 @@ impl LEVM {
             TxResult::Success => Ok(report),
             // EIP-7251 specifies that a failed system call invalidates the entire block.
             TxResult::Revert(vm_error) => Err(EvmError::Custom(format!(
-                "REVERT when dequeuing consolidation requests with error: {:?}. According to EIP-7251, the revert of this system call invalidates the block.", 
+                "REVERT when dequeuing consolidation requests with error: {:?}. According to EIP-7251, the revert of this system call invalidates the block.",
                 vm_error
             ))),
         }
@@ -378,16 +378,13 @@ impl LEVM {
         Ok((report.into(), access_list))
     }
 
-    pub async fn to_execution_db(
-        blocks: &[Block],
-        store: &Store,
-    ) -> Result<ExecutionDB, ExecutionDBError> {
+    pub async fn to_prover_db(blocks: &[Block], store: &Store) -> Result<ProverDB, ProverDBError> {
         let chain_config = store.get_chain_config()?;
         let Some(first_block_parent_hash) = blocks.first().map(|e| e.header.parent_hash) else {
-            return Err(ExecutionDBError::Custom("Unable to get first block".into()));
+            return Err(ProverDBError::Custom("Unable to get first block".into()));
         };
         let Some(last_block) = blocks.last() else {
-            return Err(ExecutionDBError::Custom("Unable to get last block".into()));
+            return Err(ProverDBError::Custom("Unable to get last block".into()));
         };
 
         let logger = Arc::new(DatabaseLogger::new(Arc::new(Mutex::new(Box::new(
@@ -425,7 +422,7 @@ impl LEVM {
             .state_accessed
             .lock()
             .map_err(|_| {
-                ExecutionDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
+                ProverDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
             })?
             .clone();
 
@@ -439,14 +436,14 @@ impl LEVM {
                     .transpose()
                     .map(|account| Ok((*address, account?)))
             })
-            .collect::<Result<HashMap<_, _>, ExecutionDBError>>()?;
+            .collect::<Result<HashMap<_, _>, ProverDBError>>()?;
 
         // fetch all read/written code from store
         let code_accessed = logger
             .code_accessed
             .lock()
             .map_err(|_| {
-                ExecutionDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
+                ProverDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
             })?
             .clone();
         let code = accounts
@@ -459,7 +456,7 @@ impl LEVM {
                     .transpose()
                     .map(|account| Ok((hash, account?)))
             })
-            .collect::<Result<HashMap<_, _>, ExecutionDBError>>()?;
+            .collect::<Result<HashMap<_, _>, ProverDBError>>()?;
 
         // fetch all read/written storage from store
         let added_storage = execution_updates.iter().filter_map(|(address, update)| {
@@ -475,7 +472,7 @@ impl LEVM {
             .into_iter()
             .chain(added_storage)
             .map(|(address, keys)| {
-                let keys: Result<HashMap<_, _>, ExecutionDBError> = keys
+                let keys: Result<HashMap<_, _>, ProverDBError> = keys
                     .iter()
                     .filter_map(|key| {
                         store
@@ -486,13 +483,13 @@ impl LEVM {
                     .collect();
                 Ok((address, keys?))
             })
-            .collect::<Result<HashMap<_, _>, ExecutionDBError>>()?;
+            .collect::<Result<HashMap<_, _>, ProverDBError>>()?;
 
         let block_hashes = logger
             .block_hashes_accessed
             .lock()
             .map_err(|_| {
-                ExecutionDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
+                ProverDBError::Store(StoreError::Custom("Could not lock mutex".to_string()))
             })?
             .clone()
             .into_iter()
@@ -502,10 +499,10 @@ impl LEVM {
         // get account proofs
         let state_trie = store
             .state_trie(last_block.hash())?
-            .ok_or(ExecutionDBError::NewMissingStateTrie(last_block.hash()))?;
-        let parent_state_trie = store.state_trie(first_block_parent_hash)?.ok_or(
-            ExecutionDBError::NewMissingStateTrie(first_block_parent_hash),
-        )?;
+            .ok_or(ProverDBError::NewMissingStateTrie(last_block.hash()))?;
+        let parent_state_trie = store
+            .state_trie(first_block_parent_hash)?
+            .ok_or(ProverDBError::NewMissingStateTrie(first_block_parent_hash))?;
         let hashed_addresses: Vec<_> = state_accessed.keys().map(hash_address).collect();
         let initial_state_proofs = parent_state_trie.get_proofs(&hashed_addresses)?;
         let final_state_proofs: Vec<_> = hashed_addresses
@@ -533,7 +530,7 @@ impl LEVM {
                 continue;
             };
             let storage_trie = store.storage_trie(last_block.hash(), address)?.ok_or(
-                ExecutionDBError::NewMissingStorageTrie(last_block.hash(), address),
+                ProverDBError::NewMissingStorageTrie(last_block.hash(), address),
             )?;
             let paths = storage_keys.iter().map(hash_key).collect::<Vec<_>>();
 
@@ -561,7 +558,7 @@ impl LEVM {
             final_storage_proofs.insert(address, final_proofs);
         }
 
-        Ok(ExecutionDB {
+        Ok(ProverDB {
             accounts,
             code,
             storage,