Struct Receipt

pub struct Receipt {
    pub inner: InnerReceipt,
    pub journal: Journal,
    pub metadata: ReceiptMetadata,
}

A receipt attesting to the execution of a guest program.

A Receipt is a zero-knowledge proof of computation. It attests that the Receipt::journal was produced by executing a guest program based on a specified memory image. This image is not included in the receipt; the verifier must provide an ImageID, a cryptographic hash corresponding to the expected image.

A prover can provide a Receipt to an untrusting party to convince them that the results contained within the Receipt (in the Receipt::journal) came from running specific code. Conversely, a verifier can inspect a receipt to confirm that its results must have been generated from the expected code, even when this code was run by an untrusted source.

Example

To create a Receipt attesting to the faithful execution of your code, run one of the prove functions from a Prover.

use risc0_zkvm::{default_prover, ExecutorEnv};
use risc0_zkvm_methods::FIB_ELF;

let env = ExecutorEnv::builder().write_slice(&[20]).build().unwrap();
let receipt = default_prover().prove(env, FIB_ELF).unwrap();

To confirm that a Receipt was honestly generated, use Receipt::verify and supply the ImageID of the code that should have been executed as a parameter. (See risc0_build for more information about how ImageIDs are generated.)

use risc0_zkvm::Receipt;

receipt.verify(FIB_ID).unwrap();

The public outputs of the Receipt are contained in the Receipt::journal. You can use Journal::decode to deserialize the journal as typed and structured data, or access the Journal::bytes directly.

Fields

inner: InnerReceipt

The polymorphic InnerReceipt.

journal: Journal

The public commitment written by the guest.

This data is cryptographically authenticated in Receipt::verify.

metadata: ReceiptMetadata

Metadata providing context on the receipt, about the proving system, SDK versions, and other information to help with interoperability. It is not cryptographically bound to the receipt, and should not be used for security-relevant decisions, such as choosing whether or not to accept a receipt based on it’s stated version.

Implementations

impl Receipt

pub fn new(inner: InnerReceipt, journal: Vec<u8>) -> Self

Construct a new Receipt

pub fn verify( &self, image_id: impl Into<Digest>, ) -> Result<(), VerificationError>

Verify that this receipt proves a successful execution of the zkVM from the given image_id.

Uses the zero-knowledge proof system to verify the seal, and decodes the proven ReceiptClaim. This method additionally ensures that the guest exited with a successful status code (i.e. Halted(0)), the image ID is as expected, and the journal has not been tampered with.

pub fn verify_with_context( &self, ctx: &VerifierContext, image_id: impl Into<Digest>, ) -> Result<(), VerificationError>

Verify that this receipt proves a successful execution of the zkVM from the given image_id.

Uses the zero-knowledge proof system to verify the seal, and decodes the proven ReceiptClaim. This method additionally ensures that the guest exited with a successful status code (i.e. Halted(0)), the image ID is as expected, and the journal has not been tampered with.

pub fn verify_integrity_with_context( &self, ctx: &VerifierContext, ) -> Result<(), VerificationError>

Verify the integrity of this receipt, ensuring the claim and journal are attested to by the seal.

This does not verify the success of the guest execution. In particular, the guest could have exited with an error (e.g. ExitCode::Halted(1)) or faulted state. It also does not check the image ID, or otherwise constrain what guest was executed. After calling this method, the caller should check the ReceiptClaim fields relevant to their application. If you need to verify a successful guest execution and access the journal, the verify function is recommended.

pub fn claim(&self) -> Result<MaybePruned<ReceiptClaim>, VerificationError>

Extract the ReceiptClaim from this receipt.

pub fn seal_size(&self) -> usize

Total number of bytes used by the seals of this receipt.

Trait Implementations

impl BorshDeserialize for Receipt

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 BorshSerialize for Receipt

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

impl Clone for Receipt

fn clone(&self) -> Receipt

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Receipt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Receipt

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Receipt> for AssumptionReceipt

fn from(receipt: Receipt) -> Self

Create a proven assumption from a Receipt.

impl Serialize for Receipt

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Receipt> for Asset

Available on (crate features client or prove) and non-target_os="zkvm" only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(receipt: Receipt) -> Result<Self>

Performs the conversion.