Struct TempoBlockExecutor 

pub(crate) struct TempoBlockExecutor<'a, DB: Database, I> {
    pub(crate) inner: EthBlockExecutor<'a, TempoEvm<DB, I>, &'a TempoChainSpec, TempoReceiptBuilder>,
    section: BlockSection,
    seen_subblocks: Vec<(PartialValidatorKey, Vec<TempoTxEnvelope>)>,
    validator_set: Option<Vec<B256>>,
    shared_gas_limit: u64,
    subblock_fee_recipients: HashMap<PartialValidatorKey, Address>,
    non_shared_gas_left: u64,
    non_payment_gas_left: u64,
    incentive_gas_used: u64,
}

Block executor for Tempo.

Wraps an inner [EthBlockExecutor] and layers Tempo-specific block execution logic on top: section-based transaction ordering (BlockSection), subblock validation, shared/non-shared gas accounting, and gas incentive tracking.

Fields

inner: EthBlockExecutor<'a, TempoEvm<DB, I>, &'a TempoChainSpec, TempoReceiptBuilder>

section: BlockSection

seen_subblocks: Vec<(PartialValidatorKey, Vec<TempoTxEnvelope>)>

validator_set: Option<Vec<B256>>

shared_gas_limit: u64

subblock_fee_recipients: HashMap<PartialValidatorKey, Address>

non_shared_gas_left: u64

non_payment_gas_left: u64

incentive_gas_used: u64

Implementations

impl<'a, DB, I> TempoBlockExecutor<'a, DB, I>

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

pub(crate) fn new( evm: TempoEvm<DB, I>, ctx: TempoBlockExecutionCtx<'a>, chain_spec: &'a TempoChainSpec, ) -> Self

pub(crate) fn validate_system_tx( &self, tx: &TempoTxEnvelope, ) -> Result<BlockSection, BlockValidationError>

Validates a system transaction.

pub(crate) fn validate_shared_gas( &self, metadata: &[SubBlockMetadata], ) -> Result<(), BlockValidationError>

pub(crate) fn validate_tx( &self, tx: &TempoTxEnvelope, gas_used: u64, ) -> Result<BlockSection, BlockValidationError>

Trait Implementations

impl<'a, DB, I> BlockExecutor for TempoBlockExecutor<'a, DB, I>

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

type Transaction = TempoTxEnvelope

Input transaction type.

type Receipt = EthereumReceipt<TempoTxType>

Receipt type this executor produces.

type Evm = TempoEvm<DB, I>

EVM used by the executor.

type Result = TempoTxResult<TempoHaltReason>

Result of a transaction execution.

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

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

fn receipts(&self) -> &[Self::Receipt]

Returns a reference to all recorded receipts.

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

Executes a single transaction without committing state changes.

fn commit_transaction( &mut self, output: Self::Result, ) -> Result<u64, BlockExecutionError>

Commits a previously executed transaction’s state changes.

fn finish( self, ) -> Result<(Self::Evm, BlockExecutionResult<Self::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 Self::Evm

Exposes mutable reference to EVM.

fn evm(&self) -> &Self::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 execute_transaction_with_commit_condition( &mut self, tx: impl ExecutableTx<Self>, f: impl FnOnce(&ExecutionResult<<Self::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 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.

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.