Struct StateDiff 

#[non_exhaustive]
pub struct StateDiff {
    pub slots: Vec<SlotChange>,
    pub accounts: Vec<AccountChange>,
    pub purged: Vec<PurgeRecord>,
    pub skipped: Vec<SkippedDelta>,
    pub skipped_balances: Vec<SkippedBalanceDelta>,
    pub skipped_masks: Vec<SkippedMask>,
    pub skipped_accounts: Vec<SkippedAccountPatch>,
}

What an apply_* call actually changed.

Returned by EvmCache::apply_update and apply_updates. Only real changes are recorded, so a no-op write yields a Default (empty) diff.

The struct is #[non_exhaustive]: it has grown fields pre-1.0 (skipped, skipped_balances, skipped_masks, and skipped_accounts) and may grow more. Construct it via Default + field assignment, never an exhaustive struct literal.

Checking for skips

is_empty / len are changes-only, so a cold-skipped update (SlotDelta / BalanceDelta / SlotMasked / Account) is invisible to them. After applying cold-aware updates, check has_skipped (or inspect the skipped_* fields) — a cold target was dropped, not applied.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

slots: Vec<SlotChange>

Storage slots whose value changed (old != new).

accounts: Vec<AccountChange>

Accounts whose balance/nonce/code-hash changed.

purged: Vec<PurgeRecord>

Purges performed, with what they removed.

skipped: Vec<SkippedDelta>

Relative slot updates (StateUpdate::SlotDelta) that were not applied because the target slot’s current value was unknown (cold). This is informational metadata, not a change: it does not affect is_empty / len.

skipped_balances: Vec<SkippedBalanceDelta>

Relative balance updates (StateUpdate::BalanceDelta) that were not applied because the target account was absent from both layers (its balance was unknown). Like skipped this is informational metadata, not a change.

skipped_masks: Vec<SkippedMask>

Masked slot updates (StateUpdate::SlotMasked) that were not applied because the target slot’s current value was unknown (cold) — the un-masked bits could not be preserved. Like skipped this is informational metadata, not a change.

skipped_accounts: Vec<SkippedAccountPatch>

Account patches (StateUpdate::Account) that were not applied because the account was absent from both layers. Like skipped this is informational metadata, not a change.

Implementations

impl StateDiff

pub fn is_empty(&self) -> bool

Whether the diff recorded no change at all.

Changes-only: counts slots + accounts + purged. Any skipped update (any of the skipped_* fields) is informational metadata, not a change, so it does not affect this.

pub fn len(&self) -> usize

Total number of changed entries (slots + accounts + purges).

Changes-only: skipped updates (any skipped_* field) are not counted (a skip is not a change). See skipped_len for the skip count.

pub fn has_skipped(&self) -> bool

Whether any cold-aware update was skipped (relative slot, balance, masked slot, or cold account patch).

true iff any of skipped, skipped_balances, skipped_masks, or skipped_accounts is non-empty. A cold-skipped update produces no change, so it is invisible to is_empty — callers applying cold-aware updates should check this to avoid silently dropping an update.

pub fn skipped_len(&self) -> usize

Total number of skipped relative/masked updates (skipped + skipped_balances + skipped_masks + skipped_accounts).

pub fn is_fully_applied(&self) -> bool

Whether every relative update in the apply was applied (none skipped).

The inverse of has_skipped.

pub fn merge(&mut self, other: StateDiff)

Fold other into self, concatenating each category.

Used by apply_updates to merge per-update diffs; the concatenation preserves order, so two writes to the same slot record their old → new history in sequence. The skipped, skipped_balances, skipped_masks, and skipped_accounts metadata are concatenated too.

Trait Implementations

impl Clone for StateDiff

fn clone(&self) -> StateDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StateDiff

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

Formats the value using the given formatter.

impl Default for StateDiff

fn default() -> StateDiff

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StateDiff

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StateDiff

impl PartialEq for StateDiff

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StateDiff