Struct VerMapWithProof 

pub struct VerMapWithProof<K, V, T: TrieCalc> { /* private fields */ }

A versioned key-value map with Merkle root hash computation.

Wraps a VerMap<K, V> and a TrieCalc back-end T to provide a merkle_root method that lazily computes the 32-byte Merkle root hash for any branch or commit.

Incremental updates

The internal trie tracks a sync point — the commit it was last synchronized to. When merkle_root is called:

1. If the trie is already synced to the target → return cached hash.
2. If the target is reachable via diff from the sync point → apply diff incrementally.
3. Otherwise → full rebuild from the store’s iterator.

Automatic cache lifecycle

The in-memory trie is transparently cached to disk so that process restarts only require an incremental diff rather than a full rebuild.

• Auto-load — when created via new or from_map, the constructor silently attempts to restore a previous cache file. On miss or corruption it falls back to a full rebuild on the next merkle_root call.
• Auto-save — the committed trie state is persisted eagerly inside merkle_root (specifically, after sync_to_commit completes). Errors are silently ignored because the cache is disposable: the authoritative data lives in the underlying VerMap.

No manual save_cache / load_cache calls are needed.

Implementations

impl<K, V, T> VerMapWithProof<K, V, T>

where K: KeyEnDeOrdered, V: ValueEnDe, T: TrieCalc,

pub fn new() -> Self

Creates a new VerMapWithProof with a fresh VerMap.

pub fn from_map(map: VerMap<K, V>) -> Self

Wraps an existing VerMap.

Runs gc for crash recovery (if needed) and B+ tree cleanup, then attempts to restore the trie cache.

pub fn map(&self) -> &VerMap<K, V>

Returns a reference to the underlying VerMap.

pub fn map_mut(&mut self) -> &mut VerMap<K, V>

Returns a mutable reference to the underlying VerMap.

Mutations through this reference will not automatically update the trie — call merkle_root to resynchronize.

pub fn merkle_root(&mut self, branch: BranchId) -> Result<Vec<u8>>

Computes the Merkle root hash for the current state of branch.

Includes uncommitted changes. Performs an incremental diff update when possible, falling back to a full rebuild otherwise.

pub fn merkle_root_at_commit(&mut self, commit: CommitId) -> Result<Vec<u8>>

Computes the Merkle root hash for a specific historical commit.

impl<K, V> VerMapWithProof<K, V, SmtCalc>

where K: KeyEnDeOrdered, V: ValueEnDe,

pub fn prove(&self, key: &[u8]) -> Result<SmtProof>

Generates a Merkle proof for the given key.

The trie must be synced (call merkle_root first) for proof generation to work.

pub fn verify_proof( root_hash: &[u8; 32], expected_key: &[u8], proof: &SmtProof, ) -> Result<bool>

Verifies a proof against a root hash and expected key.

impl<K, V> VerMapWithProof<K, V, MptCalc>

where K: KeyEnDeOrdered, V: ValueEnDe,

pub fn prove_mpt(&self, key: &K) -> Result<MptProof>

Generates a Merkle proof for the given key.

The trie must be synced (call merkle_root first) for proof generation to work.

pub fn verify_mpt_proof( root_hash: &[u8; 32], expected_key: &[u8], proof: &MptProof, ) -> Result<bool>

Verifies an MPT proof against a root hash for a specific key.

expected_key is the raw-byte key the caller expects this proof to cover.

Trait Implementations

impl<K, V, T> Default for VerMapWithProof<K, V, T>

where K: KeyEnDeOrdered, V: ValueEnDe, T: TrieCalc,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, T: TrieCalc> Drop for VerMapWithProof<K, V, T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.