refactor(l1, l2, levm): remove l2 feature flag from crates ethrex-vm and ethrex-levm

cmd/ef_tests/blockchain/test_runner.rs

@@ -5,7 +5,7 @@ use crate::{
     types::{BlockChainExpectedException, BlockExpectedException, BlockWithRLP, TestUnit},
 };
 use ethrex_blockchain::{
-    Blockchain,
+    Blockchain, BlockchainType,
     error::{ChainError, InvalidBlockError},
     fork_choice::apply_fork_choice,
 };
@@ -69,7 +69,10 @@ pub async fn run_ef_test(test_key: &str, test: &TestUnit, evm: EvmEngine) -> Res
     // Check world_state
     check_prestate_against_db(test_key, test, &store);
 
-    let blockchain = Blockchain::new(evm, store.clone());
+    // Blockchain EF tests are meant for L1.
+    let blockchain_type = BlockchainType::L1;
+
+    let blockchain = Blockchain::new(evm, store.clone(), blockchain_type);
     // Execute all blocks in test
     for block_fixture in test.blocks.iter() {
         let expects_exception = block_fixture.expect_exception.is_some();

cmd/ef_tests/state/Cargo.toml

@@ -42,7 +42,6 @@ path = "./lib.rs"
 default = ["c-kzg", "blst"]
 c-kzg = ["ethrex-vm/c-kzg", "ethrex-levm/c-kzg", "ethrex-common/c-kzg"]
 blst = ["ethrex-vm/blst"]
-l2 = ["ethrex-vm/l2", "ethrex-levm/l2"]
 
 [[test]]
 name = "all"

cmd/ef_tests/state/runner/levm_runner.rs

@@ -16,7 +16,7 @@ use ethrex_levm::{
     db::gen_db::GeneralizedDatabase,
     errors::{ExecutionReport, TxValidationError, VMError},
     tracing::LevmCallTracer,
-    vm::VM,
+    vm::{VM, VMType},
 };
 use ethrex_rlp::encode::RLPEncode;
 use ethrex_vm::backends;
@@ -201,6 +201,7 @@ pub fn prepare_vm_for_tx<'a>(
         db,
         &tx,
         LevmCallTracer::disabled(),
+        VMType::L1, // TODO: Should we run the EF tests with L2?
     ))
 }
 

cmd/ethrex/Cargo.toml

@@ -75,7 +75,6 @@ l2 = [
   "dep:ethrex-l2-common",
   "dep:ethrex-sdk",
   "dep:ethrex-l2-rpc",
-  "ethrex-vm/l2",
   "ethrex-blockchain/l2",
   "ethrex-storage-rollup",
 ]

cmd/ethrex/bench/build_block_benchmark.rs

