all integrated

Author: rakita

Cargo.lock

@@ -1,10 +1,10 @@
 use clap::Parser;
 use database::BenchmarkDB;
-use inspector::{inspect_main, inspector_context::InspectorContext, inspectors::TracerEip3155};
+use inspector::{exec::InspectEvm, inspectors::TracerEip3155};
 use revm::{
     bytecode::{Bytecode, BytecodeDecodeError},
     primitives::{address, hex, Address, TxKind},
-    transact_main, Context, Database,
+    transact_main, Context, Database, ExecuteEvm,
 };
 use std::io::Error as IoError;
 use std::path::PathBuf;
@@ -94,18 +94,16 @@ impl Cmd {
             let bench_options = microbench::Options::default().time(Duration::from_secs(3));
 
             microbench::bench(&bench_options, "Run bytecode", || {
-                let _ = transact_main(&mut ctx).unwrap();
+                let _ = ctx.exec_previous().unwrap();
             });
 
             return Ok(());
         }
 
         let out = if self.trace {
-            inspect_main(&mut InspectorContext::new(
-                &mut ctx,
-                TracerEip3155::new(Box::new(std::io::stdout())),
-            ))
-            .map_err(|_| Errors::EVMError)?
+            let inspector = TracerEip3155::new(Box::new(std::io::stdout()));
+            ctx.inspect_previous(inspector)
+                .map_err(|_| Errors::EVMError)?
         } else {
             let out = transact_main(&mut ctx).map_err(|_| Errors::EVMError)?;
             println!("Result: {:#?}", out.result);

bins/revme/src/cmd/evmrunner.rs

@@ -4,9 +4,7 @@ use super::{
 };
 use database::State;
 use indicatif::{ProgressBar, ProgressDrawTarget};
-use inspector::{
-    inspect_main_commit, inspector_context::InspectorContext, inspectors::TracerEip3155,
-};
+use inspector::{exec::InspectCommitEvm, inspectors::TracerEip3155};
 use revm::{
     bytecode::Bytecode,
     context::{block::BlockEnv, cfg::CfgEnv, tx::TxEnv},
@@ -18,7 +16,7 @@ use revm::{
     database_interface::EmptyDB,
     primitives::{keccak256, Bytes, TxKind, B256},
     specification::{eip4844::TARGET_BLOB_GAS_PER_BLOCK_CANCUN, hardfork::SpecId},
-    transact_main_commit, Context,
+    Context, ExecuteCommitEvm,
 };
 use serde_json::json;
 use statetest_types::{SpecName, Test, TestSuite};
@@ -421,21 +419,20 @@ pub fn execute_test_suite(
 
                 // Do the deed
                 let (e, exec_result) = if trace {
-                    let mut ctx = &mut InspectorContext::new(
-                        Context::builder()
-                            .with_block(&block)
-                            .with_tx(&tx)
-                            .with_cfg(&cfg)
-                            .with_db(&mut state),
-                        TracerEip3155::new(Box::new(stderr())).without_summary(),
-                    );
+                    let mut ctx = Context::builder()
+                        .with_block(&block)
+                        .with_tx(&tx)
+                        .with_cfg(&cfg)
+                        .with_db(&mut state);
 
                     let timer = Instant::now();
-                    let res = inspect_main_commit(&mut ctx);
+                    let res = ctx.inspect_commit_previous(
+                        TracerEip3155::new(Box::new(stderr())).without_summary(),
+                    );
                     *elapsed.lock().unwrap() += timer.elapsed();
 
                     let spec = cfg.spec();
-                    let db = &mut ctx.inner.journaled_state.database;
+                    let db = &mut ctx.journaled_state.database;
                     // Dump state and traces if test failed
                     let output = check_evm_execution(
                         &test,
@@ -452,7 +449,7 @@ pub fn execute_test_suite(
                     (e, res)
                 } else {
                     let timer = Instant::now();
-                    let res = transact_main_commit(&mut ctx);
+                    let res = ctx.exec_commit_previous();
                     *elapsed.lock().unwrap() += timer.elapsed();
 
                     let spec = cfg.spec();
@@ -494,24 +491,20 @@ pub fn execute_test_suite(
 
                 println!("\nTraces:");
 
-                let mut ctx = InspectorContext::new(
-                    Context::builder()
-                        .with_db(&mut state)
-                        .with_block(&block)
-                        .with_tx(&tx)
-                        .with_cfg(&cfg),
+                let mut ctx = Context::builder()
+                    .with_db(&mut state)
+                    .with_block(&block)
+                    .with_tx(&tx)
+                    .with_cfg(&cfg);
+
+                let _ = ctx.inspect_commit_previous(
                     TracerEip3155::new(Box::new(stderr())).without_summary(),
                 );
 
-                let _ = inspect_main_commit(&mut ctx);
-
                 println!("\nExecution result: {exec_result:#?}");
                 println!("\nExpected exception: {:?}", test.expect_exception);
                 println!("\nState before: {cache_state:#?}");
-                println!(
-                    "\nState after: {:#?}",
-                    ctx.inner.journaled_state.database.cache
-                );
+                println!("\nState after: {:#?}", ctx.journaled_state.database.cache);
                 println!("\nSpecification: {:?}", cfg.spec);
                 println!("\nTx: {tx:#?}");
                 println!("Block: {block:#?}");

bins/revme/src/cmd/statetest/runner.rs

@@ -1,32 +1,87 @@
 mod dummy;
 
 pub use crate::journaled_state::StateLoad;
+use database_interface::Database;
 pub use dummy::DummyHost;
 
-use crate::{journaled_state::AccountLoad, BlockGetter, CfgGetter, TransactionGetter};
-use auto_impl::auto_impl;
-use primitives::{Address, Bytes, Log, B256, U256};
+use crate::{
+    journaled_state::AccountLoad, Block, BlockGetter, CfgGetter, Journal, JournalGetter,
+    TransactionGetter,
+};
+use primitives::{Address, Bytes, Log, B256, BLOCK_HASH_HISTORY, U256};
+use std::boxed::Box;
 
 /// EVM context host.
-#[auto_impl(&mut, Box)]
-pub trait Host: TransactionGetter + BlockGetter + CfgGetter {
-    /// Load an account code.
-    fn load_account_delegated(&mut self, address: Address) -> Option<StateLoad<AccountLoad>>;
+pub trait Host: JournalGetter + TransactionGetter + BlockGetter + CfgGetter {
+    fn set_error(
+        &mut self,
+        error: <<<Self as JournalGetter>::Journal as Journal>::Database as Database>::Error,
+    );
 
     /// Gets the block hash of the given block `number`.
-    fn block_hash(&mut self, number: u64) -> Option<B256>;
+    fn block_hash(&mut self, requested_number: u64) -> Option<B256> {
+        let block_number = self.block().number();
+
+        let Some(diff) = block_number.checked_sub(requested_number) else {
+            return Some(B256::ZERO);
+        };
+
+        // blockhash should push zero if number is same as current block number.
+        if diff == 0 {
+            return Some(B256::ZERO);
+        }
+
+        if diff <= BLOCK_HASH_HISTORY {
+            return self
+                .journal()
+                .db()
+                .block_hash(requested_number)
+                .map_err(|e| self.set_error(e))
+                .ok();
+        }
+
+        Some(B256::ZERO)
+    }
+
+    fn load_account_delegated(&mut self, address: Address) -> Option<StateLoad<AccountLoad>> {
+        self.journal()
+            .load_account_delegated(address)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Gets balance of `address` and if the account is cold.
-    fn balance(&mut self, address: Address) -> Option<StateLoad<U256>>;
+    fn balance(&mut self, address: Address) -> Option<StateLoad<U256>> {
+        self.journal()
+            .load_account(address)
+            .map(|acc| acc.map(|a| a.info.balance))
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Gets code of `address` and if the account is cold.
-    fn code(&mut self, address: Address) -> Option<StateLoad<Bytes>>;
+    fn code(&mut self, address: Address) -> Option<StateLoad<Bytes>> {
+        self.journal()
+            .code(address)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Gets code hash of `address` and if the account is cold.
-    fn code_hash(&mut self, address: Address) -> Option<StateLoad<B256>>;
+    fn code_hash(&mut self, address: Address) -> Option<StateLoad<B256>> {
+        self.journal()
+            .code_hash(address)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Gets storage value of `address` at `index` and if the account is cold.
-    fn sload(&mut self, address: Address, index: U256) -> Option<StateLoad<U256>>;
+    fn sload(&mut self, address: Address, index: U256) -> Option<StateLoad<U256>> {
+        self.journal()
+            .sload(address, index)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Sets storage value of account address at index.
     ///
@@ -36,23 +91,57 @@ pub trait Host: TransactionGetter + BlockGetter + CfgGetter {
         address: Address,
         index: U256,
         value: U256,
-    ) -> Option<StateLoad<SStoreResult>>;
+    ) -> Option<StateLoad<SStoreResult>> {
+        self.journal()
+            .sstore(address, index, value)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
 
     /// Gets the transient storage value of `address` at `index`.
-    fn tload(&mut self, address: Address, index: U256) -> U256;
+    fn tload(&mut self, address: Address, index: U256) -> U256 {
+        self.journal().tload(address, index)
+    }
 
     /// Sets the transient storage value of `address` at `index`.
-    fn tstore(&mut self, address: Address, index: U256, value: U256);
+    fn tstore(&mut self, address: Address, index: U256, value: U256) {
+        self.journal().tstore(address, index, value)
+    }
 
     /// Emits a log owned by `address` with given `LogData`.
-    fn log(&mut self, log: Log);
+    fn log(&mut self, log: Log) {
+        self.journal().log(log);
+    }
 
     /// Marks `address` to be deleted, with funds transferred to `target`.
     fn selfdestruct(
         &mut self,
         address: Address,
         target: Address,
-    ) -> Option<StateLoad<SelfDestructResult>>;
+    ) -> Option<StateLoad<SelfDestructResult>> {
+        self.journal()
+            .selfdestruct(address, target)
+            .map_err(|e| self.set_error(e))
+            .ok()
+    }
+}
+
+impl<T: Host> Host for &mut T {
+    fn set_error(
+        &mut self,
+        error: <<<Self as JournalGetter>::Journal as Journal>::Database as Database>::Error,
+    ) {
+        (**self).set_error(error)
+    }
+}
+
+impl<T: Host> Host for Box<T> {
+    fn set_error(
+        &mut self,
+        error: <<<Self as JournalGetter>::Journal as Journal>::Database as Database>::Error,
+    ) {
+        (**self).set_error(error)
+    }
 }
 
 /// Represents the result of an `sstore` operation.