Enum MaybePruned

pub enum MaybePruned<T>
where
    T: Clone + Serialize,
{
    Value(T),
    Pruned(Digest),
}

Either a source value or a hash Digest of the source value.

This type supports creating “Merkle-ized structs”. Each field of a Merkle-ized struct can have either the full value, or it can be “pruned” and replaced with a digest committing to that value. One way to think of this is as a special Merkle tree of a predefined shape. Each field is a child node. Any field/node in the tree can be opened by providing the Merkle inclusion proof. When a subtree is pruned, the digest commits to the value of all contained fields. ReceiptClaim is the motivating example of this type of Merkle-ized struct.

Variants

Value(T)

Unpruned value.

Pruned(Digest)

Pruned value, which is a hash Digest of the value.

Implementations

impl MaybePruned<Assumptions>

pub fn is_empty(&self) -> bool

Check if the (possibly pruned) assumptions list is empty.

pub fn add(&mut self, assumption: MaybePruned<Assumption>)

Add an assumption to the head of the assumptions list.

If this value is pruned, then the result will also be a pruned value.

pub fn resolve(&mut self, resolved: &Digest, tail: &Digest) -> Result<()>

Mark an assumption as resolved and remove it from the list.

Assumptions can only be removed from the head of the list. If this value is pruned, then the result will also be a pruned value. The tail parameter should be equal to the digest of the list after the resolved assumption is removed.

impl<T> MaybePruned<T>

where T: Clone + Serialize,

pub fn value(self) -> Result<T, PrunedValueError>

Unwrap the value, or return an error.

pub fn as_value(&self) -> Result<&T, PrunedValueError>

Unwrap the value as a reference, or return an error.

pub fn as_value_mut(&mut self) -> Result<&mut T, PrunedValueError>

Unwrap the value as a mutable reference, or return an error.

impl<T> MaybePruned<Option<T>>

where T: Clone + Serialize,

pub fn is_none(&self) -> bool

Returns true is the value is None, or the value is pruned as the zero digest.

pub fn is_some(&self) -> bool

Returns true is the value is Some(_), or the value is pruned as a non-zero digest.

Trait Implementations

impl<T> BorshDeserialize for MaybePruned<T>

where T: Clone + Serialize + BorshDeserialize,

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<T> BorshSerialize for MaybePruned<T>

where T: Clone + Serialize + BorshSerialize,

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<T> Clone for MaybePruned<T>

where T: Clone + Serialize + Clone,

fn clone(&self) -> MaybePruned<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MaybePruned<T>

where T: Clone + Serialize + Digestible + Debug,

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

Format MaybePruned values are if they were a struct with value and digest fields. Digest field is always provided so that divergent trees of MaybePruned values can be compared.

impl<T> Default for MaybePruned<T>

where T: Digestible + Default + Clone + Serialize,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for MaybePruned<T>

where T: Clone + Serialize + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Digestible for MaybePruned<T>

where T: Digestible + Clone + Serialize,

fn digest<S: Sha256>(&self) -> Digest

Calculate a collision resistant hash for the typed and structured data.

impl<T> EnumExt for MaybePruned<T>

where T: Clone + Serialize + BorshDeserialize,

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.

impl From<MaybePruned<ReceiptClaim>> for AssumptionReceipt

fn from(claim: MaybePruned<ReceiptClaim>) -> Self

Create an unresolved assumption from a MaybePruned ReceiptClaim.

The control root will be set to all zeroes, which means that the assumption must be resolved with the same control root at the conditional receipt (i.e. that this assumption is for the same version of zkVM as the receipt it is attached to).

impl<T> From<T> for MaybePruned<T>

where T: Clone + Serialize,

fn from(value: T) -> Self

Converts to this type from the input type.

impl From<Vec<Assumption>> for MaybePruned<Assumptions>

fn from(value: Vec<Assumption>) -> Self

Converts to this type from the input type.

impl<T> Serialize for MaybePruned<T>

where T: Clone + Serialize + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.