@@ -10,7 +10,7 @@ use criterion::{
     measurement::{Measurement, ValueFormatter},
 };
 use ethrex_blockchain::{
-    Blockchain,
+    Blockchain, BlockchainType,
     payload::{BuildPayloadArgs, PayloadBuildResult, create_payload},
 };
 use ethrex_common::{
@@ -261,7 +261,11 @@ pub fn build_block_benchmark(c: &mut Criterion<GasMeasurement>) {
                         .collect();
 
                     let (store_with_genesis, genesis) = setup_genesis(&addresses).await;
-                    let block_chain = Blockchain::new(EvmEngine::LEVM, store_with_genesis.clone());
+                    let block_chain = Blockchain::new(
+                        EvmEngine::LEVM,
+                        store_with_genesis.clone(),
+                        BlockchainType::L1, // TODO: Should we support L2?
+                    );
                     fill_mempool(&block_chain, accounts).await;
 
                     (block_chain, genesis.get_block(), store_with_genesis)

cmd/ethrex/bench/import_blocks_benchmark.rs

@@ -5,6 +5,7 @@ use ethrex::{
     networks::Network,
     utils::set_datadir,
 };
+use ethrex_blockchain::BlockchainType;
 use ethrex_vm::EvmEngine;
 
 #[inline]
@@ -15,7 +16,9 @@ fn block_import() {
 
     let evm_engine = EvmEngine::default();
 
-    let network = Network::from("../../fixtures/genesis/perf-ci.json");
+    let blockchain_type = BlockchainType::default(); // TODO: Should we support L2?
+
+    let network = Network::from("../../test_data/genesis-perf-ci.json");
     let genesis = network
         .get_genesis()
         .expect("Failed to generate genesis from file");
@@ -25,6 +28,7 @@ fn block_import() {
         data_dir,
         genesis,
         evm_engine,
+        blockchain_type,
     ))
     .expect("Failed to import blocks on the Tokio runtime");
 }

cmd/ethrex/cli.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use clap::{ArgAction, Parser as ClapParser, Subcommand as ClapSubcommand};
-use ethrex_blockchain::error::ChainError;
+use ethrex_blockchain::{BlockchainType, error::ChainError};
 use ethrex_common::types::Genesis;
 use ethrex_p2p::{sync::SyncMode, types::Node};
 use ethrex_rlp::encode::RLPEncode;
@@ -241,6 +241,8 @@ pub enum Subcommand {
         path: String,
         #[arg(long = "removedb", action = ArgAction::SetTrue)]
         removedb: bool,
+        #[arg(long, action = ArgAction::SetTrue)]
+        l2: bool,
     },
     #[command(
         name = "export",
@@ -290,7 +292,7 @@ impl Subcommand {
             Subcommand::RemoveDB { datadir, force } => {
                 remove_db(&datadir, force);
             }
-            Subcommand::Import { path, removedb } => {
+            Subcommand::Import { path, removedb, l2 } => {
                 if removedb {
                     Box::pin(async {
                         Self::RemoveDB {
@@ -305,7 +307,12 @@ impl Subcommand {
 
                 let network = &opts.network;
                 let genesis = network.get_genesis()?;
-                import_blocks(&path, &opts.datadir, genesis, opts.evm).await?;
+                let blockchain_type = if l2 {
+                    BlockchainType::L2
+                } else {
+                    BlockchainType::L1
+                };
+                import_blocks(&path, &opts.datadir, genesis, opts.evm, blockchain_type).await?;
             }
             Subcommand::Export { path, first, last } => {
                 export_blocks(&path, &opts.datadir, first, last).await
@@ -354,10 +361,11 @@ pub async fn import_blocks(
     data_dir: &str,
     genesis: Genesis,
     evm: EvmEngine,
+    blockchain_type: BlockchainType,
 ) -> Result<(), ChainError> {
     let data_dir = set_datadir(data_dir);
     let store = init_store(&data_dir, genesis).await;
-    let blockchain = init_blockchain(evm, store.clone());
+    let blockchain = init_blockchain(evm, store.clone(), blockchain_type);
     let path_metadata = metadata(path).expect("Failed to read path");
     let blocks = if path_metadata.is_dir() {
         let mut blocks = vec![];

cmd/ethrex/ethrex.rs

@@ -7,6 +7,7 @@ use ethrex::{
     },
     utils::{NodeConfigFile, set_datadir, store_node_config_file},
 };
+use ethrex_blockchain::BlockchainType;
 use ethrex_p2p::{kademlia::KademliaTable, network::peer_table, types::NodeRecord};
 #[cfg(feature = "sync-test")]
 use ethrex_storage::Store;
@@ -78,7 +79,7 @@ async fn main() -> eyre::Result<()> {
     #[cfg(feature = "sync-test")]
     set_sync_block(&store).await;
 
-    let blockchain = init_blockchain(opts.evm, store.clone());
+    let blockchain = init_blockchain(opts.evm, store.clone(), BlockchainType::L1);
 
     let signer = get_signer(&data_dir);
 

cmd/ethrex/initializers.rs

@@ -3,7 +3,7 @@ use crate::{
     networks::{self, Network, PublicNetwork},
     utils::{get_client_version, parse_socket_addr, read_jwtsecret_file, read_node_config_file},
 };
-use ethrex_blockchain::Blockchain;
+use ethrex_blockchain::{Blockchain, BlockchainType};
 use ethrex_common::types::Genesis;
 use ethrex_p2p::{
     kademlia::KademliaTable,
@@ -82,9 +82,13 @@ pub fn open_store(data_dir: &str) -> Store {
     }
 }
 
-pub fn init_blockchain(evm_engine: EvmEngine, store: Store) -> Arc<Blockchain> {
+pub fn init_blockchain(
+    evm_engine: EvmEngine,
+    store: Store,
+    blockchain_type: BlockchainType,
+) -> Arc<Blockchain> {
     info!("Initiating blockchain with EVM: {}", evm_engine);
-    Blockchain::new(evm_engine, store).into()
+    Blockchain::new(evm_engine, store, blockchain_type).into()
 }
 
 #[allow(clippy::too_many_arguments)]

cmd/ethrex/l2/command.rs

@@ -10,6 +10,7 @@ use crate::{
     utils::{NodeConfigFile, parse_private_key, set_datadir, store_node_config_file},
 };
 use clap::Subcommand;
+use ethrex_blockchain::BlockchainType;
 use ethrex_common::{
     Address, U256,
     types::{BYTES_PER_BLOB, BlobsBundle, BlockHeader, batch::Batch, bytes_from_blob},
@@ -136,7 +137,8 @@ impl Command {
                 let store = init_store(&data_dir, genesis).await;
                 let rollup_store = l2::initializers::init_rollup_store(&rollup_store_dir).await;
 
-                let blockchain = init_blockchain(opts.node_opts.evm, store.clone());
+                let blockchain =
+                    init_blockchain(opts.node_opts.evm, store.clone(), BlockchainType::L2);
 
                 let signer = get_signer(&data_dir);
 

cmd/ethrex_replay/Cargo.toml

@@ -58,5 +58,5 @@ charming = { version = "0.4.0", features = ["ssr"] }
 risc0 = ["zkvm_interface/risc0", "ethrex-prover/risc0"]
 sp1 = ["zkvm_interface/sp1", "ethrex-prover/sp1"]
 gpu = ["ethrex-prover/gpu"]
-l2 = ["ethrex-vm/l2", "zkvm_interface/l2", "ethrex-l2/l2"]
+l2 = ["zkvm_interface/l2", "ethrex-l2/l2"]
 ci = []

cmd/ethrex_replay/src/cli.rs

@@ -70,6 +70,8 @@ enum SubcommandExecute {
             help = "Name or ChainID of the network to use"
         )]
         network: String,
+        #[arg(long, required = false)]
+        l2: bool,
     },
 }
 
@@ -117,11 +119,12 @@ impl SubcommandExecute {
                 tx,
                 rpc_url,
                 network,
+                l2,
             } => {
                 let chain_config = get_chain_config(&network)?;
                 let block_number = get_tx_block(&tx, &rpc_url).await?;
                 let cache = get_blockdata(&rpc_url, chain_config, block_number).await?;
-                let (receipt, transitions) = run_tx(cache, &tx).await?;
+                let (receipt, transitions) = run_tx(cache, &tx, l2).await?;
                 print_receipt(receipt);
                 for transition in transitions {
                     print_transition(transition);

cmd/ethrex_replay/src/run.rs

@@ -1,6 +1,9 @@
 use crate::cache::Cache;
 use ethrex_common::types::{AccountUpdate, ELASTICITY_MULTIPLIER, Receipt};
-use ethrex_levm::db::{CacheDB, gen_db::GeneralizedDatabase};
+use ethrex_levm::{
+    db::{CacheDB, gen_db::GeneralizedDatabase},
+    vm::VMType,
+};
 use ethrex_vm::{DynVmDatabase, Evm, EvmEngine, backends::levm::LEVM};
 use eyre::Ok;
 use std::sync::Arc;
@@ -58,7 +61,11 @@ pub async fn prove(cache: Cache) -> eyre::Result<String> {
     Ok(serde_json::to_string(&out.0)?)
 }
 
-pub async fn run_tx(cache: Cache, tx_id: &str) -> eyre::Result<(Receipt, Vec<AccountUpdate>)> {
+pub async fn run_tx(
+    cache: Cache,
+    tx_id: &str,
+    l2: bool,
+) -> eyre::Result<(Receipt, Vec<AccountUpdate>)> {
     let block = cache
         .blocks
         .first()
@@ -67,16 +74,22 @@ pub async fn run_tx(cache: Cache, tx_id: &str) -> eyre::Result<(Receipt, Vec<Acc
     let mut prover_db = cache.witness;
     prover_db.rebuild_tries()?;
 
+    let vm_type = if l2 { VMType::L2 } else { VMType::L1 };
+
     let changes = {
         let store: Arc<DynVmDatabase> = Arc::new(Box::new(prover_db.clone()));
         let mut db = GeneralizedDatabase::new(store.clone(), CacheDB::new());
-        LEVM::prepare_block(block, &mut db)?;
+        LEVM::prepare_block(block, &mut db, vm_type)?;
         LEVM::get_state_transitions(&mut db)?
     };
     prover_db.apply_account_updates(&changes)?;
 
     for (tx, tx_sender) in block.body.get_transactions_with_sender()? {
-        let mut vm = Evm::new(EvmEngine::LEVM, prover_db.clone());
+        let mut vm = if l2 {
+            Evm::new_for_l2(EvmEngine::LEVM, prover_db.clone())?
+        } else {
+            Evm::new_for_l1(EvmEngine::LEVM, prover_db.clone())
+        };
         let (receipt, _) = vm.execute_tx(tx, &block.header, &mut remaining_gas, tx_sender)?;
         let account_updates = vm.get_state_transitions()?;
         prover_db.apply_account_updates(&account_updates)?;

crates/blockchain/blockchain.rs

@@ -26,7 +26,7 @@ use ethrex_common::{Address, H256, TrieLogger};
 use ethrex_metrics::metrics;
 use ethrex_storage::{Store, UpdateBatch, error::StoreError, hash_address, hash_key};
 use ethrex_vm::backends::levm::db::DatabaseLogger;
-use ethrex_vm::{BlockExecutionResult, DynVmDatabase, Evm, EvmEngine};
+use ethrex_vm::{BlockExecutionResult, DynVmDatabase, Evm, EvmEngine, EvmError};
 use mempool::Mempool;
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -45,6 +45,13 @@ use ethrex_common::types::BlobsBundle;
 //TODO: Implement a struct Chain or BlockChain to encapsulate
 //functionality and canonical chain state and config
 
+#[derive(Debug, Clone, Default)]
+pub enum BlockchainType {
+    #[default]
+    L1,
+    L2,
+}
+
 #[derive(Debug)]
 pub struct Blockchain {
     pub evm_engine: EvmEngine,
@@ -54,6 +61,7 @@ pub struct Blockchain {
     /// This will be set to true once the initial sync has taken place and wont be set to false after
     /// This does not reflect whether there is an ongoing sync process
     is_synced: AtomicBool,
+    pub r#type: BlockchainType,
 }
 
 #[derive(Debug, Clone)]
@@ -62,12 +70,13 @@ pub struct BatchBlockProcessingFailure {
     pub failed_block_hash: H256,
 }
 impl Blockchain {
-    pub fn new(evm_engine: EvmEngine, store: Store) -> Self {
+    pub fn new(evm_engine: EvmEngine, store: Store, blockchain_type: BlockchainType) -> Self {
         Self {
             evm_engine,
             storage: store,
             mempool: Mempool::new(),
             is_synced: AtomicBool::new(false),
+            r#type: blockchain_type,
         }
     }
 
@@ -77,6 +86,7 @@ impl Blockchain {
             storage: store,
             mempool: Mempool::new(),
             is_synced: AtomicBool::new(false),
+            r#type: BlockchainType::default(),
         }
     }
 
@@ -98,7 +108,7 @@ impl Blockchain {
         validate_block(block, &parent_header, &chain_config, ELASTICITY_MULTIPLIER)?;
 
         let vm_db = StoreVmDatabase::new(self.storage.clone(), block.header.parent_hash);
-        let mut vm = Evm::new(self.evm_engine, vm_db);
+        let mut vm = self.new_evm(vm_db)?;
         let execution_result = vm.execute_block(block)?;
         let account_updates = vm.get_state_transitions()?;
 
@@ -170,7 +180,10 @@ impl Blockchain {
             let vm_db: DynVmDatabase =
                 Box::new(StoreVmDatabase::new(self.storage.clone(), parent_hash));
             let logger = Arc::new(DatabaseLogger::new(Arc::new(Mutex::new(Box::new(vm_db)))));
-            let mut vm = Evm::new_from_db(logger.clone());
+            let mut vm = match self.r#type {
+                BlockchainType::L1 => Evm::new_from_db_for_l1(logger.clone()),
+                BlockchainType::L2 => Evm::new_from_db_for_l2(logger.clone()),
+            };
 
             // Re-execute block with logger
             vm.execute_block(block)?;
@@ -442,7 +455,7 @@ impl Blockchain {
             first_block_header.parent_hash,
             block_hash_cache,
         );
-        let mut vm = Evm::new(self.evm_engine, vm_db);
+        let mut vm = self.new_evm(vm_db).map_err(|e| (e.into(), None))?;
 
         let blocks_len = blocks.len();
         let mut all_receipts: Vec<(BlockHash, Vec<Receipt>)> = Vec::with_capacity(blocks_len);
@@ -776,6 +789,14 @@ impl Blockchain {
 
         Ok(result)
     }
+
+    pub fn new_evm(&self, vm_db: StoreVmDatabase) -> Result<Evm, EvmError> {
+        let evm = match self.r#type {
+            BlockchainType::L1 => Evm::new_for_l1(self.evm_engine, vm_db),
+            BlockchainType::L2 => Evm::new_for_l2(self.evm_engine, vm_db)?,
+        };
+        Ok(evm)
+    }
 }
 
 pub fn validate_requests_hash(