Struct GeneralizedDatabase 

pub struct GeneralizedDatabase {
    pub store: Arc<dyn Database>,
    pub current_accounts_state: CacheDB,
    pub initial_accounts_state: CacheDB,
    pub shared_base: Option<Arc<CacheDB>>,
    pub codes: FxHashMap<H256, Code>,
    pub code_metadata: FxHashMap<H256, CodeMetadata>,
    pub tx_backup: Option<CallFrameBackup>,
    pub bal_recorder: Option<BlockAccessListRecorder>,
    pub accessed_accounts: Option<FxHashSet<Address>>,
    pub lazy_bal: Option<LazyBalCursor>,
    /* private fields */
}

Fields

store: Arc<dyn Database>

current_accounts_state: CacheDB

initial_accounts_state: CacheDB

shared_base: Option<Arc<CacheDB>>

Shared read-only base state (pre-block snapshot of system-touched addresses for parallel groups, captured from initial_accounts_state after prepare_block). Checked on load_account AFTER the lazy_bal hook so the BAL overlay (which includes system-call effects at idx 0) takes precedence for any address the BAL covers. Accounts are cloned into initial_accounts_state on first access.

codes: FxHashMap<H256, Code>

code_metadata: FxHashMap<H256, CodeMetadata>

tx_backup: Option<CallFrameBackup>

bal_recorder: Option<BlockAccessListRecorder>

Optional BAL recorder for EIP-7928 Block Access List recording.

accessed_accounts: Option<FxHashSet<Address>>

Optional tracker for BAL validation: records addresses accessed via load_account. Enabled only during parallel execution to detect extraneous BAL pure-access entries.

lazy_bal: Option<LazyBalCursor>

Optional BAL cursor for lazy per-read prefix materialization. When set, account loads and storage reads consult the BAL before hitting the store.

Implementations

impl GeneralizedDatabase

pub fn new(store: Arc<dyn Database>) -> Self

pub fn new_with_shared_base( store: Arc<dyn Database>, shared_base: Arc<CacheDB>, ) -> Self

Creates a new GeneralizedDatabase with a shared read-only base state. Used for parallel execution groups that share post-system-call state. Skips initial_accounts_state tracking since parallel per-tx DBs never call get_state_transitions_tx (state comes from BAL instead).

pub fn new_with_shared_base_and_capacity( store: Arc<dyn Database>, shared_base: Arc<CacheDB>, capacity: usize, ) -> Self

Like new_with_shared_base but pre-allocates account/code maps to capacity entries, avoiding rehashing during BAL seeding.

pub fn enable_bal_recording(&mut self)

Enables BAL recording for EIP-7928. After enabling, state changes will be recorded during execution.

pub fn disable_bal_recording(&mut self)

Disables BAL recording.

pub fn set_bal_index(&mut self, index: u32)

Sets the current block access index for BAL recording per EIP-7928 spec (uint32). Call this before each transaction or phase.

pub fn take_bal(&mut self) -> Option<BlockAccessList>

Takes the BAL recorder and builds the final BlockAccessList. Returns None if recording was not enabled.

pub fn bal_recorder_mut(&mut self) -> Option<&mut BlockAccessListRecorder>

Returns a mutable reference to the BAL recorder if enabled.

pub fn new_with_account_state( store: Arc<dyn Database>, current_accounts_state: FxHashMap<Address, Account>, ) -> Self

Only used within Levm Runner, where the accounts already have all the storage pre-loaded, not used in real case scenarios.

pub fn get_account( &mut self, address: Address, ) -> Result<&LevmAccount, InternalError>

Gets reference of an account

pub fn get_account_mut( &mut self, address: Address, ) -> Result<&mut LevmAccount, InternalError>

Gets mutable reference of an account Warning: Use directly only if outside of the EVM, otherwise use vm.get_account_mut because it contemplates call frame backups.

pub fn get_code(&mut self, code_hash: H256) -> Result<&Code, InternalError>

Gets code immutably given the code hash. Use this only inside of the VM, when we don’t surely know if the code is in the cache or not But e.g. in get_state_transitions just do db.codes.get(code_hash) because we know for sure code is there.

pub fn get_account_code( &mut self, address: Address, ) -> Result<&Code, InternalError>

Shortcut for getting the code when we only have the address of an account and we don’t need anything else.

pub fn get_code_metadata( &mut self, code_hash: H256, ) -> Result<&CodeMetadata, InternalError>

Gets code metadata immutably given the code hash.

pub fn get_code_length( &mut self, address: Address, ) -> Result<usize, InternalError>

Convenience method to get code length by address (optimized for EXTCODESIZE).

pub fn get_tx_backup(&self) -> Result<CallFrameBackup, InternalError>

Gets the transaction backup, if it exists. It only works if the BackupHook was enabled during the transaction execution.

pub fn undo_last_transaction(&mut self) -> Result<(), VMError>

Undoes the last transaction by restoring the cache state to the state before the transaction.

pub fn get_state_transitions(&mut self) -> Result<Vec<AccountUpdate>, VMError>

pub fn get_state_transitions_tx( &mut self, ) -> Result<Vec<AccountUpdate>, VMError>

Trait Implementations

impl Clone for GeneralizedDatabase

fn clone(&self) -> GeneralizedDatabase

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.