Struct OpEvm

pub struct OpEvm<CTX, INSP, I = EthInstructions<EthInterpreter, CTX>, P = OpPrecompiles, F = EthFrame<EthInterpreter>>(pub Evm<CTX, INSP, I, P, F>);

Optimism EVM extends the Evm type with Optimism specific types and logic.

Tuple Fields

0: Evm<CTX, INSP, I, P, F>

Inner EVM type.

Implementations

impl<CTX: ContextTr, INSP> OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, OpPrecompiles>

pub fn new(ctx: CTX, inspector: INSP) -> Self

Create a new Optimism EVM.

impl<CTX, INSP, I, P> OpEvm<CTX, INSP, I, P>

pub fn with_inspector<OINSP>(self, inspector: OINSP) -> OpEvm<CTX, OINSP, I, P>

Consumed self and returns a new Evm type with given Inspector.

pub fn with_precompiles<OP>(self, precompiles: OP) -> OpEvm<CTX, INSP, I, OP>

Consumes self and returns a new Evm type with given Precompiles.

pub fn into_inspector(self) -> INSP

Consumes self and returns the inner Inspector.

Trait Implementations

impl<CTX: Clone, INSP: Clone, I: Clone, P: Clone, F: Clone> Clone for OpEvm<CTX, INSP, I, P, F>

fn clone(&self) -> OpEvm<CTX, INSP, I, P, F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<CTX: Debug, INSP: Debug, I: Debug, P: Debug, F: Debug> Debug for OpEvm<CTX, INSP, I, P, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<CTX, INSP, I, P> EvmTr for OpEvm<CTX, INSP, I, P, EthFrame<EthInterpreter>>

where CTX: ContextTr, I: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, P: PrecompileProvider<CTX, Output = InterpreterResult>,

fn frame_return_result( &mut self, result: <Self::Frame as FrameTr>::FrameResult, ) -> Result<Option<<Self::Frame as FrameTr>::FrameResult>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

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.

type Context = CTX

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

type Instructions = I

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = P

The type containing the available precompiled contracts

type Frame = EthFrame

The type containing the frame

fn ctx(&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.

fn frame_init( &mut self, frame_input: <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 frame_run( &mut self, ) -> Result<FrameInitOrResult<Self::Frame>, ContextError<<<Self::Context as ContextTr>::Db as Database>::Error>>

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

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

Returns a mutable reference to the execution context

impl<CTX, INSP, PRECOMPILE> ExecuteCommitEvm for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>

where CTX: OpContextTr<Db: DatabaseCommit> + ContextSetters, PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,

fn commit(&mut self, state: Self::State)

Commit the state.

fn commit_inner(&mut self)

Finalize the state and commit it to the database.

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

Transact the transaction and commit to the state.

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

Transact multiple transactions and commit to the state.

fn replay_commit(&mut self) -> Result<Self::ExecutionResult, Self::Error>

Replay the transaction and commit to the state.

impl<CTX, INSP, PRECOMPILE> ExecuteEvm for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>

where CTX: OpContextTr + ContextSetters, PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,

type Tx = <CTX as ContextTr>::Tx

Transaction type.

type Block = <CTX as ContextTr>::Block

Block type.

type State = HashMap<Address, Account>

Output state type representing changes after execution.

type Error = EVMError<<<CTX as ContextTr>::Db as Database>::Error, OpTransactionError>

Error type

type ExecutionResult = ExecutionResult<OpHaltReason>

Output of transaction execution.

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

Set the block.

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 replay( &mut self, ) -> Result<ExecResultAndState<Self::ExecutionResult, Self::State>, 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>, 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>, Self::Error>

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

impl<CTX, INSP, PRECOMPILE> InspectCommitEvm for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>

where CTX: OpContextTr<Journal: JournalExt, Db: DatabaseCommit> + ContextSetters, INSP: Inspector<CTX, EthInterpreter>, PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,

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

Inspect the EVM with the current inspector and previous transaction by replaying,similar to InspectEvm::inspect_tx and commit the state diff to the database.

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

Inspect the EVM with the given transaction and inspector similar to InspectEvm::inspect and commit the state diff to the database.

impl<CTX, INSP, PRECOMPILE> InspectEvm for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>

where CTX: OpContextTr<Journal: JournalExt> + ContextSetters, INSP: Inspector<CTX, EthInterpreter>, PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,

type Inspector = INSP

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<CTX, INSP, I, P> InspectorEvmTr for OpEvm<CTX, INSP, I, P>

where CTX: ContextTr<Journal: JournalExt> + ContextSetters, I: InstructionProvider<Context = CTX, InterpreterTypes = EthInterpreter>, P: PrecompileProvider<CTX, Output = InterpreterResult>, INSP: Inspector<CTX, I::InterpreterTypes>,

type Inspector = INSP

The inspector type used for EVM execution inspection.

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<CTX, INSP, PRECOMPILE> SystemCallEvm for OpEvm<CTX, INSP, EthInstructions<EthInterpreter, CTX>, PRECOMPILE>

where CTX: OpContextTr<Tx: SystemCallTx> + ContextSetters, PRECOMPILE: PrecompileProvider<CTX, Output = InterpreterResult>,

fn transact_system_call_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 transact_system_call( &mut self, system_contract_address: Address, data: Bytes, ) -> Result<Self::ExecutionResult, Self::Error>

Calls [SystemCallEvm::transact_system_call_with_caller] 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>

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>

Calls [SystemCallEvm::transact_system_call_with_caller] and finalize functions.