Struct EthBlockExecutor

pub struct EthBlockExecutor<'a, Evm, Spec, R>
where
    R: ReceiptBuilder,
{
    pub ctx: EthBlockExecutionCtx<'a>,
    /* private fields */
}

Block executor for Ethereum.

Fields

ctx: EthBlockExecutionCtx<'a>

Context for block execution.

Implementations

impl<'a, Evm, Spec, R> EthBlockExecutor<'a, Evm, Spec, R>

where Spec: Clone, R: ReceiptBuilder,

pub fn new( evm: Evm, ctx: EthBlockExecutionCtx<'a>, spec: Spec, receipt_builder: R, ) -> EthBlockExecutor<'a, Evm, Spec, R>

Creates a new EthBlockExecutor

Trait Implementations

impl<'db, DB, E, Spec, R> BlockExecutor for EthBlockExecutor<'_, E, Spec, R>

where DB: Database + 'db, E: Evm<DB = &'db mut State<DB>>, <E as Evm>::Tx: FromRecoveredTx<<R as ReceiptBuilder>::Transaction> + FromTxWithEncoded<<R as ReceiptBuilder>::Transaction>, Spec: EthExecutorSpec, R: ReceiptBuilder, <R as ReceiptBuilder>::Transaction: Transaction + Encodable2718, <R as ReceiptBuilder>::Receipt: TxReceipt<Log = Log>,

type Transaction = <R as ReceiptBuilder>::Transaction

Input transaction type.

type Receipt = <R as ReceiptBuilder>::Receipt

Receipt type this executor produces.

type Evm = E

EVM used by the executor.

fn apply_pre_execution_changes(&mut self) -> Result<(), BlockExecutionError>

Applies any necessary changes before executing the block’s transactions.

fn execute_transaction_with_commit_condition( &mut self, tx: impl ExecutableTx<EthBlockExecutor<'_, E, Spec, R>>, f: impl FnOnce(&ExecutionResult<<<EthBlockExecutor<'_, E, Spec, R> as BlockExecutor>::Evm as Evm>::HaltReason>) -> CommitChanges, ) -> Result<Option<u64>, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal ExecutionResult produced by the EVM, and commits the transaction to the state on CommitChanges::Yes.

fn finish( self, ) -> Result<(<EthBlockExecutor<'_, E, Spec, R> as BlockExecutor>::Evm, BlockExecutionResult<<R as ReceiptBuilder>::Receipt>), BlockExecutionError>

Applies any necessary changes after executing the block’s transactions, completes execution and returns the underlying EVM along with execution result.

fn set_state_hook(&mut self, hook: Option<Box<dyn OnStateHook>>)

Sets a hook to be called after each state change during execution.

fn evm_mut( &mut self, ) -> &mut <EthBlockExecutor<'_, E, Spec, R> as BlockExecutor>::Evm

Exposes mutable reference to EVM.

fn evm(&self) -> &<EthBlockExecutor<'_, E, Spec, R> as BlockExecutor>::Evm

Exposes immutable reference to EVM.

fn execute_transaction( &mut self, tx: impl ExecutableTx<Self>, ) -> Result<u64, BlockExecutionError>

Executes a single transaction and applies execution result to internal state.

fn execute_transaction_with_result_closure( &mut self, tx: impl ExecutableTx<Self>, f: impl FnOnce(&ExecutionResult<<Self::Evm as Evm>::HaltReason>), ) -> Result<u64, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal ExecutionResult produced by the EVM.

fn apply_post_execution_changes( self, ) -> Result<BlockExecutionResult<Self::Receipt>, BlockExecutionError>

where Self: Sized,

A helper to invoke BlockExecutor::finish returning only the BlockExecutionResult.

fn with_state_hook(self, hook: Option<Box<dyn OnStateHook>>) -> Self

where Self: Sized,

A builder-style helper to invoke BlockExecutor::set_state_hook.

fn execute_block( self, transactions: impl IntoIterator<Item = impl ExecutableTx<Self>>, ) -> Result<BlockExecutionResult<Self::Receipt>, BlockExecutionError>

where Self: Sized,

Executes all transactions in a block, applying pre and post execution changes.

impl<'a, Evm, Spec, R> Debug for EthBlockExecutor<'a, Evm, Spec, R>

where Evm: Debug, Spec: Debug, R: Debug + ReceiptBuilder, <R as ReceiptBuilder>::Receipt: Debug,

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

Formats the value using the given formatter.

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.