Struct TempoBlockExecutor 

pub 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

fn deploy_precompile_at_boundary( &mut self, address: Address, ) -> Result<(), BlockExecutionError>

Deploys 0xEF marker bytecode to a precompile address if it doesn’t already have code.

This also dispatches the state change to the system caller’s state hook so that the sparse trie task is aware of the change.

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_pre_execution( &self, tx: &TempoTxEnvelope, ) -> Result<Option<BlockSection>, BlockValidationError>

Pre-validate a transaction before execution.

This is only done for system transaction as they are effectively bypassing the regular block gas limit checks and we need to make sure that they only perform explicitly allowed actions.

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

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) -> GasOutput

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<GasOutput, 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(&Self::Result), ) -> Result<GasOutput, BlockExecutionError>

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

fn execute_transaction_with_commit_condition( &mut self, tx: impl ExecutableTx<Self>, f: impl FnOnce(&Self::Result) -> CommitChanges, ) -> Result<Option<GasOutput>, BlockExecutionError>

Executes a single transaction and applies execution result to internal state. Invokes the given closure with an internal Self::Result 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.