Enum MaybePruned 

pub enum MaybePruned<T> {
    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<T> MaybePruned<T>

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>>

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.

impl MaybePruned<ReceiptClaim>

pub fn join(&self, other: &Self) -> Result<Self, PrunedValueError>

Produce the claim for joining two claims of execution in a continuation, asserting the reachability of the post state of other from the pre state of self.

pub fn resolve<Claim: Digestible + ?Sized>( &self, assumption: &Claim, ) -> Result<Self>

Available on crate feature std only.

Produce the claim for resolving an assumption from the conditional claim (self). The conditional claim must have a full (unpruned) assumptions list and the given claim must be the head of the list.

impl MaybePruned<WorkClaim<ReceiptClaim>>

pub fn join(&self, other: &Self) -> Result<Self, WorkClaimError>

Joins two possibly pruned work claims by combining their receipt claims and work values while ensuring the consumed nonce ranges are disjoint.

pub fn resolve<Claim: Digestible + ?Sized>( &self, assumption: &Claim, ) -> Result<Self>

Available on crate feature std only.

Resolves assumptions in a possibly pruned work claim while preserving the work value.

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 MaybePruned<Work>

pub fn join(&self, other: &Self) -> Result<Self, WorkClaimError>

Joins two possibly pruned work values by combining their nonce ranges and summing their values, ensuring the nonce ranges are disjoint.

Trait Implementations

impl<T> BorshDeserialize for MaybePruned<T>

where T: 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: BorshSerialize,

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

impl<T: Clone> Clone for MaybePruned<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MaybePruned<T>

where T: 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,

fn default() -> Self

Returns the “default value” for a type.

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

where T: 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,

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: 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>

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: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.