Enum DeferredProof 

pub enum DeferredProof {
    Empty,
    Wire(DeferredStateWire),
    Stark {
        proof: StarkProof,
        public_root: DeferredRoot,
    },
}

Proof material for the precompile claims associated with an execution proof.

Verification returns the deferred root used to check the VM STARK proof. Wire is the partial form; Empty and Stark are final forms.

Variants are public so callers can construct and inspect deferred proof material directly.

Variants

Empty

No precompile claims were produced. Verifiers resolve this to crate::deferred::TRUE_DIGEST.

Wire(DeferredStateWire)

Canonical deferred-state wire for a partial proof.

Stark

A precompile VM STARK proof for this execution’s exact deferred root.

After proof verifies against public_root, that root is used to verify the VM STARK proof.

Fields

proof: StarkProof

public_root: DeferredRoot

Implementations

impl DeferredProof

pub const fn empty() -> Self

Creates an empty deferred proof.

pub const fn wire(wire: DeferredStateWire) -> Self

Creates a deferred proof backed by a wire opening.

pub const fn stark(proof: StarkProof, public_root: DeferredRoot) -> Self

Creates a deferred proof backed by a precompile VM STARK proof.

pub const fn is_empty(&self) -> bool

Returns true if this deferred proof is DeferredProof::Empty.

pub const fn is_final(&self) -> bool

Returns true if this deferred proof is in final form.

This is a shape check only: it accepts empty and STARK-backed proofs and rejects wire-backed partial proofs. It does not verify the contained proof material.

pub const fn as_wire(&self) -> Option<&DeferredStateWire>

Returns the wire opening if this deferred proof is DeferredProof::Wire.

pub const fn as_stark(&self) -> Option<(&StarkProof, DeferredRoot)>

Returns the nested proof and public root if this proof is DeferredProof::Stark.

Trait Implementations

impl Clone for DeferredProof

fn clone(&self) -> DeferredProof

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeferredProof

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

Formats the value using the given formatter.

impl Deserializable for DeferredProof

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl Eq for DeferredProof

impl From<DeferredStateWire> for DeferredProof

fn from(wire: DeferredStateWire) -> Self

Converts to this type from the input type.

impl PartialEq for DeferredProof

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

Equality operator ==.

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

Inequality operator !=.

impl Serializable for DeferredProof

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl StructuralPartialEq for DeferredProof