Struct LevmAccount 

pub struct LevmAccount {
    pub info: AccountInfo,
    pub storage: FxHashMap<H256, U256>,
    pub has_storage: bool,
    pub status: AccountStatus,
    pub exists: bool,
}

Similar to Account struct but suited for LEVM implementation. Difference is this doesn’t have code and it contains an additional status field for decision-making. The code is stored in the GeneralizedDatabase and can be accessed with its hash.
Some advantages:

• We’ll fetch the code only if we need to, this means less accesses to the database.
• If there’s duplicate code between accounts (which is pretty common) we’ll store it in memory only once.
• We’ll be able to make better decisions without relying on external structures, based on the current status of an Account. e.g. If it was untouched we skip processing it when calculating Account Updates, or if the account has been destroyed and re-created with same address we know that the storage on the Database is not valid and we shouldn’t access it, etc.

Fields

info: AccountInfo

storage: FxHashMap<H256, U256>

has_storage: bool

If true it means that attempting to create an account with this address it would at least collide because of storage. We just care about this kind of collision if the account doesn’t have code or nonce. Otherwise its value doesn’t matter. For more information see EIP-7610: https://eips.ethereum.org/EIPS/eip-7610 Warning: This attribute should only be used for handling create collisions as it’s not necessary appropriate for every scenario. Read the caveat below.

How this works:

• When getting an account from the DB this is set to true if the account has non-empty storage root.
• Upon destruction of an account this is set to false because storage is emptied for sure.

Important Caveat This only works for accounts of these characteristics that have been created in the past, we consider that accounts with storage but no nonce or code cannot be created anymore, otherwise the fix would need to be more complex because we should keep track of the storage root of an account during execution instead of just keeping track of it when fetching it from the Database or updating it when destroying it. The EIP that adds to the spec this check did it because there are 28 accounts with these characteristics already deployed in mainnet (back when they were deployed with nonce 0), but they cannot be created intentionally anymore.

status: AccountStatus

Current status of the account.

exists: bool

Whether this account exists in the state trie. Used for EIP-7702 auth refund: account_exists (EELS) differs from !is_empty(). An account can exist but be empty (e.g., has non-empty storage root only). Default is false (non-existent); set to true when loaded from DB with actual state.

Implementations

impl LevmAccount

pub fn mark_destroyed(&mut self)

pub fn mark_modified(&mut self)

pub fn has_nonce(&self) -> bool

pub fn has_code(&self) -> bool

pub fn create_would_collide(&self) -> bool

pub fn is_empty(&self) -> bool

pub fn is_unmodified(&self) -> bool

Checks if the account is unmodified.

pub fn clone_without_storage(&self) -> Self

Clones the account’s metadata (info + flags) but leaves storage empty.

Used on the streaming-executor read-fault path (load_account): when the streaming merkleizer drains current_accounts_state, a hot account re-faulted on the next tx would otherwise deep-copy its entire accumulated storage map (hundreds–thousands of slots) just so the tx can read the ~3 it touches. Cloning info/flags only and faulting those slots in lazily avoids that copy. Correctness relies on get_storage_value resolving a current miss against initial_accounts_state (the committed in-block baseline) before the pre-block store, which keeps the diff invariant “every key in current.storage is also in initial.storage” intact.

Destructured (not ..) so adding a field to LevmAccount fails to compile here until it is explicitly carried — a missing flag would silently corrupt the state-transition diff.

Trait Implementations

impl Clone for LevmAccount

fn clone(&self) -> LevmAccount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LevmAccount

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

Formats the value using the given formatter.

impl Default for LevmAccount

fn default() -> LevmAccount

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LevmAccount

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for LevmAccount

impl From<AccountState> for LevmAccount

fn from(state: AccountState) -> Self

Converts to this type from the input type.

impl From<GenesisAccount> for LevmAccount

fn from(genesis: GenesisAccount) -> Self

Converts to this type from the input type.

impl PartialEq for LevmAccount

fn eq(&self, other: &LevmAccount) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LevmAccount

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LevmAccount