Enum AssumptionReceipt 

pub enum AssumptionReceipt {
    Proven(InnerAssumptionReceipt),
    Unresolved(Assumption),
}

An assumption attached to a guest execution as a result of calling env::verify or env::verify_integrity.

Variants

Proven(InnerAssumptionReceipt)

A Receipt for a proven assumption.

Upon proving, this receipt will be used as proof of the assumption that results from a call to env::verify, and the resulting receipt will be unconditional. As a result, Receipt::verify will return true and the verifier will accept the receipt.

Unresolved(Assumption)

An Assumption that is not directly proven to be true.

Proving an execution with an unresolved assumption will result in a conditional receipt. In order for the verifier to accept a conditional receipt, they must be given a AssumptionReceipt proving the assumption, or explicitly accept the assumption without proof.

Implementations

impl AssumptionReceipt

pub fn claim_digest(&self) -> Result<Digest, VerificationError>

Returns the digest of the claim for this AssumptionReceipt.

Trait Implementations

impl Clone for AssumptionReceipt

fn clone(&self) -> AssumptionReceipt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AssumptionReceipt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AssumptionReceipt

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Assumption> for AssumptionReceipt

fn from(assumption: Assumption) -> Self

Create an unresolved assumption from an Assumption.

impl<Claim> From<FakeReceipt<Claim>> for AssumptionReceipt

where Claim: Digestible,

fn from(receipt: FakeReceipt<Claim>) -> Self

Create a fake proven assumption from a FakeReceipt.

impl<Claim> From<GenericReceipt<Claim>> for AssumptionReceipt

where Claim: Digestible,

fn from(receipt: GenericReceipt<Claim>) -> Self

Create a proven assumption from a GenericReceipt.

impl From<InnerAssumptionReceipt> for AssumptionReceipt

fn from(receipt: InnerAssumptionReceipt) -> Self

Create a proven assumption from a InnerAssumptionReceipt.

impl From<InnerReceipt> for AssumptionReceipt

fn from(receipt: InnerReceipt) -> Self

Create a proven assumption from a InnerReceipt.

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 From<Receipt> for AssumptionReceipt

fn from(receipt: Receipt) -> Self

Create a proven assumption from a Receipt.

impl From<ReceiptClaim> for AssumptionReceipt

fn from(claim: ReceiptClaim) -> Self

Create an unresolved assumption from a 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<Claim> From<SuccinctReceipt<Claim>> for AssumptionReceipt

where Claim: Digestible,

fn from(receipt: SuccinctReceipt<Claim>) -> Self

Create a proven assumption from a SuccinctReceipt.

impl Serialize for AssumptionReceipt

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

where __S: Serializer,

Serialize this value into the given Serde serializer.