Struct DeferredTrieData 

pub struct DeferredTrieData { /* private fields */ }

Shared handle to asynchronously populated trie data.

Uses a try-lock + fallback computation approach for deadlock-free access. If the deferred task hasn’t completed, computes trie data synchronously from stored unsorted inputs rather than blocking.

Implementations

impl DeferredTrieData

pub fn pending( hashed_state: Arc<HashedPostState>, trie_updates: Arc<TrieUpdates>, anchor_hash: B256, ancestors: Vec<Self>, ) -> Self

Create a new pending handle with fallback inputs for synchronous computation.

If the async task hasn’t completed when wait_cloned is called, the trie data will be computed synchronously from these inputs. This eliminates deadlock risk.

Arguments

• hashed_state - Unsorted hashed post-state from execution
• trie_updates - Unsorted trie updates from state root computation
• anchor_hash - The persisted ancestor hash this trie input is anchored to
• ancestors - Deferred trie data from ancestor blocks for merging

pub fn ready(bundle: ComputedTrieData) -> Self

Create a handle that is already populated with the given ComputedTrieData.

Useful when trie data is available immediately. Self::wait_cloned will return without any computation.

pub fn sort_and_build_trie_input( hashed_state: &HashedPostState, trie_updates: &TrieUpdates, anchor_hash: B256, ancestors: &[Self], ) -> ComputedTrieData

Sort block execution outputs and build a [TrieInputSorted] overlay.

The trie input overlay accumulates sorted hashed state (account/storage changes) and trie node updates from all in-memory ancestor blocks. This overlay is required for:

• Computing state roots on top of in-memory blocks
• Generating storage/account proofs for unpersisted state

Process

1. Sort the current block’s hashed state and trie updates
2. Merge ancestor overlays (oldest -> newest, so later state takes precedence)
3. Extend the merged overlay with this block’s sorted data

Used by both the async background task and the synchronous fallback path.

Arguments

• hashed_state - Unsorted hashed post-state (account/storage changes) from execution
• trie_updates - Unsorted trie node updates from state root computation
• anchor_hash - The persisted ancestor hash this trie input is anchored to
• ancestors - Deferred trie data from ancestor blocks for merging

pub fn wait_cloned(&self) -> ComputedTrieData

Returns trie data, computing synchronously if the async task hasn’t completed.

• If the async task has completed (Ready), returns the cached result.
• If pending, computes synchronously from stored inputs.

Deadlock is avoided as long as the provided ancestors form a true ancestor chain (a DAG):

• Each block only waits on its ancestors (blocks on the path to the persisted root)
• Sibling blocks (forks) are never in each other’s ancestor lists
• A block never waits on its descendants

Given that invariant, circular wait dependencies are impossible.

Trait Implementations

impl Clone for DeferredTrieData

fn clone(&self) -> DeferredTrieData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeferredTrieData

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

Formats the value using the given formatter.

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