Struct AccountChanges 

pub struct AccountChanges {
    pub address: Address,
    pub storage_changes: Vec<SlotChanges>,
    pub storage_reads: Vec<Uint<256, 4>>,
    pub balance_changes: Vec<BalanceChange>,
    pub nonce_changes: Vec<NonceChange>,
    pub code_changes: Vec<CodeChange>,
}

This struct is used to track the changes across accounts in a block.

Fields

address: Address

The address of the account whose changes are stored.

storage_changes: Vec<SlotChanges>

List of slot changes for this account.

storage_reads: Vec<Uint<256, 4>>

List of storage reads for this account.

balance_changes: Vec<BalanceChange>

List of balance changes for this account.

nonce_changes: Vec<NonceChange>

List of nonce changes for this account.

code_changes: Vec<CodeChange>

List of code changes for this account.

Implementations

impl AccountChanges

pub const fn new(address: Address) -> AccountChanges

Creates a new AccountChanges instance for the given address with empty vectors.

pub fn with_capacity(address: Address, capacity: usize) -> AccountChanges

Creates a new AccountChanges instance for the given address with specified capacity.

pub const fn address(&self) -> Address

Returns the address of the account.

pub fn is_empty(&self) -> bool

Returns true if this account change set contains no changes or reads.

A SlotChanges entry with an empty change list does not count as data, so an entry that only carries the address (or empty slot entries) is considered empty.

pub fn storage_changes(&self) -> &[SlotChanges]

Returns the storage changes for this account.

pub fn storage_slots(&self) -> impl Iterator<Item = Uint<256, 4>>

Returns an iterator over storage slots present in this account’s changes and reads.

Changed slots are yielded first, followed by read slots.

pub fn storage_post_states( &self, ) -> impl Iterator<Item = (Uint<256, 4>, Uint<256, 4>)>

Returns an iterator over the post-state value for each changed storage slot.

The post-state value is taken from the last recorded change for each slot.

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

Returns the balance from the last recorded change, or None if unchanged.

pub fn nonce_post_state(&self) -> Option<u64>

Returns the nonce from the last recorded change, or None if unchanged.

pub fn code_post_state(&self) -> Option<&Bytes>

Returns the code from the last recorded change, or None if unchanged.

pub fn code_hash_post_state(&self) -> Option<FixedBytes<32>>

Returns the hash of the code from the last recorded change, or None if unchanged.

KECCAK256_EMPTY is returned when the code was set to empty.

pub fn code_post_state_with_hash(&self) -> Option<(FixedBytes<32>, &Bytes)>

Returns the code from the last recorded change together with its hash, or None if unchanged.

Use this over hashing Self::code_post_state separately when both the code and its hash are needed, for example when storing the deployed bytecode by hash.

pub fn account_info(&self) -> BalAccountInfo

Returns the account-level fields this entry changed, see BalAccountInfo.

pub fn has_storage_changes(&self) -> bool

Returns true if this entry writes at least one storage slot.

SlotChanges entries without changes are ignored, mirroring Self::is_empty.

pub fn has_changes(&self) -> bool

Returns true if this entry records at least one state change.

Entries that only record reads leave the account untouched and do not contribute to the block’s post-state.

pub fn merge(&mut self, incoming: AccountChanges)

Merges another account change set into this one.

Storage changes for matching slots are grouped together. Storage reads are normalized after merging so that written slots are represented by storage_changes, while storage_reads only contains unique read-only slots in first-seen order. This preserves the EIP-7928 invariant that a storage slot appears in either reads or changes, but not both, after independently valid account change sets are combined.

This preserves relative ordering by appending incoming changes to existing changes. Call Self::sort after merging if canonical EIP-7928 ordering is required.

Panics

Panics if the two account change sets have different addresses.

pub fn storage_reads(&self) -> &[Uint<256, 4>]

Returns the storage reads for this account.

pub fn balance_changes(&self) -> &[BalanceChange]

