Struct StarkProvingKey 

pub struct StarkProvingKey<SC: StarkGenericConfig> {
    pub commit: Com<SC>,
    pub pc_start: Val<SC>,
    pub initial_global_cumulative_sum: SepticDigest<Val<SC>>,
    pub traces: Vec<RowMajorMatrix<Val<SC>>>,
    pub data: PcsProverData<SC>,
    pub chip_ordering: HashMap<String, usize>,
    pub local_only: Vec<bool>,
    pub constraints_map: HashMap<String, usize>,
}

A proving key for a STARK.

Fields

commit: Com<SC>

The commitment to the preprocessed traces.

pc_start: Val<SC>

The start pc of the program.

initial_global_cumulative_sum: SepticDigest<Val<SC>>

The starting global digest of the program, after incorporating the initial memory.

traces: Vec<RowMajorMatrix<Val<SC>>>

The preprocessed traces.

data: PcsProverData<SC>

The pcs data for the preprocessed traces.

chip_ordering: HashMap<String, usize>

The preprocessed chip ordering.

local_only: Vec<bool>

The preprocessed chip local only information.

constraints_map: HashMap<String, usize>

The number of total constraints for each chip.

Implementations

impl<SC: StarkGenericConfig> StarkProvingKey<SC>

pub fn observe_into(&self, challenger: &mut SC::Challenger)

Observes the values of the proving key into the challenger.

Trait Implementations

impl<SC: Clone + StarkGenericConfig> Clone for StarkProvingKey<SC>

fn clone(&self) -> StarkProvingKey<SC>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, SC: StarkGenericConfig> Deserialize<'de> for StarkProvingKey<SC>

where PcsProverData<SC>: DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<SC> MachineProvingKey<SC> for StarkProvingKey<SC>

where SC: 'static + StarkGenericConfig + Send + Sync, PcsProverData<SC>: Send + Sync + Serialize + DeserializeOwned, Com<SC>: Send + Sync,

fn preprocessed_commit(&self) -> Com<SC>

The main commitment.

fn pc_start(&self) -> Val<SC>

The start pc.

fn initial_global_cumulative_sum(&self) -> SepticDigest<Val<SC>>

The initial global cumulative sum.

fn observe_into(&self, challenger: &mut Challenger<SC>)

Observe itself in the challenger.

impl<SC: StarkGenericConfig> Serialize for StarkProvingKey<SC>

where PcsProverData<SC>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.