Struct TempoEvm 

pub struct TempoEvm<DB: Database, I> {
    pub inner: Evm<TempoContext<DB>, I, EthInstructions<EthInterpreter, TempoContext<DB>>, PrecompilesMap, EthFrame<EthInterpreter>>,
    pub logs: Vec<Log>,
    pub(crate) collected_fee: U256,
}

TempoEvm extends the Evm with Tempo specific types and logic.

Fields

inner: Evm<TempoContext<DB>, I, EthInstructions<EthInterpreter, TempoContext<DB>>, PrecompilesMap, EthFrame<EthInterpreter>>

Inner EVM type.

logs: Vec<Log>

Preserved logs from the last transaction

collected_fee: U256

The fee collected in collectFeePreTx call.

Implementations

impl<DB: Database, I> TempoEvm<DB, I>

pub fn new(ctx: TempoContext<DB>, inspector: I) -> Self

Create a new Tempo EVM.

fn new_inner( inner: Evm<TempoContext<DB>, I, EthInstructions<EthInterpreter, TempoContext<DB>>, PrecompilesMap, EthFrame<EthInterpreter>>, ) -> Self

Inner helper function to create a new Tempo EVM with empty logs.

impl<DB: Database, I> TempoEvm<DB, I>

pub fn with_inspector<OINSP>(self, inspector: OINSP) -> TempoEvm<DB, OINSP>

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

pub fn with_precompiles(self, precompiles: PrecompilesMap) -> Self

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

pub fn into_inspector(self) -> I

Consumes self and returns the inner Inspector.

pub fn take_logs(&mut self) -> Vec<Log>

Take logs from the EVM.

Trait Implementations

impl<DB: Debug + Database, I: Debug> Debug for TempoEvm<DB, I>

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

Formats the value using the given formatter.

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

type Target = Evm<Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, DB>, I, EthInstructions<EthInterpreter, Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, DB>>, PrecompilesMap, EthFrame>

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

where DB: Database,

fn frame_return_result( &mut self, result: <Self::Frame as FrameTr>::FrameResult, ) -> Result<Option<<Self::Frame as FrameTr>::FrameResult>, ContextError<DB::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 = Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, DB>

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

type Instructions = EthInstructions<EthInterpreter, Context<TempoBlockEnv, TempoTxEnv, CfgEnv<TempoHardfork>, DB>>

The instruction set type that implements InstructionProvider to define available operations

type Precompiles = PrecompilesMap

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_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<DB::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<DB::Error>>

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

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.

impl<DB, I> ExecuteCommitEvm for TempoEvm<DB, I>

where DB: Database + DatabaseCommit,

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>, TransactionIndexedError<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<DB, I> ExecuteEvm for TempoEvm<DB, I>

where DB: Database,

type Tx = TempoTxEnv

Transaction type.

type Block = TempoBlockEnv

Block type.

type State = HashMap<Address, Account, DefaultHashBuilder>

Output state type representing changes after execution.

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

Error type

type ExecutionResult = ExecutionResult<TempoHaltReason>

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>, 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> InspectCommitEvm for TempoEvm<DB, I>

where DB: Database + DatabaseCommit, I: Inspector<TempoContext<DB>>,

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<DB, I> InspectEvm for TempoEvm<DB, I>

where DB: Database, I: Inspector<TempoContext<DB>>,

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> InspectSystemCallEvm for TempoEvm<DB, I>

where DB: Database, I: Inspector<TempoContext<DB>>,

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

Inspect a system call with the current inspector and a custom caller.

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

Inspect a system call with the current inspector.

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

Inspect a system call and finalize the state.

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

Inspect a system call with a custom caller and finalize the state.

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

Inspect a system call with a given inspector.

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

Inspect a system call with a given inspector and finalize the state.

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

Inspect a system call with a given inspector and caller.

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

Inspect a system call with a given inspector and finalize the state.

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

where DB: Database, I: Inspector<TempoContext<DB>>,

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 TempoEvm<DB, I>

where DB: Database,

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.

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.