Struct ArbEvm 

pub struct ArbEvm<DB: Database, I> { /* private fields */ }

Arbitrum EVM with frame-level Stylus dispatch and custom opcodes.

Implements [EvmTr] directly to intercept Stylus WASM calls in frame_init before they reach the precompile provider.

Implementations

impl<DB, I> ArbEvm<DB, I>

where DB: Database,

pub fn new( inner: Evm<EthEvmContext<DB>, I, EthInstructions<EthInterpreter, EthEvmContext<DB>>, ArbPrecompilesMap, EthFrame>, inspect: bool, ) -> Self

pub fn into_inner( self, ) -> Evm<EthEvmContext<DB>, I, EthInstructions<EthInterpreter, EthEvmContext<DB>>, ArbPrecompilesMap, EthFrame>

pub fn ctx(&self) -> &EthEvmContext<DB>

pub fn ctx_mut(&mut self) -> &mut EthEvmContext<DB>

pub fn precompiles_mut(&mut self) -> &mut ArbPrecompilesMap

Methods from Deref<Target = EthEvmContext<DB>>

pub fn modify_block<F>(&mut self, f: F)

where F: FnOnce(&mut BLOCK),

Modifies the context block.

pub fn modify_tx<F>(&mut self, f: F)

where F: FnOnce(&mut TX),

Modifies the context transaction.

pub fn modify_cfg<F>(&mut self, f: F)

where F: FnOnce(&mut CFG),

Modifies the context configuration.

pub fn modify_chain<F>(&mut self, f: F)

where F: FnOnce(&mut CHAIN),

Modifies the context chain.

pub fn modify_db<F>(&mut self, f: F)

where F: FnOnce(&mut DB),

Modifies the context database.

pub fn modify_journal<F>(&mut self, f: F)

where F: FnOnce(&mut JOURNAL),

Modifies the context journal.

pub fn modify_local<F>(&mut self, f: F)

where F: FnOnce(&mut LOCAL),

Modifies the local context.

Trait Implementations

impl<DB: Database, I> Deref for ArbEvm<DB, I>

type Target = Context<BlockEnv, TxEnv, CfgEnv, DB>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<DB: Database, I> DerefMut for ArbEvm<DB, I>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<DB, I> Evm for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>, Journal<DB>: JournalExt,

type DB = DB

Database type held by the EVM.

type Tx = ArbTransaction

The transaction object that the EVM will execute.

type Error = EVMError<<DB as Database>::Error>

Error type returned by EVM. Contains either errors related to invalid transactions or internal irrecoverable execution errors.

type HaltReason = HaltReason

Halt reason. Enum over all possible reasons for halting the execution. When execution halts, it means that transaction is valid, however, it’s execution was interrupted (e.g because of running out of gas or overflowing stack).

type Spec = SpecId

Identifier of the EVM specification. EVM is expected to use this identifier to determine which features are enabled.

type Precompiles = PrecompilesMap

Precompiles used by the EVM.

type Inspector = I

Evm inspector.

type BlockEnv = BlockEnv

Block environment used by the EVM.

fn block(&self) -> &BlockEnv

Reference to [Evm::BlockEnv].

fn chain_id(&self) -> u64

Returns the chain ID of the environment.

