Struct CompactProof 

pub struct CompactProof {
    pub encoded_nodes: Vec<Vec<u8>>,
}

Storage proof in compact form.

Fields

encoded_nodes: Vec<Vec<u8>>

Implementations

impl CompactProof

pub fn iter_compact_encoded_nodes(&self) -> impl Iterator<Item = &[u8]>

Return an iterator on the compact encoded nodes.

pub fn to_storage_proof<H>( &self, expected_root: &<H as Hasher>::Out, ) -> Result<(StorageProof, <H as Hasher>::Out), Error<<H as Hasher>::Out, Error<<H as Hasher>::Out>>>

where H: Hasher,

Decode to a full storage_proof.

The decoded root is always checked against expected_root.

pub fn to_memory_db<H>( &self, expected_root: &<H as Hasher>::Out, ) -> Result<(MemoryDB<H, HashKey<H>, Vec<u8>>, <H as Hasher>::Out), Error<<H as Hasher>::Out, Error<<H as Hasher>::Out>>>

where H: Hasher,

Convert self into a MemoryDB.

expected_root is the expected root of this compact proof. The decoded root is always checked against it.

Returns the memory db and the root of the trie.

Trait Implementations

impl Clone for CompactProof

fn clone(&self) -> CompactProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompactProof

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

Formats the value using the given formatter.

impl Decode for CompactProof

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<CompactProof, 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 DecodeWithMemTracking for CompactProof

impl Encode for CompactProof

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 EncodeLike for CompactProof

impl Eq for CompactProof

impl PartialEq for CompactProof

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CompactProof

impl TypeInfo for CompactProof

type Identity = CompactProof

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.