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, ) -> 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_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_tx_calls( db: &mut GeneralizedDatabase, block_header: &BlockHeader, tx: &Transaction, only_top_call: bool, with_log: bool, vm_type: VMType, crypto: &dyn Crypto, ) -> Result<CallTrace, EvmError>

Run transaction with callTracer activated.

impl LEVM

pub fn execute_block( block: &Block, db: &mut GeneralizedDatabase, vm_type: VMType, crypto: &dyn Crypto, ) -> 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<&BlockAccessList>, bal_parallel_exec_enabled: bool, ) -> 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 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.

Transactions from the same sender are executed sequentially within their group to ensure correct nonce and balance propagation. Different sender groups run in parallel. This approach (inspired by Nethermind’s per-sender prewarmer) improves warmup accuracy by avoiding nonce mismatches within sender groups.

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 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, ) -> 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, ) -> Result<ExecutionResult, EvmError>

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 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.