Struct JitEvm 

pub struct JitEvm<EVM, F = fn(B256, &[u8]) -> Option<EvmCompilerFn>> {
    inner: EVM,
    functions: B256Map<RawEvmCompilerFn>,
    on_miss: F,
}

Available on crate feature evm only.

Wrapper around any [EvmTr] that overrides [EvmTr::frame_run] to dispatch to JIT-compiled functions by code hash, falling back to the interpreter.

The F parameter is a lookup function (B256, &[u8]) -> Option<EvmCompilerFn> called when a code hash is not found in the precompiled map. Return None to fall back to the interpreter; return Some(f) to execute f (e.g. compile on the fly).

Fields

inner: EVM

functions: B256Map<RawEvmCompilerFn>

on_miss: F

Implementations

impl<EVM> JitEvm<EVM>

pub fn new(inner: EVM, functions: B256Map<RawEvmCompilerFn>) -> Self

Create a new JIT EVM wrapper that falls back to the interpreter on miss.

impl<EVM, F> JitEvm<EVM, F>

pub fn with_on_miss( inner: EVM, functions: B256Map<RawEvmCompilerFn>, on_miss: F, ) -> Self

Create a new JIT EVM wrapper with a custom miss handler.

pub fn into_inner(self) -> EVM

Consumes the wrapper and returns the inner EVM.

Trait Implementations

impl<EVM, F> Deref for JitEvm<EVM, F>

type Target = EVM

The resulting type after dereferencing.

fn deref(&self) -> &EVM

Dereferences the value.

impl<EVM, F> DerefMut for JitEvm<EVM, F>

fn deref_mut(&mut self) -> &mut EVM

Mutably dereferences the value.

impl<EVM, F> EvmTr for JitEvm<EVM, F>

where EVM: EvmTr<Frame = EthFrame, Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>>, F: FnMut(B256, &[u8]) -> Option<EvmCompilerFn>,

type Context = <EVM as EvmTr>::Context

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

type Instructions = <EVM as EvmTr>::Instructions

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = <EVM as EvmTr>::Precompiles

The type containing the available precompiled contracts

type Frame = <EVM as EvmTr>::Frame

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: <Self::Frame as FrameTr>::FrameInit, ) -> Result<ItemOrResult<&mut Self::Frame, <Self::Frame as FrameTr>::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<FrameInitOrResult<Self::Frame>, 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: <Self::Frame as FrameTr>::FrameResult, ) -> Result<Option<<Self::Frame as FrameTr>::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<EVM, F> ExecuteEvm for JitEvm<EVM, F>

where EVM: EvmTr<Frame = EthFrame, Context: ContextTr<Journal: JournalTr<State = EvmState>> + ContextSetters, Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>>, F: FnMut(B256, &[u8]) -> Option<EvmCompilerFn>,

type ExecutionResult = ExecutionResult

Output of transaction execution.

type State = HashMap<Address, Account, FbBuildHasher<20>>

Output state type representing changes after execution.

type Error = EVMError<<<<EVM as EvmTr>::Context as ContextTr>::Db as Database>::Error>

Error type

type Tx = <<EVM as EvmTr>::Context as ContextTr>::Tx

Transaction type.

type Block = <<EVM as EvmTr>::Context as ContextTr>::Block

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<EVM, F> InspectCommitEvm for JitEvm<EVM, F>

where Self: InspectEvm + ExecuteCommitEvm,

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<EVM, F> InspectEvm for JitEvm<EVM, F>

where EVM: EvmTr<Frame = EthFrame, Context: ContextTr<Journal: JournalTr<State = EvmState> + JournalExt> + ContextSetters, Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>> + InspectorEvmTr, F: FnMut(B256, &[u8]) -> Option<EvmCompilerFn>,

type Inspector = <EVM as InspectorEvmTr>::Inspector

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<EVM, F> InspectorEvmTr for JitEvm<EVM, F>

where EVM: EvmTr<Frame = EthFrame, Precompiles: PrecompileProvider<EVM::Context, Output = InterpreterResult>> + InspectorEvmTr, F: FnMut(B256, &[u8]) -> Option<EvmCompilerFn>,

type Inspector = <EVM as InspectorEvmTr>::Inspector

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 inspect_frame_run( &mut self, ) -> Result<FrameInitOrResult<Self::Frame>, ContextDbError<Self::Context>>

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

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.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.