Module trie

Available on crate feature trie only.

Re-exported reth trie types

Modules

array

Parallel iterator types for arrays ([T; N])

collections

Parallel iterator types for standard collections

forward_cursor

The implementation of forward-only in-memory cursor.

hash_builder

The implementation of hash builder. MPT hash builder implementation.

hashed_cursor

The cursor implementations for navigating hashed state.

iter

Traits for writing parallel programs using an iterator-style interface

metricsmetrics

Trie calculation metrics.

node_iter

The iterators for traversing existing intermediate hashes and updated trie leaves.

option

Parallel iterator types for options

prefix_set

The implementation of a container for storing intermediate changes to a trie. The container indicates when the trie has been modified.

prelude

The rayon prelude imports the various ParallelIterator traits. The intention is that one can include use rayon::prelude::* and have easy access to the various traits and methods you will need.

proof

Merkle proof generation.

range

Parallel iterator types for ranges, the type for values created by a..b expressions

range_inclusive

Parallel iterator types for inclusive ranges, the type for values created by a..=b expressions

result

Parallel iterator types for results

root

Common root computation functions.

serde_bincode_compatserde and serde-bincode-compat

Bincode-compatible serde implementations for trie types.

slice

Parallel iterator types for slices

stats

Trie calculation stats.

str

Parallel iterator types for strings

string

This module contains the parallel iterator types for owned strings (String). You will rarely need to interact with it directly unless you have need to name one of the iterator types.

test_utilstest-utils

Collection of trie-related test utilities.

trie_cursor

The cursor implementations for navigating account and storage tries.

triehashtest-utils

Implementation of hasher using our keccak256 hashing function for compatibility with triehash crate.

updates

Buffer for trie updates.

vec

Parallel iterator types for vectors (Vec<T>)

walker

The trie walker for iterating over the trie nodes.

witness

Trie witness generation.

Structs

AccountProof

The merkle proof with the relevant account info.

BranchNode

A branch node in an Ethereum Merkle Patricia Trie.

BranchNodeCompact

A struct representing a branch node in an Ethereum trie.

BranchNodeRef

A reference to BranchNode and its state mask. NOTE: The stack may contain more items that specified in the state mask.

BroadcastContext

Provides context to a closure called by broadcast.

ChunkedHashedPostState

An iterator that yields chunks of the state updates of at most size account and storage targets.

ChunkedMultiProofTargets

An iterator that yields chunks of the proof targets of at most size account and storage targets.

DecodedAccountProof

The merkle proof with the relevant account info.

DecodedMultiProof

This is a type of MultiProof that uses decoded proofs, meaning these proofs are stored as a collection of TrieNodes instead of RLP-encoded bytes.

DecodedStorageMultiProof

The decoded merkle multiproof for a storage trie.

DecodedStorageProof

The merkle proof of the storage entry, using decoded proofs.

ExtensionNode

An extension node in an Ethereum Merkle Patricia Trie.

ExtensionNodeRef

Reference to the extension node. See ExtensionNode from more information.

FnContext

Provides the calling context to a closure called by join_context.

HashBuilder

A component used to construct the root hash of the trie.

HashedAccountsSorted

Sorted account state optimized for iterating during state trie calculation.

HashedPostState

Representation of in-memory hashed state.

HashedPostStateSorted

Sorted hashed post state optimized for iterating during state trie calculation.

HashedStorage

Representation of in-memory hashed storage.

HashedStorageSorted

Sorted hashed storage optimized for iterating during state trie calculation.

IntermediateStateRootState

The intermediate state of the state root computation.

KeccakKeyHasher

A key hasher that uses the Keccak-256 hash function.

LeafNode

A leaf node represents the endpoint or terminal node in the trie. In other words, a leaf node is where actual values are stored.

LeafNodeRef

Reference to the leaf node. See LeafNode from more information.

MultiProof

The state multiproof of target accounts and multiproofs of their storage tries. Multiproof is effectively a state subtrie that only contains the nodes in the paths of target accounts.

MultiProofTargets

Proof targets map.

Nibbles

Structure representing a sequence of nibbles.

RlpNode

An RLP-encoded node.

Scope

Represents a fork-join scope which can be used to spawn any number of tasks. See scope() for more information.

ScopeFifo

Represents a fork-join scope which can be used to spawn any number of tasks. Those spawned from the same thread are prioritized in relative FIFO order. See scope_fifo() for more information.

StateRoot

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

StorageMultiProof

The merkle multiproof of storage trie.

StorageProof

The merkle proof of the storage entry.

StorageRoot

StorageRoot is used to compute the root node of an account storage trie.

StorageTrieEntry

Account storage trie node.

StoredNibbles

The representation of nibbles of the merkle trie stored in the database.

StoredNibblesSubKey

The representation of nibbles of the merkle trie stored in the database.

StoredSubNode

Walker sub node for storing intermediate state root calculation state in the database.

ThreadBuilder

Thread builder used for customization via ThreadPoolBuilder::spawn_handler.

ThreadPool

Represents a user created thread-pool.

ThreadPoolBuildError

Error when initializing a thread pool.

ThreadPoolBuilder

Used to create a new ThreadPool or to configure the global rayon thread pool.

TrieAccount

Represents an TrieAccount in the account trie.

TrieInput

Inputs for trie-related computations.

TrieMask

A struct representing a mask of 16 bits, used for Ethereum trie operations.

Enums

StateRootProgress

The progress of the state root computation.

TrieNode

Enum representing an MPT trie node.

Yield

Result of yield_now() or yield_local().

Constants

CHILD_INDEX_RANGE

The range of valid child indexes.

EMPTY_ROOT_HASH

Root hash of an empty trie.

TRIE_ACCOUNT_RLP_MAX_SIZE

The maximum size of RLP encoded trie account in bytes. 2 (header) + 4 * 1 (field lens) + 8 (nonce) + 32 * 3 (balance, storage root, code hash)

Traits

KeyHasher

Trait for hashing keys in state.

Functions

broadcast

Executes op within every thread in the current threadpool. If this is called from a non-Rayon thread, it will execute in the global threadpool. Any attempts to use join, scope, or parallel iterators will then operate within that threadpool. When the call has completed on each thread, returns a vector containing all of their return values.

current_num_threads

Returns the number of threads in the current registry. If this code is executing within a Rayon thread-pool, then this will be the number of threads for the thread-pool of the current thread. Otherwise, it will be the number of threads for the global thread-pool.

current_thread_index

If called from a Rayon worker thread, returns the index of that thread within its current pool; if not called from a Rayon thread, returns None.

encode_path_leaf

Encodes a given path leaf as a compact array of bytes.

in_place_scope

Creates a “fork-join” scope s and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

in_place_scope_fifo

Creates a “fork-join” scope s with FIFO order, and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

join

Takes two closures and potentially runs them in parallel. It returns a pair of the results from those closures.

join_context

Identical to join, except that the closures have a parameter that provides context for the way the closure has been called, especially indicating whether they’re executing on a different thread than where join_context was called. This will occur if the second job is stolen by a different thread, or if join_context was called from outside the thread pool to begin with.

max_num_threads

Returns the maximum number of threads that Rayon supports in a single thread-pool.

rlp_nodeDeprecated

Given an RLP-encoded node, returns it either as rlp(node) or rlp(keccak(rlp(node))).

scope

Creates a “fork-join” scope s and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

scope_fifo

Creates a “fork-join” scope s with FIFO order, and invokes the closure with a reference to s. This closure can then spawn asynchronous tasks into s. Those tasks may run asynchronously with respect to the closure; they may themselves spawn additional tasks into s. When the closure returns, it will block until all tasks that have been spawned into s complete.

spawn

Puts the task into the Rayon threadpool’s job queue in the “static” or “global” scope. Just like a standard thread, this task is not tied to the current stack frame, and hence it cannot hold any references other than those with 'static lifetime. If you want to spawn a task that references stack data, use the scope() function to create a scope.

spawn_broadcast

Spawns an asynchronous task on every thread in this thread-pool. This task will run in the implicit, global scope, which means that it may outlast the current stack frame – therefore, it cannot capture any references onto the stack (you will likely need a move closure).

spawn_fifo

Fires off a task into the Rayon threadpool in the “static” or “global” scope. Just like a standard thread, this task is not tied to the current stack frame, and hence it cannot hold any references other than those with 'static lifetime. If you want to spawn a task that references stack data, use the scope_fifo() function to create a scope.

word_rlpDeprecated

Optimization for quick RLP-encoding of a 32-byte word.

yield_local

Cooperatively yields execution to local Rayon work.

yield_now

Cooperatively yields execution to Rayon.