add erc20 example and cleanup

bluealloy · Feb 7, 2025 · fff44da · fff44da
1 parent 404aeeb
commit fff44da
Show file tree

Hide file tree

Showing 10 changed files with 149 additions and 118 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -26,13 +26,13 @@ members = [
 
     # examples
     "examples/block_traces",
-    # "examples/cheatcode_inspector",
+    #"examples/cheatcode_inspector",
     "examples/contract_deployment",
     "examples/database_components",
     "examples/uniswap_get_reserves",
     "examples/uniswap_v2_usdc_swap",
-    # "examples/erc20_gas",
-    # "examples/custom_opcodes",
+    "examples/erc20_gas",
+    #"examples/custom_opcodes",
 ]
 resolver = "2"
 default-members = ["crates/revm"]

diff --git a/bins/revme/src/cmd/bench/analysis.rs b/bins/revme/src/cmd/bench/analysis.rs
@@ -13,22 +13,22 @@ pub fn run() {
     let bytecode = Bytecode::new_raw(Bytes::from(hex::decode(BYTES).unwrap()));
 
     // BenchmarkDB is dummy state that implements Database trait.
-    let mut context = Context::mainnet()
+    let context = Context::mainnet()
         .with_db(BenchmarkDB::new_bytecode(bytecode))
         .modify_tx_chained(|tx| {
             // Execution globals block hash/gas_limit/coinbase/timestamp..
             tx.caller = BENCH_CALLER;
             tx.kind = TxKind::Call(BENCH_TARGET);
-            //evm.env.tx.data = Bytes::from(hex::decode("30627b7c").unwrap());
             tx.data = bytes!("8035F0CE");
-        })
-        .build_mainnet();
+        });
+
+    let mut evm = context.build_mainnet();
 
     let time = Instant::now();
-    let _ = context.transact_previous();
+    let _ = evm.transact_previous();
     println!("First init: {:?}", time.elapsed());
 
     let time = Instant::now();
-    let _ = context.transact_previous();
+    let _ = evm.transact_previous();
     println!("Run: {:?}", time.elapsed());
 }
diff --git a/crates/context/Cargo.toml b/crates/context/Cargo.toml
@@ -30,6 +30,7 @@ database-interface.workspace = true
 state.workspace = true
 specification.workspace = true
 bytecode.workspace = true
+auto_impl.workspace = true
 
 # misc
 derive-where.workspace = true

diff --git a/crates/context/src/setters.rs b/crates/context/src/setters.rs
@@ -1,6 +1,8 @@
 use crate::Context;
+use auto_impl::auto_impl;
 use context_interface::{Block, Cfg, Database, Journal, Transaction};
 
