Struct TempoEvmHandler 

pub struct TempoEvmHandler<DB, I> {
    fee_token: Address,
    fee_payer: Address,
    _phantom: PhantomData<(DB, I)>,
}

Tempo EVM [Handler] implementation with Tempo specific modifications:

Fees are paid in fee tokens instead of account balance.

Fields

fee_token: Address

Fee token used for the transaction.

fee_payer: Address

Fee payer for the transaction.

_phantom: PhantomData<(DB, I)>

Phantom data to avoid type inference issues.

Implementations

impl<DB, I> TempoEvmHandler<DB, I>

pub fn new() -> Self

Create a new TempoEvmHandler handler instance

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

fn load_fee_fields( &mut self, evm: &mut TempoEvm<DB, I>, ) -> Result<(), EVMError<DB::Error, TempoInvalidTransaction>>

impl<DB, I> TempoEvmHandler<DB, I>

where DB: Database,

fn execute_single_call_with<F>( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, run_loop: F, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

where F: FnMut(&mut Self, &mut TempoEvm<DB, I>, <<TempoEvm<DB, I> as EvmTr>::Frame as FrameTr>::FrameInit) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>,

Generic single-call execution that works with both standard and inspector exec loops.

This is the core implementation that both execute_single_call and inspector-aware execution can use by providing the appropriate exec loop function.

fn execute_single_call( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

Executes a standard single-call transaction using the default handler logic.

This calls the same helper methods used by the default Handler::execution() implementation.

fn execute_multi_call_with<F>( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, calls: Vec<Call>, execute_single: F, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

where F: FnMut(&mut Self, &mut TempoEvm<DB, I>, &InitialAndFloorGas) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>,

Generic multi-call execution that works with both standard and inspector exec loops.

This is the core implementation for atomic batch execution that both execute_multi_call and inspector-aware execution can use by providing the appropriate single-call function.

Provides atomic batch execution for AA transactions with multiple calls:

1. Creates a checkpoint before executing any calls
2. Executes each call sequentially, updating gas tracking
3. If ANY call fails, reverts ALL state changes atomically
4. If all calls succeed, commits ALL state changes atomically

The atomicity is guaranteed by the checkpoint/revert/commit mechanism:

• Each individual call creates its own internal checkpoint
• The outer checkpoint (created here) captures state before any calls execute
• Reverting the outer checkpoint undoes all nested changes

fn execute_multi_call( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, calls: Vec<Call>, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

Executes a multi-call AA transaction atomically.

fn inspect_execute_single_call( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

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

Executes a standard single-call transaction with inspector support.

This is the inspector-aware version of execute_single_call that uses inspect_run_exec_loop instead of run_exec_loop.

fn inspect_execute_multi_call( &mut self, evm: &mut TempoEvm<DB, I>, init_and_floor_gas: &InitialAndFloorGas, calls: Vec<Call>, ) -> Result<FrameResult, EVMError<DB::Error, TempoInvalidTransaction>>

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

Executes a multi-call AA transaction atomically with inspector support.

This is the inspector-aware version of execute_multi_call that uses inspect_execute_single_call instead of execute_single_call.

Trait Implementations

impl<DB: Debug, I: Debug> Debug for TempoEvmHandler<DB, I>

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

Formats the value using the given formatter.

impl<DB, I> Default for TempoEvmHandler<DB, I>

fn default() -> Self

Returns the “default value” for a type.

impl<DB, I> Handler for TempoEvmHandler<DB, I>

where DB: Database,

fn execution( &mut self, evm: &mut Self::Evm, init_and_floor_gas: &InitialAndFloorGas, ) -> Result<FrameResult, Self::Error>

Overridden execution method that handles AA vs standard transactions.

Dispatches based on transaction type:

• AA transactions (type 0x5): Use batch execution path with calls field
• All other transactions: Use standard single-call execution

fn execution_result( &mut self, evm: &mut Self::Evm, result: <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Take logs from the Journal if outcome is Halt Or Revert.

fn apply_eip7702_auth_list( &self, evm: &mut Self::Evm, ) -> Result<u64, Self::Error>

Override apply_eip7702_auth_list to support AA transactions with authorization lists.

The default implementation only processes authorization lists for TransactionType::Eip7702 (0x04). This override extends support to AA transactions (type 0x76) by checking for the presence of an aa_authorization_list in the tempo_tx_env.

fn validate_env(&self, evm: &mut Self::Evm) -> Result<(), Self::Error>

Validates transaction environment with custom handling for AA transactions.

Performs standard validation plus AA-specific checks:

• Priority fee validation (EIP-1559)
• Time window validation (validAfter/validBefore)

fn validate_initial_tx_gas( &self, evm: &Self::Evm, ) -> Result<InitialAndFloorGas, Self::Error>

Calculates initial gas costs with custom handling for AA transactions.

AA transactions have variable intrinsic gas based on signature type:

• secp256k1 (64/65 bytes): Standard 21k base
• P256 (129 bytes): 21k base + 5k for P256 verification
• WebAuthn (>129 bytes): 21k base + 5k + calldata gas for variable data

type Evm = TempoEvm<DB, I>

The EVM type containing Context, Instruction, and Precompiles implementations.

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

The error type returned by this handler.

type HaltReason = TempoHaltReason

The halt reason type included in the output

fn run( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

The main entry point for transaction execution.

fn validate_against_state_and_deduct_caller( &self, evm: &mut Self::Evm, ) -> Result<(), Self::Error>

Deducts maximum possible fee and transfer value from caller’s balance.

fn reimburse_caller( &self, evm: &mut Self::Evm, exec_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, ) -> Result<(), Self::Error>

Returns unused gas costs to the transaction sender’s account.

fn reward_beneficiary( &self, _evm: &mut Self::Evm, _exec_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, ) -> Result<(), Self::Error>

Transfers transaction fees to the block beneficiary’s account.

fn catch_error( &self, evm: &mut Self::Evm, error: Self::Error, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Handles cleanup when an error occurs during execution.

fn run_system_call( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Runs the system call.

fn run_without_catch_error( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Called by [Handler::run] to execute the core handler logic.

fn validate( &self, evm: &mut Self::Evm, ) -> Result<InitialAndFloorGas, Self::Error>

Validates the execution environment and transaction parameters.

fn pre_execution(&self, evm: &mut Self::Evm) -> Result<u64, Self::Error>

Prepares the EVM state for execution.

fn post_execution( &self, evm: &mut Self::Evm, exec_result: &mut FrameResult, init_and_floor_gas: InitialAndFloorGas, eip7702_gas_refund: i64, ) -> Result<(), Self::Error>

Handles the final steps of transaction execution.

fn load_accounts(&self, evm: &mut Self::Evm) -> Result<(), Self::Error>

Loads access list and beneficiary account, marking them as warm in the [context::Journal].

fn first_frame_input( &mut self, evm: &mut Self::Evm, gas_limit: u64, ) -> Result<FrameInit, Self::Error>

Creates initial frame input using transaction parameters, gas limit and configuration.

fn last_frame_result( &mut self, evm: &mut Self::Evm, frame_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, ) -> Result<(), Self::Error>

Processes the result of the initial call and handles returned gas.

fn run_exec_loop( &mut self, evm: &mut Self::Evm, first_frame_input: <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameInit, ) -> Result<FrameResult, Self::Error>

Executes the main frame processing loop.

fn eip7623_check_gas_floor( &self, _evm: &mut Self::Evm, exec_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, init_and_floor_gas: InitialAndFloorGas, )

Validates that the minimum gas floor requirements are satisfied.

fn refund( &self, evm: &mut Self::Evm, exec_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult, eip7702_refund: i64, )

Calculates the final gas refund amount, including any EIP-7702 refunds.

impl<DB, I> InspectorHandler for TempoEvmHandler<DB, I>

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

fn inspect_execution( &mut self, evm: &mut Self::Evm, init_and_floor_gas: &InitialAndFloorGas, ) -> Result<FrameResult, Self::Error>

Overridden execution method with inspector support that handles AA vs standard transactions.

Dispatches based on transaction type:

• AA transactions (type 0x76): Use batch execution path with calls field
• All other transactions: Use standard single-call execution

This mirrors the logic in Handler::execution but uses inspector-aware execution methods.

type IT = EthInterpreter

The interpreter types used by this handler.

fn inspect_run( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Entry point for inspection.

fn inspect_run_without_catch_error( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Run inspection without catching error.

fn inspect_run_exec_loop( &mut self, evm: &mut Self::Evm, first_frame_input: <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameInit, ) -> Result<FrameResult, Self::Error>

Run inspection on execution loop.

fn inspect_run_system_call( &mut self, evm: &mut Self::Evm, ) -> Result<ExecutionResult<Self::HaltReason>, Self::Error>

Run system call with inspection support.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes