Crate reth_trie_common

Commonly used types for trie usage.

Modules

arrayrayon

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

collectionsrayon

Parallel iterator types for standard collections

hash_builder

The implementation of hash builder. MPT hash builder implementation.

iterrayon

Traits for writing parallel programs using an iterator-style interface

optionrayon

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.

preluderayon

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

Re-export Proof verification logic.

rangerayon

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

range_inclusiverayon

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

resultrayon

Parallel iterator types for results

root

Common root computation functions.

serde_bincode_compatserde and serde-bincode-compat

Bincode-compatible serde implementations for trie types.

slicerayon

Parallel iterator types for slices

strrayon

Parallel iterator types for strings

stringrayon

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.

triehashtest-utils

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

updates

Buffer for trie updates.

vecrayon

Parallel iterator types for vectors (Vec<T>)

Structs

AccountProof

The merkle proof with the relevant account info.

BranchNode

Re-export A branch node in an Ethereum Merkle Patricia Trie.

BranchNodeCompact

Re-export A struct representing a branch node in an Ethereum trie.

BranchNodeRef

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

BroadcastContextrayon

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

Re-export An extension node in an Ethereum Merkle Patricia Trie.

ExtensionNodeRef

Re-export Reference to the extension node. See ExtensionNode from more information.

FnContextrayon

Provides the calling context to a closure called by join_context.

HashBuilder

Re-export 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.

KeccakKeyHasher

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

LeafNode

Re-export 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

Re-export 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

Re-export An RLP-encoded node.

Scoperayon

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

ScopeFiforayon

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.

StorageMultiProof

The merkle multiproof of storage trie.

StorageProof

The merkle proof of the storage entry.

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.

ThreadBuilderrayon

Thread builder used for customization via ThreadPoolBuilder::spawn_handler.

ThreadPoolrayon

Represents a user created thread-pool.

ThreadPoolBuildErrorrayon

Error when initializing a thread pool.

ThreadPoolBuilderrayon

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

TrieAccount

Re-export for convenience. Represents an TrieAccount in the account trie.

TrieInput

Inputs for trie-related computations.

TrieMask

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

Enums

TrieNode

Re-export Enum representing an MPT trie node.

Yieldrayon

Result of yield_now() or yield_local().

Constants

CHILD_INDEX_RANGE

Re-export The range of valid child indexes.

EMPTY_ROOT_HASH

Re-export 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

broadcastrayon

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_threadsrayon

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_indexrayon

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

Re-export Encodes a given path leaf as a compact array of bytes.

in_place_scoperayon

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_fiforayon

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.

joinrayon

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

join_contextrayon

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_threadsrayon

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

rlp_nodeDeprecated

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

scoperayon

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_fiforayon

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.

spawnrayon

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_broadcastrayon

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_fiforayon

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

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

yield_localrayon

Cooperatively yields execution to local Rayon work.

yield_nowrayon

Cooperatively yields execution to Rayon.