Struct UpdateBatch 

pub struct UpdateBatch {
    pub account_updates: Vec<TrieNode>,
    pub storage_updates: Vec<(H256, Vec<TrieNode>)>,
    pub blocks: Vec<Block>,
    pub receipts: Vec<(H256, Vec<Receipt>)>,
    pub code_updates: Vec<(H256, Code)>,
    pub commit_depth: Option<usize>,
    pub wait_for_flush: bool,
}

Batch of updates to apply to the store atomically.

Used during block execution to collect all state changes before committing them to the database in a single transaction.

Fields

account_updates: Vec<TrieNode>

New nodes to add to the state trie.

storage_updates: Vec<(H256, Vec<TrieNode>)>

Storage trie updates per account (keyed by hashed address).

blocks: Vec<Block>

Blocks to store.

receipts: Vec<(H256, Vec<Receipt>)>

Receipts to store, grouped by block hash.

code_updates: Vec<(H256, Code)>

Contract code updates (code hash -> bytecode).

commit_depth: Option<usize>

Commit gate for this batch’s trie layers (independent of wait_for_flush).

• None: live path (newPayload). The persist worker commits by the canonical head - DB_COMMIT_THRESHOLD safe-commit root.
• Some(depth): single-canonical-chain execution (batch import, full sync, startup state regeneration). The persist worker commits every layer deeper than depth (see [Trie::get_commitable_by_depth]), which bounds resident trie layers to ~depth.

wait_for_flush: bool

When the persist worker acks (independent of commit_depth).

• false: ack after staging, so the caller’s next-block execution overlaps this block’s disk flush. Used by the live path and the per-block re-execution paths (regen / full-sync fallback / import tail) — their memory is already bounded by commit_depth’s depth gate and the persist channel capacity, so waiting per block would only serialize CPU and I/O for no benefit.
• true: ack after flush, bounding in-flight work to ~1 message. Used by the bespoke batch path, where a single message carries ~1024 blocks (~1 GB of trie diff) and two in flight would be a real memory cost.