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,