Struct OpaqueLeaf

pub struct OpaqueLeaf(pub Vec<u8>);

A helper type to allow using arbitrary SCALE-encoded leaf data in the RuntimeApi.

The point is to be able to verify MMR proofs from external MMRs, where we don’t know the exact leaf type, but it’s enough for us to have it SCALE-encoded.

Note the leaf type should be encoded in its compact form when passed through this type. See FullLeaf documentation for details.

This type does not implement SCALE encoding/decoding on purpose to avoid confusion, it would have to be SCALE-compatible with the concrete leaf type, but due to SCALE limitations it’s not possible to know how many bytes the encoding of concrete leaf type uses.

Tuple Fields

0: Vec<u8>

Raw bytes of the leaf type encoded in its compact form.

NOTE it DOES NOT include length prefix (like Vec<u8> encoding would).

Implementations

impl OpaqueLeaf

pub fn from_leaf<T>(leaf: &T) -> OpaqueLeaf

where T: FullLeaf,

Convert a concrete MMR leaf into an opaque type.

pub fn from_encoded_leaf(encoded_leaf: Vec<u8>) -> OpaqueLeaf

Create a OpaqueLeaf given raw bytes of compact-encoded leaf.

pub fn try_decode<T>(&self) -> Option<T>

where T: Decode,

Attempt to decode the leaf into expected concrete type.

Trait Implementations

impl Clone for OpaqueLeaf

fn clone(&self) -> OpaqueLeaf

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpaqueLeaf

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OpaqueLeaf

fn deserialize<__D>( __deserializer: __D, ) -> Result<OpaqueLeaf, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FullLeaf for OpaqueLeaf

fn using_encoded<R, F>(&self, f: F, _compact: bool) -> R

where F: FnOnce(&[u8]) -> R,

Encode the leaf either in its full or compact form.

impl PartialEq for OpaqueLeaf

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for OpaqueLeaf

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OpaqueLeaf