Struct sp_api::StorageProof

pub struct StorageProof { /* private fields */ }

A proof that some set of key-value pairs are included in the storage trie. The proof contains the storage values so that the partial storage backend can be reconstructed by a verifier that does not already have access to the key-value pairs.

The proof consists of the set of serialized nodes in the storage trie accessed when looking up the keys covered by the proof. Verifying the proof requires constructing the partial trie from the serialized nodes and performing the key lookups.

Implementations

impl StorageProof

pub fn new(trie_nodes: impl IntoIterator<Item = Vec<u8>>) -> StorageProof

Constructs a storage proof from a subset of encoded trie nodes in a storage backend.

pub fn new_with_duplicate_nodes_check( trie_nodes: impl IntoIterator<Item = Vec<u8>>, ) -> Result<StorageProof, StorageProofError>

Constructs a storage proof from a subset of encoded trie nodes in a storage backend.

Returns an error if the provided subset of encoded trie nodes contains duplicates.

pub fn empty() -> StorageProof

Returns a new empty proof.

An empty proof is capable of only proving trivial statements (ie. that an empty set of key-value pairs exist in storage).

pub fn is_empty(&self) -> bool

Returns whether this is an empty proof.

pub fn len(&self) -> usize

Returns the number of nodes in the proof.

pub fn into_iter_nodes(self) -> impl DoubleEndedIterator

Convert into an iterator over encoded trie nodes in lexicographical order constructed from the proof.

pub fn iter_nodes(&self) -> impl DoubleEndedIterator

Create an iterator over encoded trie nodes in lexicographical order constructed from the proof.

pub fn into_nodes(self) -> BTreeSet<Vec<u8>>

Convert into plain node vector.

pub fn into_memory_db<H>(self) -> MemoryDB<H, HashKey<H>, Vec<u8>>

where H: Hasher,

Creates a MemoryDB from Self.

pub fn to_memory_db<H>(&self) -> MemoryDB<H, HashKey<H>, Vec<u8>>

where H: Hasher,

Creates a MemoryDB from Self reference.

pub fn merge(proofs: impl IntoIterator<Item = StorageProof>) -> StorageProof

Merges multiple storage proofs covering potentially different sets of keys into one proof covering all keys. The merged proof output may be smaller than the aggregate size of the input proofs due to deduplication of trie nodes.

pub fn into_compact_proof<H>( self, root: <H as Hasher>::Out, ) -> Result<CompactProof, Error<<H as Hasher>::Out, Error<<H as Hasher>::Out>>>

where H: Hasher,

Encode as a compact proof with default trie layout.

pub fn to_compact_proof<H>( &self, root: <H as Hasher>::Out, ) -> Result<CompactProof, Error<<H as Hasher>::Out, Error<<H as Hasher>::Out>>>

where H: Hasher,

Encode as a compact proof with default trie layout.

pub fn encoded_compact_size<H>(self, root: <H as Hasher>::Out) -> Option<usize>

where H: Hasher,

Returns the estimated encoded size of the compact proof.

Running this operation is a slow operation (build the whole compact proof) and should only be in non sensitive path.

Return None on error.

Trait Implementations

impl Clone for StorageProof

fn clone(&self) -> StorageProof

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StorageProof

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

Formats the value using the given formatter.

impl Decode for StorageProof

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<StorageProof, Error>

where __CodecInputEdqy: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for StorageProof

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl PartialEq for StorageProof

fn eq(&self, other: &StorageProof) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TypeInfo for StorageProof

type Identity = StorageProof

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike for StorageProof

impl Eq for StorageProof

impl StructuralPartialEq for StorageProof