Struct frame_support::traits::base16::BasicProvingTrie

pub struct BasicProvingTrie<Hashing, Key, Value>
where
    Hashing: Hasher,
{ /* private fields */ }

A helper structure for building a basic base-16 merkle trie and creating compact proofs for that trie. Proofs are created with latest substrate trie format (LayoutV1), and are not compatible with proofs using LayoutV0.

Implementations

impl<Hashing, Key, Value> BasicProvingTrie<Hashing, Key, Value>

where Hashing: Hasher, Key: Encode,

pub fn create_multi_proof(&self, keys: &[Key]) -> Result<Vec<u8>, DispatchError>

Create a compact merkle proof needed to prove all keys and their values are in the trie.

When verifying the proof created by this function, you must include all of the keys and values of the proof, else the verifier will complain that extra nodes are provided in the proof that are not needed.

Trait Implementations

impl<Hashing, Key, Value> ProofToHashes for BasicProvingTrie<Hashing, Key, Value>

where Hashing: Hasher, <Hashing as Hasher>::Out: MaxEncodedLen,

type Proof = [u8]

The Proof type we will use to determine the number of hashes.

fn proof_to_hashes(proof: &[u8]) -> Result<u32, DispatchError>

This function returns the number of hashes we expect to calculate based on the size of the proof. This is used for benchmarking, so for worst case scenario, we should round up.

impl<Hashing, Key, Value> ProvingTrie<Hashing, Key, Value> for BasicProvingTrie<Hashing, Key, Value>

where Hashing: Hasher, Key: Encode, Value: Encode + Decode,

fn generate_for<I>( items: I, ) -> Result<BasicProvingTrie<Hashing, Key, Value>, DispatchError>

where I: IntoIterator<Item = (Key, Value)>,

Create a new instance of a ProvingTrie using an iterator of key/value pairs.

fn root(&self) -> &<Hashing as Hasher>::Out

Access the underlying trie root.

fn query(&self, key: &Key) -> Option<Value>

Query a value contained within the current trie. Returns None if the nodes within the current MemoryDB are insufficient to query the item.

fn create_proof(&self, key: &Key) -> Result<Vec<u8>, DispatchError>

Create a compact merkle proof needed to prove a single key and its value are in the trie.

fn verify_proof( root: &<Hashing as Hasher>::Out, proof: &[u8], key: &Key, value: &Value, ) -> Result<(), DispatchError>

Verify the existence of key and value in a given trie root and proof.