Struct Account 

pub struct Account {
    pub info: AccountInfo,
    pub original_info: Box<AccountInfo>,
    pub transaction_id: usize,
    pub storage: EvmStorage,
    pub status: AccountStatus,
}

The main account type used inside Revm. It is stored inside Journal and contains all the information about the account.

Other than standard Account information it contains its status that can be both cold and warm additional to that it contains BAL that is used to load data for this particular account.

On loading from database: * If CompiledBal is present, load values from BAL into Account (Assume account has read data from database) * In case of parallel execution, AccountInfo would be same over all parallel executions. * Maybe use transaction_id as a way to notify user that this is obsolete data. * Database needs to load account and tie to with BAL writes If CompiledBal is not present, use loaded values * Account is already up to date (uses present flow).

Fields

info: AccountInfo

Balance, nonce, and code

original_info: Box<AccountInfo>

Original account info used by BAL, changed only on cold load by BAL.

transaction_id: usize

Transaction id, used to track when account was toched/loaded into journal.

storage: EvmStorage

Storage cache

status: AccountStatus

Account status flags

Implementations

impl Account

pub fn new_not_existing(transaction_id: usize) -> Self

Creates new account and mark it as non existing.

pub fn caller_initial_modification( &mut self, new_balance: U256, is_call: bool, ) -> U256

Make changes to the caller account.

It marks the account as touched, changes the balance and bumps the nonce if is_call is true.

Returns the old balance.

pub fn state_clear_aware_is_empty(&self, spec: SpecId) -> bool

Checks if account is empty and check if empty state before spurious dragon hardfork.

pub fn mark_selfdestruct(&mut self)

Marks the account as self destructed.

pub fn unmark_selfdestruct(&mut self)

Unmarks the account as self destructed.

pub fn is_selfdestructed(&self) -> bool

Is account marked for self destruct.

pub fn mark_touch(&mut self)

Marks the account as touched

pub fn unmark_touch(&mut self)

Unmarks the touch flag.

pub fn is_touched(&self) -> bool

If account status is marked as touched.

pub fn mark_created(&mut self)

Marks the account as newly created.

pub fn unmark_created(&mut self)

Unmarks the created flag.

pub fn mark_cold(&mut self)

Marks the account as cold.

pub fn is_cold_transaction_id(&self, transaction_id: usize) -> bool

Is account warm for given transaction id.

pub fn mark_warm_with_transaction_id(&mut self, transaction_id: usize) -> bool

Marks the account as warm and return true if it was previously cold.

pub fn is_created_locally(&self) -> bool

Is account locally created

pub fn is_selfdestructed_locally(&self) -> bool

Is account locally selfdestructed

pub fn selfdestruct(&mut self)

Selfdestruct the account by clearing its storage and resetting its account info

pub fn mark_created_locally(&mut self) -> bool

Mark account as locally created and mark global created flag.

Returns true if it is created globally for first time.

pub fn unmark_created_locally(&mut self)

Unmark account as locally created

pub fn mark_selfdestructed_locally(&mut self) -> bool

Mark account as locally and globally selfdestructed

pub fn unmark_selfdestructed_locally(&mut self)

Unmark account as locally selfdestructed

pub fn is_loaded_as_not_existing(&self) -> bool

Is account loaded as not existing from database.

This is needed for pre spurious dragon hardforks where existing and empty were two separate states.

pub fn is_loaded_as_not_existing_not_touched(&self) -> bool

Is account loaded as not existing from database and not touched.

pub fn is_created(&self) -> bool

Is account newly created in this transaction.

pub fn is_empty(&self) -> bool

Is account empty, check if nonce and balance are zero and code is empty.

pub fn changed_storage_slots( &self, ) -> impl Iterator<Item = (&StorageKey, &EvmStorageSlot)>

Returns an iterator over the storage slots that have been changed.

See also EvmStorageSlot::is_changed.

pub fn with_info(self, info: AccountInfo) -> Self

Sets account info and returns self for method chaining.

pub fn with_storage<I>(self, storage_iter: I) -> Self

where I: Iterator<Item = (StorageKey, EvmStorageSlot)>,

Populates storage from an iterator of storage slots and returns self for method chaining.

pub fn with_selfdestruct_mark(self) -> Self

Marks the account as self destructed and returns self for method chaining.

pub fn with_touched_mark(self) -> Self

Marks the account as touched and returns self for method chaining.

pub fn with_created_mark(self) -> Self

Marks the account as newly created and returns self for method chaining.

pub fn with_cold_mark(self) -> Self

Marks the account as cold and returns self for method chaining.

pub fn with_warm_mark(self, transaction_id: usize) -> (Self, bool)

Marks the account as warm (not cold) and returns self for method chaining. Also returns whether the account was previously cold.

pub fn with_warm(self, transaction_id: usize) -> Self

Variant of with_warm_mark that doesn’t return the previous state.

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Account

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

Formats the value using the given formatter.

impl Default for Account

fn default() -> Account

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Account

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AccountInfo> for Account

fn from(info: AccountInfo) -> Self

Converts to this type from the input type.

impl PartialEq for Account

fn eq(&self, other: &Account) -> 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 Account

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Account

impl StructuralPartialEq for Account