Struct Stark

pub struct Stark {
    pub security_level: usize,
    pub fri_expansion_factor: usize,
    pub num_trace_randomizers: usize,
    pub num_collinearity_checks: usize,
}

Parameters for the Zero-Knowledge Scalable Transparent ARgument of Knowledge (STARK) for Triton VM.

The two core methods are Stark::prove and Stark::verify.

Fields

security_level: usize

The conjectured security level in bits. Concretely, the system

• is perfectly complete, and
• has soundness error 2^(-security_level).

fri_expansion_factor: usize

The ratio between the lengths of the randomized trace domain and the FRI domain. Must be a power of 2 for efficiency reasons.

num_trace_randomizers: usize

The number of randomizers for the execution trace. The trace randomizers are integral for achieving zero-knowledge. In particular, they achieve ZK for the (DEEP) ALI part of the zk-STARK.

See also MasterTable::trace_randomizer_for_column.

num_collinearity_checks: usize

The number of collinearity checks to perform in FRI.

Implementations

impl Stark

pub fn new(security_level: usize, log2_of_fri_expansion_factor: usize) -> Self

Panics

Panics if log2_of_fri_expansion_factor is zero.

pub fn prove( &self, claim: &Claim, aet: &AlgebraicExecutionTrace, ) -> Result<Proof, ProvingError>

Prove the correctness of the given Claim using the given witness.

This method should be the first option to consider for proving. For more control over the proving process, see Prover.

pub fn verify( &self, claim: &Claim, proof: &Proof, ) -> Result<(), VerificationError>

Verify the accuracy of the given Claim, supported by the Proof.

See also Verifier.

pub fn derive_max_degree(&self, padded_height: usize) -> isize

👎Deprecated since 0.43.0: use stark.max_degree instead

pub fn max_degree(&self, padded_height: usize) -> isize

The upper bound to use for the maximum degree the quotients given the length of the trace and the number of trace randomizers. The degree of the quotients depends on the AIR constraints.

pub fn derive_fri(&self, padded_height: usize) -> Result<Fri, FriSetupError>

👎Deprecated since 0.43.0: use stark.fri instead

pub fn fri(&self, padded_height: usize) -> Result<Fri, FriSetupError>

The parameters for FRI. The length of the FRI domain has a major influence on proving time. It is influenced by the length of the execution trace and the FRI expansion factor, a security parameter.

In principle, the FRI domain length is also influenced by the AIR’s degree (see air::TARGET_DEGREE). However, by segmenting the quotient polynomial into TARGET_DEGREE-many parts, that influence is mitigated.

Trait Implementations

impl<'a> Arbitrary<'a> for Stark

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Stark

fn clone(&self) -> Stark

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Stark

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

Formats the value using the given formatter.

impl Default for Stark

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Stark

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Stark

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Stark

fn eq(&self, other: &Stark) -> 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 Stark

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Stark

impl Eq for Stark

impl StructuralPartialEq for Stark