Struct StarkVerifyingKey 

#[repr(C)]
pub struct StarkVerifyingKey<Val, Com> {
    pub preprocessed_data: Option<VerifierSinglePreprocessedData<Com>>,
    pub params: StarkVerifyingParams,
    pub symbolic_constraints: SymbolicConstraintsDag<Val>,
    pub quotient_degree: u8,
    pub rap_phase_seq_kind: RapPhaseSeqKind,
}

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

Fields

preprocessed_data: Option<VerifierSinglePreprocessedData<Com>>

Preprocessed trace data, if any

params: StarkVerifyingParams

Parameters of the STARK

symbolic_constraints: SymbolicConstraintsDag<Val>

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

quotient_degree: u8

The factor to multiply the trace degree by to get the degree of the quotient polynomial. Determined from the max constraint degree of the AIR constraints. This is equivalently the number of chunks the quotient polynomial is split into.

rap_phase_seq_kind: RapPhaseSeqKind

Implementations

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

pub fn num_cached_mains(&self) -> usize

pub fn has_common_main(&self) -> bool

pub fn has_interaction(&self) -> bool

Trait Implementations

impl<Val: Clone, Com: Clone> Clone for StarkVerifyingKey<Val, Com>

fn clone(&self) -> StarkVerifyingKey<Val, Com>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, Val, Com> Deserialize<'de> for StarkVerifyingKey<Val, Com>

where Val: Deserialize<'de>, Com: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Val, Com> Serialize for StarkVerifyingKey<Val, Com>

where Val: Serialize, Com: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.