Struct CpuProver 

pub struct CpuProver<SC: StarkGenericConfig, A> { /* private fields */ }

A prover implementation based on x86 and ARM CPUs.

Trait Implementations

impl<SC, A> MachineProver<SC, A> for CpuProver<SC, A>

where SC: 'static + StarkGenericConfig + Send + Sync, A: MachineAir<SC::Val> + for<'a> Air<ProverConstraintFolder<'a, SC>> + Air<InteractionBuilder<Val<SC>>> + for<'a> Air<VerifierConstraintFolder<'a, SC>> + for<'a> Air<SymbolicAirBuilder<Val<SC>>>, A::Record: MachineRecord<Config = SP1CoreOpts>, SC::Val: PrimeField32, Com<SC>: Send + Sync, PcsProverData<SC>: Send + Sync + Serialize + DeserializeOwned, OpeningProof<SC>: Send + Sync, SC::Challenger: Clone,

fn open( &self, pk: &StarkProvingKey<SC>, data: ShardMainData<SC, Self::DeviceMatrix, Self::DeviceProverData>, challenger: &mut <SC as StarkGenericConfig>::Challenger, ) -> Result<ShardProof<SC>, Self::Error>

Prove the program for the given shard and given a commitment to the main data.

fn prove( &self, pk: &StarkProvingKey<SC>, records: Vec<A::Record>, challenger: &mut SC::Challenger, opts: <A::Record as MachineRecord>::Config, ) -> Result<MachineProof<SC>, Self::Error>

where A: for<'a> Air<DebugConstraintBuilder<'a, Val<SC>, SC::Challenge>>,

Prove the execution record is valid.

Given a proving key pk and a matching execution record record, this function generates a STARK proof that the execution record is valid.

type DeviceMatrix = DenseMatrix<<<<SC as StarkGenericConfig>::Pcs as Pcs<<SC as StarkGenericConfig>::Challenge, <SC as StarkGenericConfig>::Challenger>>::Domain as PolynomialSpace>::Val>

The type used to store the traces.

type DeviceProverData = <<SC as StarkGenericConfig>::Pcs as Pcs<<SC as StarkGenericConfig>::Challenge, <SC as StarkGenericConfig>::Challenger>>::ProverData

The type used to store the polynomial commitment schemes data.

type DeviceProvingKey = StarkProvingKey<SC>

The type used to store the proving key.

type Error = CpuProverError

The type used for error handling.

fn new(machine: StarkMachine<SC, A>) -> Self

Create a new prover from a given machine.

fn machine(&self) -> &StarkMachine<SC, A>

A reference to the machine that this prover is using.

fn setup( &self, program: &A::Program, ) -> (Self::DeviceProvingKey, StarkVerifyingKey<SC>)

Setup the preprocessed data into a proving and verifying key.

fn pk_from_vk( &self, program: &A::Program, vk: &StarkVerifyingKey<SC>, ) -> Self::DeviceProvingKey

Setup the proving key given a verifying key. This is similar to setup but faster since some computed information is already in the verifying key.

fn pk_to_device(&self, pk: &StarkProvingKey<SC>) -> Self::DeviceProvingKey

Copy the proving key from the host to the device.

fn pk_to_host(&self, pk: &Self::DeviceProvingKey) -> StarkProvingKey<SC>

Copy the proving key from the device to the host.

fn commit( &self, record: &A::Record, named_traces: Vec<(String, RowMajorMatrix<Val<SC>>)>, ) -> ShardMainData<SC, Self::DeviceMatrix, Self::DeviceProverData>

Commit to the main traces.

fn generate_traces( &self, record: &A::Record, ) -> Vec<(String, RowMajorMatrix<Val<SC>>)>

Generate the main traces.

fn observe( &self, challenger: &mut SC::Challenger, commitment: Com<SC>, public_values: &[SC::Val], )

Observe the main commitment and public values and update the challenger.

fn config(&self) -> &SC

The stark config for the machine.

fn num_pv_elts(&self) -> usize

The number of public values elements.

fn shard_chips<'a, 'b>( &'a self, record: &'b A::Record, ) -> impl Iterator<Item = &'b MachineChip<SC, A>>

where SC: 'b, 'a: 'b,

The chips that will be necessary to prove this record.

fn debug_constraints( &self, pk: &StarkProvingKey<SC>, records: Vec<A::Record>, challenger: &mut SC::Challenger, )

where SC::Val: PrimeField32, A: for<'a> Air<DebugConstraintBuilder<'a, Val<SC>, SC::Challenge>>,

Debug the constraints for the given inputs.