evm: add unit tests for ConfigureEvm trait

crates/ethereum/evm/src/lib.rs

@@ -123,22 +123,45 @@ impl ConfigureEvm for EthEvmConfig {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use reth_chainspec::ChainSpec;
+    use reth_chainspec::{Chain, ChainSpec};
+    use reth_evm::execute::ProviderError;
     use reth_primitives::{
         revm_primitives::{BlockEnv, CfgEnv, SpecId},
-        Header, U256,
+        Genesis, Header, B256, KECCAK_EMPTY, U256,
     };
-    use revm_primitives::CfgEnvWithHandlerCfg;
+    use reth_revm::{
+        db::{CacheDB, EmptyDBTyped},
+        JournaledState,
+    };
+    use revm_primitives::{CfgEnvWithHandlerCfg, EnvWithHandlerCfg, HandlerCfg};
+    use std::collections::HashSet;
 
     #[test]
-    #[ignore]
     fn test_fill_cfg_and_block_env() {
+        // Create a new configuration environment
         let mut cfg_env = CfgEnvWithHandlerCfg::new_with_spec_id(CfgEnv::default(), SpecId::LATEST);
+
+        // Create a default block environment
         let mut block_env = BlockEnv::default();
+
+        // Create a default header
         let header = Header::default();
-        let chain_spec = ChainSpec::default();
+
+        // Build the ChainSpec for Ethereum mainnet, activating London, Paris, and Shanghai
+        // hardforks
+        let chain_spec = ChainSpec::builder()
+            .chain(Chain::mainnet())
+            .genesis(Genesis::default())
+            .london_activated()
+            .paris_activated()
+            .shanghai_activated()
+            .build();
+
+        // Define the total difficulty as zero (default)
         let total_difficulty = U256::ZERO;
 
+        // Use the `EthEvmConfig` to fill the `cfg_env` and `block_env` based on the ChainSpec,
+        // Header, and total difficulty
         EthEvmConfig::default().fill_cfg_and_block_env(
             &mut cfg_env,
             &mut block_env,
@@ -147,6 +170,136 @@ mod tests {
             total_difficulty,
         );
 
+        // Assert that the chain ID in the `cfg_env` is correctly set to the chain ID of the
+        // ChainSpec
         assert_eq!(cfg_env.chain_id, chain_spec.chain().id());
     }
+
+    #[test]
+    fn test_evm_configure() {
+        // Create a default `EthEvmConfig`
+        let evm_config = EthEvmConfig::default();
+
+        // Initialize an empty database wrapped in CacheDB
+        let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
+
+        // Create an EVM instance using the configuration and the database
+        let evm = evm_config.evm(db);
+
+        // Check that the EVM environment is initialized with default values
+        assert_eq!(evm.context.evm.inner.env, Box::default());
+
+        // Latest spec ID and no warm preloaded addresses
+        assert_eq!(
+            evm.context.evm.inner.journaled_state,
+            JournaledState::new(SpecId::LATEST, HashSet::default())
+        );
+
+        // Ensure that the accounts database is empty
+        assert!(evm.context.evm.inner.db.accounts.is_empty());
+
+        // Ensure that the block hashes database is empty
+        assert!(evm.context.evm.inner.db.block_hashes.is_empty());
+
+        // Verify that there are two default contracts in the contracts database
+        assert_eq!(evm.context.evm.inner.db.contracts.len(), 2);
+        assert!(evm.context.evm.inner.db.contracts.contains_key(&KECCAK_EMPTY));
+        assert!(evm.context.evm.inner.db.contracts.contains_key(&B256::ZERO));
+
+        // Ensure that the logs database is empty
+        assert!(evm.context.evm.inner.db.logs.is_empty());
+
+        // Ensure that there are no valid authorizations in the EVM context
+        assert!(evm.context.evm.inner.valid_authorizations.is_empty());
+    }
+
+    #[test]
+    fn test_evm_with_env_default_spec() {
+        let evm_config = EthEvmConfig::default();
+
+        let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
+
+        let env_with_handler = EnvWithHandlerCfg::default();
+
+        let evm = evm_config.evm_with_env(db, env_with_handler.clone());
+
+        // Check that the EVM environment
+        assert_eq!(evm.context.evm.env, env_with_handler.env);
+
+        // Default spec ID
+        assert_eq!(evm.handler.spec_id(), SpecId::LATEST);
+    }
+
+    #[test]
+    fn test_evm_with_env_custom_cfg() {
+        let evm_config = EthEvmConfig::default();
+
+        let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
+
+        // Create a custom configuration environment with a chain ID of 111
+        let cfg = CfgEnv::default().with_chain_id(111);
+
+        let env_with_handler = EnvWithHandlerCfg {
+            env: Box::new(Env {
+                cfg: cfg.clone(),
+                block: BlockEnv::default(),
+                tx: TxEnv::default(),
+            }),
+            handler_cfg: Default::default(),
+        };
+
+        let evm = evm_config.evm_with_env(db, env_with_handler);
+
+        // Check that the EVM environment is initialized with the custom environment
+        assert_eq!(evm.context.evm.inner.env.cfg, cfg);
+
+        // Default spec ID
+        assert_eq!(evm.handler.spec_id(), SpecId::LATEST);
+    }
+
+    #[test]
+    fn test_evm_with_env_custom_block_and_tx() {
+        let evm_config = EthEvmConfig::default();
+
+        let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
+
+        // Create customs block and tx env
+        let block = BlockEnv {
+            basefee: U256::from(1000),
+            gas_limit: U256::from(10_000_000),
+            number: U256::from(42),
+            ..Default::default()
+        };
+        let tx = TxEnv { gas_limit: 5_000_000, gas_price: U256::from(50), ..Default::default() };
+
+        let env_with_handler = EnvWithHandlerCfg {
+            env: Box::new(Env { cfg: CfgEnv::default(), block, tx }),
+            handler_cfg: Default::default(),
+        };
+
+        let evm = evm_config.evm_with_env(db, env_with_handler.clone());
+
+        // Verify that the block and transaction environments are set correctly
+        assert_eq!(evm.context.evm.env.block, env_with_handler.env.block);
+        assert_eq!(evm.context.evm.env.tx, env_with_handler.env.tx);
+
+        // Default spec ID
+        assert_eq!(evm.handler.spec_id(), SpecId::LATEST);
+    }
+
+    #[test]
+    fn test_evm_with_spec_id() {
+        let evm_config = EthEvmConfig::default();
+
+        let db = CacheDB::<EmptyDBTyped<ProviderError>>::default();
+
+        let handler_cfg = HandlerCfg { spec_id: SpecId::CONSTANTINOPLE, ..Default::default() };
+
+        let env_with_handler = EnvWithHandlerCfg { env: Box::new(Env::default()), handler_cfg };
+
+        let evm = evm_config.evm_with_env(db, env_with_handler);
+
+        // Check that the spec ID is setup properly
+        assert_eq!(evm.handler.spec_id(), SpecId::CONSTANTINOPLE);
+    }
 }