Struct StarkProof 

pub struct StarkProof {
    pub trace_commitment: Hash256,
    pub constraint_commitment: Hash256,
    pub query_indices: Vec<usize>,
    pub fri_proof: FriProof,
    pub config: StarkConfig,
    pub trace_length: usize,
    pub public_input_hash: Hash256,
    pub constraints: Vec<StarkConstraint>,
    pub public_input_authentication_path: Vec<Hash256>,
    pub trace_query_proofs: Vec<TraceQueryProof>,
    pub trace_rows: Vec<Vec<u64>>,
}

A complete STARK proof.

Fields

trace_commitment: Hash256

Commitment to the execution trace.

constraint_commitment: Hash256

Commitment to the constraint polynomial.

query_indices: Vec<usize>

Query indices (deterministic, derived from commitments).

fri_proof: FriProof

FRI proof of low degree.

config: StarkConfig

Configuration used.

trace_length: usize

Number of rows in the trace (needed for verification).

public_input_hash: Hash256

Hash of the public inputs (first row of trace) for verification.

constraints: Vec<StarkConstraint>

Public transition constraints for the statement being proven.

public_input_authentication_path: Vec<Hash256>

Merkle authentication path from the public input row to trace root.

trace_query_proofs: Vec<TraceQueryProof>

Merkle-authenticated trace openings for every Fiat-Shamir query.

trace_rows: Vec<Vec<u64>>

Complete committed trace rows.

This keeps the unaudited pedagogical verifier fail-closed: it can recompute the trace root, recompute the constraint commitment, and evaluate every transition instead of trusting sampled openings as a production STARK soundness argument.

Trait Implementations

impl Clone for StarkProof

fn clone(&self) -> StarkProof

Returns a duplicate 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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StarkProof

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StarkProof

impl PartialEq for StarkProof

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for StarkProof

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StarkProof