fn transact_raw( &mut self, tx: Self::Tx, ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>

Executes a transaction and returns the outcome.

fn transact_system_call( &mut self, caller: Address, contract: Address, data: Bytes, ) -> Result<ResultAndState<Self::HaltReason>, Self::Error>

Executes a system call.

fn finish(self) -> (Self::DB, EvmEnv<Self::Spec>)

Consumes the EVM and returns the inner [EvmEnv].

fn set_inspector_enabled(&mut self, enabled: bool)

Determines whether additional transactions should be inspected or not.

fn components(&self) -> (&Self::DB, &Self::Inspector, &Self::Precompiles)

Provides immutable references to the database, inspector and precompiles.

fn components_mut( &mut self, ) -> (&mut Self::DB, &mut Self::Inspector, &mut Self::Precompiles)

Provides mutable references to the database, inspector and precompiles.

fn transact( &mut self, tx: impl IntoTxEnv<Self::Tx>, ) -> Result<ExecResultAndState<ExecutionResult<Self::HaltReason>>, Self::Error>

Same as [Evm::transact_raw], but takes any type implementing [IntoTxEnv].

fn db(&self) -> &Self::DB

Returns an immutable reference to the underlying database.

fn db_mut(&mut self) -> &mut Self::DB

Returns a mutable reference to the underlying database.

fn transact_commit( &mut self, tx: impl IntoTxEnv<Self::Tx>, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

where Self::DB: DatabaseCommit,

Executes a transaction and commits the state changes to the underlying database.

fn into_db(self) -> Self::DB

where Self: Sized,

Consumes the EVM and returns the inner database.

fn into_env(self) -> EvmEnv<Self::Spec, Self::BlockEnv>

where Self: Sized,

Consumes the EVM and returns the inner [EvmEnv].

fn enable_inspector(&mut self)

Enables the configured inspector.

fn disable_inspector(&mut self)

Disables the configured inspector.

fn precompiles(&self) -> &Self::Precompiles

Getter of precompiles.

fn precompiles_mut(&mut self) -> &mut Self::Precompiles

Mutable getter of precompiles.

fn inspector(&self) -> &Self::Inspector

Getter of inspector.

fn inspector_mut(&mut self) -> &mut Self::Inspector

Mutable getter of inspector.

impl<DB, I> EvmTr for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>,

type Context = Context<BlockEnv, TxEnv, CfgEnv, DB>

The context type that implements ContextTr to provide access to execution state

type Instructions = EthInstructions<EthInterpreter, Context<BlockEnv, TxEnv, CfgEnv, DB>>

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = ArbPrecompilesMap

The type containing the available precompiled contracts

type Frame = EthFrame

The type containing the frame

fn all( &self, ) -> (&Self::Context, &Self::Instructions, &Self::Precompiles, &FrameStack<Self::Frame>)

Returns a tuple of references to the context, the frame and the instructions.

fn all_mut( &mut self, ) -> (&mut Self::Context, &mut Self::Instructions, &mut Self::Precompiles, &mut FrameStack<Self::Frame>)

Returns a tuple of mutable references to the context, the frame and the instructions.

fn frame_init( &mut self, frame_input: FrameInit, ) -> Result<ItemOrResult<&mut Self::Frame, FrameResult>, ContextDbError<Self::Context>>

Initializes the frame for the given frame input. Frame is pushed to the frame stack.

fn frame_run( &mut self, ) -> Result<ItemOrResult<FrameInit, FrameResult>, ContextDbError<Self::Context>>

Run the frame from the top of the stack. Returns the frame init or result.

fn frame_return_result( &mut self, result: FrameResult, ) -> Result<Option<FrameResult>, ContextDbError<Self::Context>>

Returns the result of the frame to the caller. Frame is popped from the frame stack. Consumes the frame result or returns it if there is more frames to run.

fn ctx(&mut self) -> &mut Self::Context

Returns a mutable reference to the execution context

fn ctx_mut(&mut self) -> &mut Self::Context

Returns a mutable reference to the execution context

fn ctx_ref(&self) -> &Self::Context

Returns an immutable reference to the execution context

fn ctx_instructions(&mut self) -> (&mut Self::Context, &mut Self::Instructions)

Returns mutable references to both the context and instruction set. This enables atomic access to both components when needed.

fn ctx_precompiles(&mut self) -> (&mut Self::Context, &mut Self::Precompiles)

Returns mutable references to both the context and precompiles. This enables atomic access to both components when needed.

fn frame_stack(&mut self) -> &mut FrameStack<Self::Frame>

Returns a mutable reference to the frame stack.

impl<DB, I> ExecuteEvm for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>,

type ExecutionResult = ExecutionResult

Output of transaction execution.

type State = HashMap<Address, Account, DefaultHashBuilder>

Output state type representing changes after execution.

type Error = EVMError<<DB as Database>::Error>

Error type

type Tx = TxEnv

Transaction type.

type Block = BlockEnv

Block type.

fn transact_one( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Execute transaction and store state inside journal. Returns output of transaction execution.

fn finalize(&mut self) -> Self::State

Finalize execution, clearing the journal and returning the accumulated state changes.

fn set_block(&mut self, block: Self::Block)

Set the block.

fn replay(&mut self) -> Result<ResultAndState<HaltReason>, Self::Error>

Execute previous transaction and finalize it.

fn transact( &mut self, tx: Self::Tx, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Transact the given transaction and finalize in a single operation.

fn transact_many( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<Vec<Self::ExecutionResult>, TransactionIndexedError<Self::Error>>

Execute multiple transactions without finalizing the state.

fn transact_many_finalize( &mut self, txs: impl Iterator<Item = Self::Tx>, ) -> Result<ExecResultAndState<Vec<Self::ExecutionResult>, Self::State>, TransactionIndexedError<Self::Error>>

Execute multiple transactions and finalize the state in a single operation.

impl<DB, I> InspectEvm for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>, Journal<DB>: JournalExt,

type Inspector = I

The inspector type used for inspecting EVM execution.

fn set_inspector(&mut self, inspector: Self::Inspector)

Set the inspector for the EVM.

fn inspect_one_tx( &mut self, tx: Self::Tx, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the given transaction.

fn inspect_tx( &mut self, tx: Self::Tx, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Inspect the EVM and finalize the state.

fn inspect( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Inspect the EVM with the given inspector and transaction, and finalize the state.

fn inspect_one( &mut self, tx: Self::Tx, inspector: Self::Inspector, ) -> Result<Self::ExecutionResult, Self::Error>

Inspect the EVM with the given inspector and transaction.

impl<DB, I> InspectorEvmTr for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>, Journal<DB>: JournalExt,

type Inspector = I

The inspector type used for EVM execution inspection.

fn all_inspector( &self, ) -> (&Self::Context, &Self::Instructions, &Self::Precompiles, &FrameStack<Self::Frame>, &Self::Inspector)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn all_mut_inspector( &mut self, ) -> (&mut Self::Context, &mut Self::Instructions, &mut Self::Precompiles, &mut FrameStack<Self::Frame>, &mut Self::Inspector)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn inspector(&mut self) -> &mut Self::Inspector

Returns a mutable reference to the inspector.

fn ctx_inspector(&mut self) -> (&mut Self::Context, &mut Self::Inspector)

Returns a tuple of mutable references to the context and the inspector.

fn ctx_inspector_frame( &mut self, ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame)

Returns a tuple of mutable references to the context, the inspector and the frame.

fn ctx_inspector_frame_instructions( &mut self, ) -> (&mut Self::Context, &mut Self::Inspector, &mut Self::Frame, &mut Self::Instructions)

Returns a tuple of mutable references to the context, the inspector, the frame and the instructions.

fn inspect_frame_init( &mut self, frame_init: <Self::Frame as FrameTr>::FrameInit, ) -> Result<ItemOrResult<&mut Self::Frame, <Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Initializes the frame for the given frame input. Frame is pushed to the frame stack.

fn inspect_frame_run( &mut self, ) -> Result<ItemOrResult<<Self::Frame as FrameTr>::FrameInit, <Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

Run the frame from the top of the stack. Returns the frame init or result.

impl<DB, I> SystemCallEvm for ArbEvm<DB, I>

where DB: Database, I: Inspector<EthEvmContext<DB>, EthInterpreter>,

fn system_call_one_with_caller( &mut self, caller: Address, system_contract_address: Address, data: Bytes, ) -> Result<Self::ExecutionResult, Self::Error>

System call is a special transaction call that is used to call a system contract.

fn system_call_one( &mut self, system_contract_address: Address, data: Bytes, ) -> Result<Self::ExecutionResult, Self::Error>

System call is a special transaction call that is used to call a system contract.

fn system_call( &mut self, system_contract_address: Address, data: Bytes, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Internally calls [SystemCallEvm::system_call_with_caller].

fn system_call_with_caller( &mut self, caller: Address, system_contract_address: Address, data: Bytes, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

Internally calls [SystemCallEvm::system_call_one] and [ExecuteEvm::finalize] functions to obtain the changed state.

fn transact_system_call_with_caller( &mut self, caller: Address, system_contract_address: Address, data: Bytes, ) -> Result<Self::ExecutionResult, Self::Error>

👎Deprecated since 0.1.0: Use system_call_one_with_caller instead

System call is a special transaction call that is used to call a system contract.

fn transact_system_call( &mut self, system_contract_address: Address, data: Bytes, ) -> Result<Self::ExecutionResult, Self::Error>

👎Deprecated since 0.1.0: Use system_call_one instead

Calls [SystemCallEvm::system_call_one] with [SYSTEM_ADDRESS] as a caller.

fn transact_system_call_finalize( &mut self, system_contract_address: Address, data: Bytes, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

👎Deprecated since 0.1.0: Use system_call instead

Transact the system call and finalize.

fn transact_system_call_with_caller_finalize( &mut self, caller: Address, system_contract_address: Address, data: Bytes, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, Self::Error>

👎Deprecated since 0.1.0: Use system_call_with_caller instead

Calls [SystemCallEvm::system_call_one] and finalize functions.