Returns the balance changes for this account.

pub fn nonce_changes(&self) -> &[NonceChange]

Returns the nonce changes for this account.

pub fn code_changes(&self) -> &[CodeChange]

Returns the code changes for this account.

pub fn sort(&mut self)

Sorts this account’s changes in-place according to the account-local EIP-7928 ordering rules.

This applies the account-local ordering required by the “Ordering, Uniqueness and Determinism” section of EIP-7928:

• storage_changes are sorted lexicographically by storage key
• each per-slot StorageChange list is sorted by block access index in ascending order
• storage_reads are sorted lexicographically by storage key
• balance_changes, nonce_changes, and code_changes are sorted by block access index in ascending order

Per-slot storage change ordering is delegated to SlotChanges::sort.

This method only canonicalizes ordering for a single account. It does not enforce the EIP-7928 uniqueness constraints for storage keys or block access indexes.

pub fn normalize(&mut self)

Renormalizes this account change set in place.

Empty SlotChanges entries are dropped, duplicate slot entries are folded together (preserving the relative order of their changes), and storage reads are deduplicated and pruned against written slots, restoring the EIP-7928 invariant that a slot appears in either reads or changes but not both.

pub fn collapse_changes_at(&mut self, at: BlockAccessIndex)

Collapses each change list to its last entry and assigns that entry to at.

The last entry of each list is treated as the effective value (“last write wins”), matching Self::storage_post_states. Storage reads carry no block access index and are left untouched.

pub fn shift_indices_from(&mut self, from: BlockAccessIndex)

Shifts every recorded block access index at or after from forward by one.

Indices saturate at u64::MAX instead of overflowing.

pub const fn with_address(self, address: Address) -> AccountChanges

Set the address.

pub fn with_storage_read(self, key: Uint<256, 4>) -> AccountChanges

Add a storage read slot.

pub fn with_storage_change(self, change: SlotChanges) -> AccountChanges

Add a storage change (multiple writes to a slot grouped in SlotChanges).

pub fn with_balance_change(self, change: BalanceChange) -> AccountChanges

Add a balance change.

pub fn with_nonce_change(self, change: NonceChange) -> AccountChanges

Add a nonce change.

pub fn with_code_change(self, change: CodeChange) -> AccountChanges

Add a code change.

pub fn extend_storage_reads<I>(self, iter: I) -> AccountChanges

where I: IntoIterator<Item = Uint<256, 4>>,

Add multiple storage reads at once.

pub fn extend_storage_changes<I>(self, iter: I) -> AccountChanges

where I: IntoIterator<Item = SlotChanges>,

Add multiple slot changes at once.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for AccountChanges

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<AccountChanges, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest( u: Unstructured<'arbitrary>, ) -> Result<AccountChanges, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl BorshDeserialize for AccountChanges

fn deserialize_reader<__R>(reader: &mut __R) -> Result<AccountChanges, Error>

where __R: Read,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for AccountChanges

fn serialize<__W>(&self, writer: &mut __W) -> Result<(), Error>

where __W: Write,

impl Clone for AccountChanges

fn clone(&self) -> AccountChanges

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountChanges

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

Formats the value using the given formatter.

impl Decodable for AccountChanges

fn decode(b: &mut &[u8]) -> Result<AccountChanges, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for AccountChanges

fn default() -> AccountChanges

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AccountChanges

fn deserialize<__D>( __deserializer: __D, ) -> Result<AccountChanges, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for AccountChanges

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

impl Eq for AccountChanges

impl From<&AccountChanges> for BalAccountInfo

fn from(changes: &AccountChanges) -> BalAccountInfo

Converts to this type from the input type.

impl FromIterator<AccountChanges> for Bal

fn from_iter<I>(iter: I) -> Bal

where I: IntoIterator<Item = AccountChanges>,

Creates a value from an iterator.

impl Hash for AccountChanges

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AccountChanges

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AccountChanges

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AccountChanges

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: 144 bytes