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 storage_changes(&self) -> &[SlotChanges]

Returns the storage changes for this account.

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 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 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 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 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

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 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