+#[auto_impl(&mut, Box)]
 pub trait ContextSetters {
     type Tx: Transaction;
     type Block: Block;

diff --git a/crates/handler/src/lib.rs b/crates/handler/src/lib.rs
@@ -25,6 +25,8 @@ pub mod validation;
 pub use frame::{return_create, return_eofcreate, CtxTraitDbError, EthFrame, Frame};
 pub use frame_data::{FrameData, FrameResult};
 pub use handler::{inspect_instructions, EthHandler, EthTraitError, EvmTrait};
+pub use inspector::{Inspector, JournalExt};
 pub use item_or_result::{FrameInitOrResult, FrameOrResult, ItemOrResult};
 pub use mainnet_handler::MainnetHandler;
+pub use noop::NoOpInspector;
 pub use precompile_provider::{EthPrecompiles, PrecompileProvider};
diff --git a/crates/revm/src/mainnet_exec_inspect.rs b/crates/revm/src/mainnet_exec_inspect.rs
@@ -1,9 +1,10 @@
 use crate::{exec_inspect::ExecuteCommitEvm, ExecuteEvm};
 use crate::{InspectCommitEvm, InspectEvm};
-use context::{Cfg, Context, Evm};
+use context::setters::ContextSetters;
+use context::Evm;
 use context_interface::{
     result::{EVMError, ExecutionResult, HaltReason, InvalidTransaction, ResultAndState},
-    Block, ContextTrait, Database, Journal, Transaction,
+    ContextTrait, Database, Journal,
 };
 use database_interface::DatabaseCommit;
 use handler::inspector::JournalExt;
@@ -18,47 +19,38 @@ use primitives::Log;
 use state::EvmState;
 use std::vec::Vec;
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, INSP> ExecuteEvm
-    for Evm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-        EthPrecompiles<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-    >
+impl<CTX, INSP> ExecuteEvm
+    for Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles<CTX>>
 where
-    BLOCK: Block,
-    TX: Transaction,
-    CFG: Cfg,
-    DB: Database,
-    JOURNAL: Journal<Database = DB, FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>, EthInterpreter>,
+    CTX: ContextSetters
+        + ContextTrait<Journal: Journal<FinalOutput = (EvmState, Vec<Log>)> + JournalExt>,
+    INSP: Inspector<CTX, EthInterpreter>,
 {
-    type Output =
-        Result<ResultAndState<HaltReason>, EVMError<<DB as Database>::Error, InvalidTransaction>>;
+    type Output = Result<
+        ResultAndState<HaltReason>,
+        EVMError<<CTX::Db as Database>::Error, InvalidTransaction>,
+    >;
 
     fn transact_previous(&mut self) -> Self::Output {
         let mut t = MainnetHandler::<_, _, EthFrame<_, _, _>>::default();
         t.run(self)
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, INSP> ExecuteCommitEvm
-    for Evm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-        EthPrecompiles<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-    >
+impl<CTX, INSP> ExecuteCommitEvm
+    for Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles<CTX>>
 where
-    BLOCK: Block,
-    TX: Transaction,
-    CFG: Cfg,
-    DB: Database + DatabaseCommit,
-    JOURNAL: Journal<Database = DB, FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>, EthInterpreter>,
+    CTX: ContextSetters
+        + ContextTrait<
+            Journal: Journal<FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
+            Db: DatabaseCommit,
+        >,
+    INSP: Inspector<CTX, EthInterpreter>,
 {
-    type CommitOutput =
-        Result<ExecutionResult<HaltReason>, EVMError<<DB as Database>::Error, InvalidTransaction>>;
+    type CommitOutput = Result<
+        ExecutionResult<HaltReason>,
+        EVMError<<CTX::Db as Database>::Error, InvalidTransaction>,
+    >;
 
     fn transact_commit_previous(&mut self) -> Self::CommitOutput {
         self.transact_previous().map(|r| {
@@ -68,20 +60,12 @@ where
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, INSP> InspectEvm
-    for Evm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-        EthPrecompiles<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-    >
+impl<CTX, INSP> InspectEvm
+    for Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles<CTX>>
 where
-    BLOCK: Block,
-    TX: Transaction,
-    CFG: Cfg,
-    DB: Database,
-    JOURNAL: Journal<Database = DB, FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>, EthInterpreter>,
+    CTX: ContextSetters
+        + ContextTrait<Journal: Journal<FinalOutput = (EvmState, Vec<Log>)> + JournalExt>,
+    INSP: Inspector<CTX, EthInterpreter>,
 {
     type Inspector = INSP;
 
@@ -90,28 +74,23 @@ where
     }
 
     fn inspect_previous(&mut self) -> Self::Output {
-        let mut t = MainnetHandler::<_, EVMError<DB::Error, InvalidTransaction>, EthFrame<_, _, _>> {
+        let mut t = MainnetHandler::<_, _, EthFrame<_, _, _>> {
             _phantom: core::marker::PhantomData,
         };
 
         t.inspect_run(self)
     }
 }
 
-impl<BLOCK, TX, CFG, DB, JOURNAL, CHAIN, INSP> InspectCommitEvm
-    for Evm<
-        Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>,
-        INSP,
-        EthInstructions<EthInterpreter, Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-        EthPrecompiles<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>>,
-    >
+impl<CTX, INSP> InspectCommitEvm
+    for Evm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, EthPrecompiles<CTX>>
 where
-    BLOCK: Block,
-    TX: Transaction,
-    CFG: Cfg,
-    DB: Database + DatabaseCommit,
-    JOURNAL: Journal<Database = DB, FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
-    INSP: Inspector<Context<BLOCK, TX, CFG, DB, JOURNAL, CHAIN>, EthInterpreter>,
+    CTX: ContextSetters
+        + ContextTrait<
+            Journal: Journal<FinalOutput = (EvmState, Vec<Log>)> + JournalExt,
+            Db: DatabaseCommit,
+        >,
+    INSP: Inspector<CTX, EthInterpreter>,
 {
     fn inspect_commit_previous(&mut self) -> Self::CommitOutput {
         self.inspect_previous().map(|r| {
@@ -129,6 +108,7 @@ mod test {
         opcode::{PUSH1, SSTORE},
         Bytecode,
     };
+    use context::Context;
     use context_interface::TransactionType;
     use database::{BenchmarkDB, EEADDRESS, FFADDRESS};
     use primitives::{address, TxKind, U256};

diff --git a/examples/erc20_gas/src/exec.rs b/examples/erc20_gas/src/exec.rs
@@ -2,26 +2,54 @@ use crate::handler::Erc20MainetHandler;
 use revm::{
     context_interface::{
         result::{EVMError, ExecutionResult, HaltReason, InvalidTransaction, ResultAndState},
-        DatabaseGetter,
+        ContextTrait, Journal,
     },
-    database_interface::{Database, DatabaseCommit},
-    handler::handler::{EthContext, EthHandler},
+    database_interface::DatabaseCommit,
+    handler::{
+        instructions::InstructionProvider, CtxTraitDbError, EthFrame, EthHandler, EvmTrait,
+        PrecompileProvider,
+    },
+    interpreter::{interpreter::EthInterpreter, InterpreterAction, InterpreterResult},
+    primitives::Log,
+    state::EvmState,
 };
 
-pub fn transact_erc20evm<DB: Database, CTX: EthContext + DatabaseGetter<Database = DB>>(
-    ctx: &mut CTX,
-) -> Result<ResultAndState<HaltReason>, EVMError<<DB as Database>::Error, InvalidTransaction>> {
-    Erc20MainetHandler::<CTX, _>::new().run(ctx)
+pub fn transact_erc20evm<EVM>(
+    evm: &mut EVM,
+) -> Result<ResultAndState<HaltReason>, EVMError<CtxTraitDbError<EVM::Context>, InvalidTransaction>>
+where
+    EVM: EvmTrait<
+        Context: ContextTrait<Journal: Journal<FinalOutput = (EvmState, Vec<Log>)>>,
+        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Instructions: InstructionProvider<
+            Context = EVM::Context,
+            InterpreterTypes = EthInterpreter<()>,
+            Output = InterpreterAction,
+        >,
+    >,
+{
+    Erc20MainetHandler::<EVM, _, EthFrame<EVM, _, EthInterpreter>>::new().run(evm)
 }
 
-pub fn transact_erc20evm_commit<
-    DB: Database + DatabaseCommit,
-    CTX: EthContext + DatabaseGetter<Database = DB>,
->(
-    ctx: &mut CTX,
-) -> Result<ExecutionResult<HaltReason>, EVMError<<DB as Database>::Error, InvalidTransaction>> {
-    transact_erc20evm(ctx).map(|r| {
-        ctx.db().commit(r.state);
+pub fn transact_erc20evm_commit<EVM>(
+    evm: &mut EVM,
+) -> Result<ExecutionResult<HaltReason>, EVMError<CtxTraitDbError<EVM::Context>, InvalidTransaction>>
+where
+    EVM: EvmTrait<
+        Context: ContextTrait<
+            Journal: Journal<FinalOutput = (EvmState, Vec<Log>)>,
+            Db: DatabaseCommit,
+        >,
+        Precompiles: PrecompileProvider<Context = EVM::Context, Output = InterpreterResult>,
+        Instructions: InstructionProvider<
+            Context = EVM::Context,
+            InterpreterTypes = EthInterpreter<()>,
+            Output = InterpreterAction,
+        >,
+    >,
+{
+    transact_erc20evm(evm).map(|r| {
+        evm.ctx().db().commit(r.state);
         r.result
     })
 }