Struct winter_prover::StarkProof

pub struct StarkProof {
    pub context: Context,
    pub num_unique_queries: u8,
    pub commitments: Commitments,
    pub trace_queries: Vec<Queries>,
    pub constraint_queries: Queries,
    pub ood_frame: OodFrame,
    pub fri_proof: FriProof,
    pub pow_nonce: u64,
}

A proof generated by Winterfell prover.

A STARK proof contains information proving that a computation was executed correctly. A proof also contains basic metadata for the computation, but neither the definition of the computation itself, nor public inputs consumed by the computation are contained in a proof.

A proof can be serialized into a sequence of bytes using to_bytes() function, and deserialized from a sequence of bytes using from_bytes() function.

To estimate soundness of a proof (in bits), security_level() function can be used.

Fields

context: Context

Basic metadata about the execution of the computation described by this proof.

num_unique_queries: u8

Number of unique queries made by the verifier. This will be different from the context.options.num_queries if the same position in the domain was queried more than once.

commitments: Commitments

Commitments made by the prover during the commit phase of the protocol.

trace_queries: Vec<Queries>

Decommitments of extended execution trace values (for all trace segments) at position queried by the verifier.

constraint_queries: Queries

Decommitments of constraint composition polynomial evaluations at positions queried by the verifier.

ood_frame: OodFrame

Trace and constraint polynomial evaluations at an out-of-domain point.

fri_proof: FriProof

Low-degree proof for a DEEP composition polynomial.

pow_nonce: u64

Proof-of-work nonce for query seed grinding.

Implementations

impl StarkProof

pub fn options(&self) -> &ProofOptions

Returns STARK protocol parameters used to generate this proof.

pub fn trace_layout(&self) -> &TraceLayout

Returns a layout describing how columns of the execution trace described by this context are arranged into segments.

pub fn trace_length(&self) -> usize

Returns trace length for the computation described by this proof.

pub fn get_trace_info(&self) -> TraceInfo

Returns trace info for the computation described by this proof.

pub fn lde_domain_size(&self) -> usize

Returns the size of the LDE domain for the computation described by this proof.

pub fn security_level<H>(&self, conjectured: bool) -> u32

where H: Hasher,

Returns security level of this proof (in bits).

When conjectured is true, conjectured security level is returned; otherwise, provable security level is returned. Usually, the number of queries needed for provable security is 2x - 3x higher than the number of queries needed for conjectured security at the same security level.

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

Serializes this proof into a vector of bytes.

pub fn from_bytes(source: &[u8]) -> Result<StarkProof, DeserializationError>

Returns a STARK proof read from the specified source.

Errors

Returns an error of a valid STARK proof could not be read from the specified source.

pub fn new_dummy() -> StarkProof

Creates a dummy StarkProof for use in tests.

Trait Implementations

impl Clone for StarkProof

fn clone(&self) -> StarkProof

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StarkProof

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

Formats the value using the given formatter.

impl Deserializable for StarkProof

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

where R: ByteReader,

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 read_batch_from<R>( source: &mut R, num_elements: usize ) -> Result<Vec<Self>, DeserializationError>

where R: ByteReader,

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

impl PartialEq for StarkProof

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serializable for StarkProof

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

where W: ByteWriter,

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 write_batch_into<W>(source: &[Self], target: &mut W)

where W: ByteWriter,

Serializes all elements of the source and writes these bytes into the target.

fn get_size_hint(&self) -> usize

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

impl Eq for StarkProof

impl StructuralEq for StarkProof

impl StructuralPartialEq for StarkProof