Struct JournaledAccount 

pub struct JournaledAccount<'a, ENTRY>
where
    ENTRY: JournalEntryTr,
{ /* private fields */ }

Journaled account contains both mutable account and journal entries.

Useful to encapsulate account and journal entries together. So when account gets changed, we can add a journal entry for it.

Implementations

impl<'a, ENTRY> JournaledAccount<'a, ENTRY>

where ENTRY: JournalEntryTr,

pub fn into_account_ref(self) -> &'a Account

Consumes the journaled account and returns the mutable account.

pub fn new( address: Address, account: &'a mut Account, journal_entries: &'a mut Vec<ENTRY>, ) -> JournaledAccount<'a, ENTRY>

Creates a new journaled account.

pub fn balance(&self) -> &Uint<256, 4>

Returns the balance of the account.

pub fn nonce(&self) -> u64

Returns the nonce of the account.

pub fn code_hash(&self) -> &FixedBytes<32>

Returns the code hash of the account.

pub fn code(&self) -> Option<&Bytecode>

Returns the code of the account.

pub fn touch(&mut self)

Touches the account.

pub fn set_balance(&mut self, balance: Uint<256, 4>)

Sets the balance of the account.

If balance is the same, we don’t add a journal entry.

Touches the account in all cases.

pub fn incr_balance(&mut self, balance: Uint<256, 4>) -> bool

Increments the balance of the account.

Touches the account in all cases.

pub fn decr_balance(&mut self, balance: Uint<256, 4>) -> bool

Decrements the balance of the account.

Touches the account in all cases.

pub fn bump_nonce(&mut self) -> bool

Bumps the nonce of the account.

Touches the account in all cases.

Returns true if nonce was bumped, false if nonce is at the max value.

pub fn set_code(&mut self, code_hash: FixedBytes<32>, code: Bytecode)

Sets the code of the account.

Touches the account in all cases.

pub fn set_code_and_hash_slow(&mut self, code: Bytecode)

Sets the code of the account. Calculates hash of the code.

Touches the account in all cases.

pub fn delegate(&mut self, address: Address)

Delegates the account to another address (EIP-7702).

This touches the account, sets the code to the delegation designation, and bumps the nonce.

Methods from Deref<Target = Account>

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 is_selfdestructed(&self) -> bool

Is account marked for self destruct.

pub fn is_touched(&self) -> bool

If account status is marked as touched.

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

Is account warm for given transaction id.

pub fn is_created_locally(&self) -> bool

Is account locally created

pub fn is_selfdestructed_locally(&self) -> bool

Is account 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 = (&Uint<256, 4>, &EvmStorageSlot)>

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

See also EvmStorageSlot::is_changed.

Trait Implementations

impl<'a, ENTRY> Debug for JournaledAccount<'a, ENTRY>

where ENTRY: Debug + JournalEntryTr,

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

Formats the value using the given formatter.

impl<'a, ENTRY> Deref for JournaledAccount<'a, ENTRY>

where ENTRY: JournalEntryTr,

type Target = Account

The resulting type after dereferencing.

fn deref(&self) -> &<JournaledAccount<'a, ENTRY> as Deref>::Target

Dereferences the value.

impl<'a, ENTRY> PartialEq for JournaledAccount<'a, ENTRY>

where ENTRY: PartialEq + JournalEntryTr,

fn eq(&self, other: &JournaledAccount<'a, ENTRY>) -> 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<'a, ENTRY> Eq for JournaledAccount<'a, ENTRY>

where ENTRY: Eq + JournalEntryTr,

impl<'a, ENTRY> StructuralPartialEq for JournaledAccount<'a, ENTRY>

where ENTRY: JournalEntryTr,

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes