Struct StateRoot 

pub struct StateRoot<T, H> {
    pub trie_cursor_factory: T,
    pub hashed_cursor_factory: H,
    pub prefix_sets: TriePrefixSets,
    /* private fields */
}

Available on crate feature trie only.

StateRoot is used to compute the root node of a state trie.

Fields

trie_cursor_factory: T

The factory for trie cursors.

hashed_cursor_factory: H

The factory for hashed cursors.

prefix_sets: TriePrefixSets

A set of prefix sets that have changed.

Implementations

impl<T, H> StateRoot<T, H>

pub fn new(trie_cursor_factory: T, hashed_cursor_factory: H) -> StateRoot<T, H>

Creates StateRoot with trie_cursor_factory and hashed_cursor_factory. All other parameters are set to reasonable defaults.

The cursors created by given factories are then used to walk through the accounts and calculate the state root value with.

pub fn with_prefix_sets(self, prefix_sets: TriePrefixSets) -> StateRoot<T, H>

Set the prefix sets.

pub const fn with_threshold(self, threshold: u64) -> StateRoot<T, H>

Set the threshold.

pub const fn with_no_threshold(self) -> StateRoot<T, H>

Set the threshold to maximum value so that intermediate progress is not returned.

pub fn with_intermediate_state( self, state: Option<IntermediateStateRootState>, ) -> StateRoot<T, H>

Set the previously recorded intermediate state.

pub fn with_hashed_cursor_factory<HF>( self, hashed_cursor_factory: HF, ) -> StateRoot<T, HF>

Set the hashed cursor factory.

pub fn with_trie_cursor_factory<TF>( self, trie_cursor_factory: TF, ) -> StateRoot<TF, H>

Set the trie cursor factory.

impl<T, H> StateRoot<T, H>

where T: TrieCursorFactory + Clone, H: HashedCursorFactory + Clone,

pub fn root_with_updates( self, ) -> Result<(FixedBytes<32>, TrieUpdates), StateRootError>

Walks the intermediate nodes of existing state trie (if any) and hashed entries. Feeds the nodes into the hash builder. Collects the updates in the process.

Ignores the threshold.

Returns

The state root and the trie updates.

pub fn root(self) -> Result<FixedBytes<32>, StateRootError>

Walks the intermediate nodes of existing state trie (if any) and hashed entries. Feeds the nodes into the hash builder.

Returns

The state root hash.

pub fn root_with_progress(self) -> Result<StateRootProgress, StateRootError>

Walks the intermediate nodes of existing state trie (if any) and hashed entries. Feeds the nodes into the hash builder. Collects the updates in the process.

Returns

The intermediate progress of state root computation.

Trait Implementations

impl<'a, TX> DatabaseStateRoot<'a, TX> for StateRoot<DatabaseTrieCursorFactory<&'a TX>, DatabaseHashedCursorFactory<&'a TX>>

where TX: DbTx,

fn from_tx( tx: &'a TX, ) -> StateRoot<DatabaseTrieCursorFactory<&'a TX>, DatabaseHashedCursorFactory<&'a TX>>

Create a new StateRoot instance.

fn incremental_root_calculator( tx: &'a TX, range: RangeInclusive<u64>, ) -> Result<StateRoot<DatabaseTrieCursorFactory<&'a TX>, DatabaseHashedCursorFactory<&'a TX>>, StateRootError>

Given a block number range, identifies all the accounts and storage keys that have changed.

fn incremental_root( tx: &'a TX, range: RangeInclusive<u64>, ) -> Result<FixedBytes<32>, StateRootError>

Computes the state root of the trie with the changed account and storage prefixes and existing trie nodes.

fn incremental_root_with_updates( tx: &'a TX, range: RangeInclusive<u64>, ) -> Result<(FixedBytes<32>, TrieUpdates), StateRootError>

Computes the state root of the trie with the changed account and storage prefixes and existing trie nodes collecting updates in the process.

fn incremental_root_with_progress( tx: &'a TX, range: RangeInclusive<u64>, ) -> Result<StateRootProgress, StateRootError>

Computes the state root of the trie with the changed account and storage prefixes and existing trie nodes collecting updates in the process.

fn overlay_root( tx: &'a TX, post_state: &HashedPostStateSorted, ) -> Result<FixedBytes<32>, StateRootError>

Calculate the state root for this HashedPostStateSorted. Internally, this method retrieves prefixsets and uses them to calculate incremental state root.

fn overlay_root_with_updates( tx: &'a TX, post_state: &HashedPostStateSorted, ) -> Result<(FixedBytes<32>, TrieUpdates), StateRootError>

Calculates the state root for this HashedPostStateSorted and returns it alongside trie updates. See Self::overlay_root for more info.

fn overlay_root_from_nodes( tx: &'a TX, input: TrieInputSorted, ) -> Result<FixedBytes<32>, StateRootError>

Calculates the state root for provided HashedPostStateSorted using cached intermediate nodes.

fn overlay_root_from_nodes_with_updates( tx: &'a TX, input: TrieInputSorted, ) -> Result<(FixedBytes<32>, TrieUpdates), StateRootError>

Calculates the state root and trie updates for provided HashedPostStateSorted using cached intermediate nodes.

impl<T, H> Debug for StateRoot<T, H>

where T: Debug, H: Debug,

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

Formats the value using the given formatter.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.