Struct ProofCalculator 

pub struct ProofCalculator<TC, HC, VE: LeafValueEncoder> { /* private fields */ }

A proof calculator that generates Merkle proofs from leaf data and cached branch hashes.

The hashed cursor supplies leaves, while the trie cursor supplies cached branch hashes to skip subtries. Subtries containing proof targets or keys in the configured prefix set are recalculated.

The calculator:

• Accepts proof targets in any order and sorts them in place by parent context, then key.
• Returns proof nodes in depth-first post-order (children before parents).
• Automatically resets after each calculation
• Re-uses cursors from one calculation to the next

Implementations

impl<TC, HC, VE: LeafValueEncoder> ProofCalculator<TC, HC, VE>

pub fn new(trie_cursor: TC, hashed_cursor: HC) -> Self

Create a new ProofCalculator instance for calculating account proofs.

pub fn with_prefix_set(self, prefix_set: PrefixSet) -> Self

Sets the prefix set and returns self.

When given, all cached hashes matching the PrefixSet will be invalidated and their subtries recalculated.

impl<TC, HC, VE> ProofCalculator<TC, HC, VE>

where TC: TrieCursor, HC: HashedCursor, VE: LeafValueEncoder<Value = HC::Value>,

pub fn proof( &mut self, value_encoder: &mut VE, targets: &mut [ProofV2Target], ) -> Result<Vec<ProofTrieNodeV2>, StateProofError>

Generate a proof for the given targets.

Given a set of ProofV2Targets, returns nodes whose paths are a prefix of any target. The returned nodes are sorted in depth-first post-order (children before parents).

Targets may be supplied in any order. Calculation sorts the slice in place by known parent context, then by key within each group.

pub fn compute_root_hash( &mut self, proof_nodes: &[ProofTrieNodeV2], ) -> Result<Option<B256>, StateProofError>

Computes the root hash from a set of proof nodes.

Returns None if there is no root node (partial proof), otherwise returns the hash of the root node.

This method reuses the internal RLP encode buffer for efficiency.

pub fn root_node( &mut self, value_encoder: &mut VE, ) -> Result<ProofTrieNodeV2, StateProofError>

Calculates the root node of the trie.

This method does not accept targets nor retain proofs. Returns the root node which can be used to compute the root hash via Self::compute_root_hash.

impl<TC, HC> ProofCalculator<TC, HC, StorageValueEncoder>

where TC: TrieStorageCursor, HC: HashedStorageCursor<Value = U256>,

pub fn new_storage(trie_cursor: TC, hashed_cursor: HC) -> Self

Create a new StorageProofCalculator instance.

pub fn storage_proof( &mut self, hashed_address: B256, targets: &mut [ProofV2Target], ) -> Result<Vec<ProofTrieNodeV2>, StateProofError>

Generate a proof for a storage trie at the given hashed address.

Given a set of ProofV2Targets, returns nodes whose paths are a prefix of any target. The returned nodes are sorted in depth-first post-order (children before parents).

Targets may be supplied in any order. Calculation sorts the slice in place by known parent context, then by key within each group.

pub fn storage_root_node( &mut self, hashed_address: B256, ) -> Result<ProofTrieNodeV2, StateProofError>

Calculates the root node of a storage trie.

This method does not accept targets nor retain proofs. Returns the root node which can be used to compute the root hash via Self::compute_root_hash.

pub fn storage_root( &mut self, hashed_address: B256, ) -> Result<B256, StateProofError>

Calculates the storage root hash of the account at hashed_address.

Trait Implementations

impl<TC: Debug, HC: Debug, VE: Debug + LeafValueEncoder> Debug for ProofCalculator<TC, HC, VE>

where VE::DeferredEncoder: Debug,

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

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.