Struct LEVM 

pub struct LEVM;

The struct implements the following functions: LEVM::execute_block LEVM::execute_tx LEVM::get_state_transitions LEVM::process_withdrawals

Implementations

impl LEVM

pub fn rerun_block( db: &mut GeneralizedDatabase, block: &Block, stop_index: Option<usize>, vm_type: VMType, crypto: &dyn Crypto, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<(), EvmError>

Execute all transactions of the block up until a certain transaction specified in stop_index. The goal is to just mutate the state up to that point, without needing to process transaction receipts or requests.

pub fn trace_tx_prestate( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &Transaction, diff_mode: bool, include_empty: bool, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<PrestateResult, EvmError>

Executes tx and returns the prestateTracer result. diff_mode toggles between pre-only and pre+post output. include_empty keeps entries that would otherwise be all-default (must be false in diff mode). Assumes db already reflects all prior txs in the block.

pub fn trace_call_prestate( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &GenericTransaction, diff_mode: bool, include_empty: bool, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<PrestateResult, EvmError>

debug_traceCall counterpart of Self::trace_tx_prestate: traces a synthetic eth_call-shaped request against db (which must already hold the target state).

pub fn trace_tx_opcodes( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &Transaction, cfg: OpcodeTracerConfig, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<OpcodeTraceResult, EvmError>

Run transaction with opcode (EIP-3155) tracer activated.

pub fn trace_call_opcodes( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &GenericTransaction, cfg: OpcodeTracerConfig, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<OpcodeTraceResult, EvmError>

debug_traceCall counterpart of Self::trace_tx_opcodes.

pub fn trace_tx_calls( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &Transaction, only_top_call: bool, with_log: bool, log_index_base: u64, vm_type: VMType, crypto: &dyn Crypto, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<CallTrace, EvmError>

Run transaction with callTracer activated. log_index_base is the number of logs emitted by preceding txs in the block, so withLog logs get geth’s block-absolute index (pass 0 when there is no preceding context or logs aren’t collected).

pub fn trace_call_calls( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &GenericTransaction, only_top_call: bool, with_log: bool, log_index_base: u64, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<CallTrace, EvmError>

debug_traceCall counterpart of Self::trace_tx_calls.

pub fn trace_block_calls( db: &mut GeneralizedDatabase, block: &Block, only_top_call: bool, with_log: bool, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<Vec<(H256, CallTrace)>, EvmError>

Traces every transaction in block with the callTracer, oldest to newest. db must already hold the block’s parent state; this runs the block’s system calls (beacon root, etc.) and then each transaction in order, accumulating state. The block-invariant EVMConfig/chain_id/blob fee are computed once and reused per tx (the single-tx entry points recompute them each call). Returns (tx_hash, trace).

pub fn trace_block_prestate( db: &mut GeneralizedDatabase, block: &Block, diff_mode: bool, include_empty: bool, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<Vec<(H256, PrestateResult)>, EvmError>

Traces every transaction in block with the prestateTracer. See Self::trace_block_calls for the state/config-reuse semantics.

pub fn trace_block_opcodes( db: &mut GeneralizedDatabase, block: &Block, cfg: OpcodeTracerConfig, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<Vec<(H256, OpcodeTraceResult)>, EvmError>

Traces every transaction in block with the opcode (EIP-3155) tracer. See Self::trace_block_calls for the state/config-reuse semantics.

impl LEVM

pub fn execute_block( block: &Block, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<(BlockExecutionResult, Option<BlockAccessList>), EvmError>

Execute a block and return the execution result.

Also records and returns the Block Access List (EIP-7928) for Amsterdam+ forks. The BAL will be None for pre-Amsterdam forks.

pub fn execute_block_pipeline( block: &Block, db: &mut GeneralizedDatabase, vm_type: VMType, merkleizer: Option<Sender<Vec<AccountUpdate>>>, queue_length: &AtomicUsize, crypto: &dyn Crypto, header_bal: Option<Arc<BlockAccessList>>, bal_parallel_exec_enabled: bool, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<(BlockExecutionResult, Option<BlockAccessList>), EvmError>

merkleizer is Some on the streaming (non-BAL) path; the BAL validation path passes None because the caller merkleizes optimistically from the input BAL and the EVM-side bal_to_account_updates send is then redundant work.

pub fn validate_tx_execution( bal_idx: u32, seed_idx: u32, current_state: &FxHashMap<Address, LevmAccount>, codes: &FxHashMap<H256, Code>, bal: &BlockAccessList, index: &BalAddressIndex, system_seed: &CacheDB, store: &Arc<dyn Database>, pure_reads: &FxHashSet<(Address, U256)>, tx_initial: &FxHashMap<(Address, U256), U256>, ) -> Result<(), BalValidationError>

Validates that a tx’s post-execution state matches BAL claims.

Replaces the previous snapshot->diff->validate approach:

• No HashMap clone needed (reconstructs seeded values from BAL)
• Uses pre-built index for O(1) account lookups
• Uses binary search on sorted change lists

bal_idx: block_access_index for this tx (tx_idx + 1) seed_idx: max BAL index used for seeding (= tx_idx = bal_idx - 1) current_state: post-execution account state from per-tx DB codes: code cache from per-tx DB (for code change validation) bal: the block access list index: pre-built validation index system_seed: pre-system-call state snapshot (for extraneous entry detection) store: database (fallback for pre-state lookups) pure_reads: slots the shadow recorder observed as pure reads (never written); the execution->BAL check skips the seeded pre-state lookup for these since a genuine read cannot diverge from its pre-tx value. Pass an empty set to validate every slot unconditionally (e.g. from unit tests). tx_initial: start-of-tx storage values the EVM already captured for written slots ((addr, slot) -> pre_value); used as the storage seed fast-path so seeded_storage avoids a store read. Pass an empty map to force the store fallback (e.g. from unit tests).

Exposed as pub (rather than crate-private) solely so the direct validate_tx_execution unit tests in the ethrex-test crate (test/tests/blockchain/bal_validate_tx_execution_tests.rs) can call it.

pub fn warm_block( block: &Block, store: Arc<dyn Database>, vm_type: VMType, crypto: &dyn Crypto, cancelled: &AtomicBool, ) -> Result<(), EvmError>

Pre-warms state by executing all transactions in parallel, grouped by sender.

The store parameter should be a CachingDatabase-wrapped store so that parallel workers can benefit from shared caching. The same cache should be used by the sequential execution phase.

pub fn warm_txs( txs_with_sender: &[(&Transaction, Address)], header: &BlockHeader, store: Arc<dyn Database>, vm_type: VMType, crypto: &dyn Crypto, should_stop: &(dyn Fn() -> bool + Sync), ) -> Result<(), EvmError>

Speculatively executes an arbitrary transaction set against header’s parent state to warm shared caches (used by the mempool prewarmer and warm_block). Sequential within a sender group, parallel across groups. should_stop is polled before each sender group and again before each transaction, so cancellation latency is bounded by one transaction’s execution. Execution results are discarded — only cache population matters.

pub fn bal_storage_slots(bal: &BlockAccessList) -> Vec<(Address, H256)>

Flattened (address, slot) storage worklist for a BAL, in natural account order (slots grouped per account for storage-trie locality).

pub fn warm_block_from_bal( bal: &BlockAccessList, store: Arc<dyn Database>, cancelled: &AtomicBool, ) -> Result<(), EvmError>

Concurrent block warmer for the BAL path: prefetches account states and contract code while execution runs.

Storage slots are deliberately NOT warmed here. They are prefetched synchronously before the executor starts (see bal_storage_slots and the call site in blockchain.rs); warming them concurrently here let the executor race the warmer to the trie for SSTORE original values and cost ~22% of CPU. Keep storage warming synchronous and up front.

pub fn execute_tx( tx: &Transaction, tx_sender: Address, block_header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<ExecutionReport, EvmError>

pub fn undo_last_tx(db: &mut GeneralizedDatabase) -> Result<(), EvmError>

pub fn simulate_tx_from_generic( tx: &GenericTransaction, block_header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, stateless_validator: Option<&dyn StatelessValidator>, ) -> Result<ExecutionResult, EvmError>

pub fn simulate_frame_validation_prefix( tx: &Transaction, block_header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, prefix: &ValidationPrefix, _canonical_paymaster_code_hash: Option<H256>, ) -> Result<FrameValidationOutcome, EvmError>

EIP-8141 mempool validation-prefix simulation (local peer policy, never consensus). Builds a VM like LEVM::execute_tx over a fresh simulation database, activates the [ValidationObserver] for the transaction’s sender, runs ONLY the validation-prefix frames, and applies the admission assertions:

• no prefix frame reverted;
• each verify/pay frame that must APPROVE did (the prefix established a payer);
• the deploy frame (if any) left non-empty code at the sender;
• total simulated prefix gas <= MAX_VERIFY_GAS;
• no validation-trace rule was violated.

canonical_paymaster_code_hash is the pinned canonical paymaster code hash, when known (always None today, OQ1).

pub fn get_state_transitions( db: &mut GeneralizedDatabase, ) -> Result<Vec<AccountUpdate>, EvmError>

pub fn get_state_transitions_tx( db: &mut GeneralizedDatabase, ) -> Result<Vec<AccountUpdate>, EvmError>

pub fn process_withdrawals( db: &mut GeneralizedDatabase, withdrawals: &[Withdrawal], ) -> Result<(), EvmError>

pub fn beacon_root_contract_call( block_header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<(), EvmError>

pub fn process_block_hash_history( block_header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<(), EvmError>

pub fn install_expiry_verifier_code( db: &mut GeneralizedDatabase, crypto: &dyn Crypto, ) -> Result<(), EvmError>

Install the canonical EIP-8141 expiry verifier runtime code at EXPIRY_VERIFIER on Hegota activation (EIP-8141: “At activation, clients must install…”). Idempotent: writes only when the existing code differs, so exactly one account update is produced (at the first Hegota block) and none afterwards.

pub fn create_access_list( tx: GenericTransaction, header: &BlockHeader, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<(ExecutionResult, AccessList), VMError>

pub fn prepare_block( block: &Block, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<(), EvmError>

Trait Implementations

impl Debug for LEVM

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

Formats the value using the given formatter.