Struct StarkVerifyingKey 

#[repr(C)]
pub struct StarkVerifyingKey<F, Digest> {
    pub preprocessed_data: Option<VerifierSinglePreprocessedData<Digest>>,
    pub params: StarkVerifyingParams,
    pub symbolic_constraints: SymbolicConstraintsDag<F>,
    pub max_constraint_degree: u8,
    pub is_required: bool,
    pub unused_variables: Vec<SymbolicVariable<F>>,
}

Verifying key for a single STARK (corresponding to single AIR matrix)

Fields

preprocessed_data: Option<VerifierSinglePreprocessedData<Digest>>

Preprocessed trace data, if any

params: StarkVerifyingParams

Parameters of the STARK

symbolic_constraints: SymbolicConstraintsDag<F>

Symbolic constraints of the AIR in all challenge phases. This is a serialization of the constraints in the AIR.

max_constraint_degree: u8

The maximum degree of any polynomial (constraint or interaction) for this AIR.

is_required: bool

True means this AIR must have non-empty trace.

unused_variables: Vec<SymbolicVariable<F>>

Symbolic variables referenced unreferenced by the AIR.

Implementations

impl<Val, Com> StarkVerifyingKey<Val, Com>

pub fn num_cached_mains(&self) -> usize

pub fn num_parts(&self) -> usize

pub fn has_interaction(&self) -> bool

pub fn num_interactions(&self) -> usize

pub fn dag_main_part_index_to_commit_index(&self, index: usize) -> usize

Converts from a main part index (as used by the constraint DAG) to the commitment part indexing scheme that includes preprocessed trace.

Trait Implementations

impl<F: Clone, Digest: Clone> Clone for StarkVerifyingKey<F, Digest>

fn clone(&self) -> StarkVerifyingKey<F, Digest>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug, Digest: Debug> Debug for StarkVerifyingKey<F, Digest>

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

Formats the value using the given formatter.

impl<'de, F, Digest> Deserialize<'de> for StarkVerifyingKey<F, Digest>

where F: Deserialize<'de>, Digest: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F, Digest> Serialize for StarkVerifyingKey<F, Digest>

where F: Serialize, Digest: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.