Struct SP1Prover 

pub struct SP1Prover<C = CpuProverComponents>
where
    C: SP1ProverComponents,
{

    pub core_prover: <C as SP1ProverComponents>::CoreProver,
    pub compress_prover: <C as SP1ProverComponents>::CompressProver,
    pub shrink_prover: <C as SP1ProverComponents>::ShrinkProver,
    pub wrap_prover: <C as SP1ProverComponents>::WrapProver,
    pub lift_programs_lru: Mutex<LruCache<SP1RecursionShape, Arc<RecursionProgram<BabyBear>>>>,
    pub lift_cache_misses: AtomicUsize,
    pub join_programs_map: BTreeMap<SP1CompressWithVkeyShape, Arc<RecursionProgram<BabyBear>>>,
    pub join_cache_misses: AtomicUsize,
    pub recursion_vk_root: <BabyBearPoseidon2 as FieldHasher<BabyBear>>::Digest,
    pub recursion_vk_map: BTreeMap<<BabyBearPoseidon2 as FieldHasher<BabyBear>>::Digest, usize>,
    pub recursion_vk_tree: MerkleTree<BabyBear, BabyBearPoseidon2>,
    pub core_shape_config: Option<CoreShapeConfig<BabyBear>>,
    pub compress_shape_config: Option<RecursionShapeConfig<BabyBear, RecursionAir<BabyBear, sp1_prover::::CompressAir::{constant#0}>>>,
    pub wrap_program: OnceLock<Arc<RecursionProgram<BabyBear>>>,
    pub wrap_vk: OnceLock<StarkVerifyingKey<BabyBearPoseidon2Outer>>,
    pub vk_verification: bool,
}

A end-to-end for the SP1 RISC-V zkVM.

This object coordinates the proving along all the steps: core, compression, shrinkage, and wrapping.

Fields

core_prover: <C as SP1ProverComponents>::CoreProver

The core prover.

compress_prover: <C as SP1ProverComponents>::CompressProver

The compress prover (for both lift and join).

shrink_prover: <C as SP1ProverComponents>::ShrinkProver

The shrink prover.

wrap_prover: <C as SP1ProverComponents>::WrapProver

The wrap prover.

lift_programs_lru: Mutex<LruCache<SP1RecursionShape, Arc<RecursionProgram<BabyBear>>>>

The cache of compiled recursion programs.

lift_cache_misses: AtomicUsize

The number of cache misses for recursion programs.

join_programs_map: BTreeMap<SP1CompressWithVkeyShape, Arc<RecursionProgram<BabyBear>>>

The cache of compiled compression programs.

join_cache_misses: AtomicUsize

The number of cache misses for compression programs.

recursion_vk_root: <BabyBearPoseidon2 as FieldHasher<BabyBear>>::Digest

The root of the allowed recursion verification keys.

recursion_vk_map: BTreeMap<<BabyBearPoseidon2 as FieldHasher<BabyBear>>::Digest, usize>

The allowed VKs and their corresponding indices.

recursion_vk_tree: MerkleTree<BabyBear, BabyBearPoseidon2>

The Merkle tree for the allowed VKs.

core_shape_config: Option<CoreShapeConfig<BabyBear>>

The core shape configuration.

compress_shape_config: Option<RecursionShapeConfig<BabyBear, RecursionAir<BabyBear, sp1_prover::::CompressAir::{constant#0}>>>

The recursion shape configuration.

wrap_program: OnceLock<Arc<RecursionProgram<BabyBear>>>

The program for wrapping.

wrap_vk: OnceLock<StarkVerifyingKey<BabyBearPoseidon2Outer>>

The verifying key for wrapping.

vk_verification: bool

Whether to verify verification keys.

Implementations

impl<C> SP1Prover<C>

where C: SP1ProverComponents,

pub fn program_from_shape( &self, shape: SP1CompressProgramShape, shrink_shape: Option<RecursionShape>, ) -> Arc<RecursionProgram<BabyBear>>

impl<C> SP1Prover<C>

where C: SP1ProverComponents,

pub fn verify( &self, proof: &SP1CoreProofData, vk: &SP1VerifyingKey, ) -> Result<(), MachineVerificationError<BabyBearPoseidon2>>

Verify a core proof by verifying the shards, verifying lookup bus, verifying that the shards are contiguous and complete.

pub fn verify_compressed( &self, proof: &SP1ReduceProof<BabyBearPoseidon2>, vk: &SP1VerifyingKey, ) -> Result<(), MachineVerificationError<BabyBearPoseidon2>>

Verify a compressed proof.

pub fn verify_shrink( &self, proof: &SP1ReduceProof<BabyBearPoseidon2>, vk: &SP1VerifyingKey, ) -> Result<(), MachineVerificationError<BabyBearPoseidon2>>

Verify a shrink proof.

pub fn verify_wrap_bn254( &self, proof: &SP1ReduceProof<BabyBearPoseidon2Outer>, vk: &SP1VerifyingKey, ) -> Result<(), MachineVerificationError<BabyBearPoseidon2Outer>>

Verify a wrap bn254 proof.

pub fn verify_plonk_bn254( &self, proof: &PlonkBn254Proof, vk: &SP1VerifyingKey, public_values: &SP1PublicValues, build_dir: &Path, ) -> Result<(), Error>

Verifies a PLONK proof using the circuit artifacts in the build directory.

pub fn verify_groth16_bn254( &self, proof: &Groth16Bn254Proof, vk: &SP1VerifyingKey, public_values: &SP1PublicValues, build_dir: &Path, ) -> Result<(), Error>

Verifies a Groth16 proof using the circuit artifacts in the build directory.

impl<C> SP1Prover<C>

where C: SP1ProverComponents,

pub fn new() -> SP1Prover<C>

Initializes a new SP1Prover.

pub fn uninitialized() -> SP1Prover<C>

Creates a new SP1Prover with lazily initialized components.

pub fn setup( &self, elf: &[u8], ) -> (SP1ProvingKey, <<C as SP1ProverComponents>::CoreProver as MachineProver<BabyBearPoseidon2, RiscvAir<BabyBear>>>::DeviceProvingKey, Program, SP1VerifyingKey)

Creates a proving key and a verifying key for a given RISC-V ELF.

pub fn get_program(&self, elf: &[u8]) -> Result<Program, Report>

Get a program with an allowed preprocessed shape.

pub fn execute<'a>( &'a self, elf: &[u8], stdin: &SP1Stdin, context: SP1Context<'a>, ) -> Result<(SP1PublicValues, [u8; 32], ExecutionReport), ExecutionError>

Execute an SP1 program with the specified inputs.

pub fn prove_core<'a>( &'a self, pk_d: &<<C as SP1ProverComponents>::CoreProver as MachineProver<BabyBearPoseidon2, RiscvAir<BabyBear>>>::DeviceProvingKey, program: Program, stdin: &SP1Stdin, opts: SP1ProverOpts, context: SP1Context<'a>, ) -> Result<SP1ProofWithMetadata<SP1CoreProofData>, SP1CoreProverError>

Generate shard proofs which split up and prove the valid execution of a RISC-V program with the core prover. Uses the provided context.

pub fn compress( &self, vk: &SP1VerifyingKey, proof: SP1ProofWithMetadata<SP1CoreProofData>, deferred_proofs: Vec<SP1ReduceProof<BabyBearPoseidon2>>, opts: SP1ProverOpts, ) -> Result<SP1ReduceProof<BabyBearPoseidon2>, SP1RecursionProverError>

Reduce shards proofs to a single shard proof using the recursion prover.

pub fn shrink( &self, reduced_proof: SP1ReduceProof<BabyBearPoseidon2>, opts: SP1ProverOpts, ) -> Result<SP1ReduceProof<BabyBearPoseidon2>, SP1RecursionProverError>

Wrap a reduce proof into a STARK proven over a SNARK-friendly field.

pub fn wrap_bn254( &self, compressed_proof: SP1ReduceProof<BabyBearPoseidon2>, opts: SP1ProverOpts, ) -> Result<SP1ReduceProof<BabyBearPoseidon2Outer>, SP1RecursionProverError>

Wrap a reduce proof into a STARK proven over a SNARK-friendly field.

pub fn wrap_plonk_bn254( &self, proof: SP1ReduceProof<BabyBearPoseidon2Outer>, build_dir: &Path, ) -> PlonkBn254Proof

Wrap the STARK proven over a SNARK-friendly field into a PLONK proof.

pub fn wrap_groth16_bn254( &self, proof: SP1ReduceProof<BabyBearPoseidon2Outer>, build_dir: &Path, ) -> Groth16Bn254Proof

Wrap the STARK proven over a SNARK-friendly field into a Groth16 proof.

pub fn recursion_program( &self, input: &SP1RecursionWitnessValues<BabyBearPoseidon2>, ) -> Arc<RecursionProgram<BabyBear>>

pub fn compress_program( &self, input: &SP1CompressWithVKeyWitnessValues<BabyBearPoseidon2>, ) -> Arc<RecursionProgram<BabyBear>>

pub fn shrink_program( &self, shrink_shape: RecursionShape, input: &SP1CompressWithVKeyWitnessValues<BabyBearPoseidon2>, ) -> Arc<RecursionProgram<BabyBear>>

pub fn wrap_program(&self) -> Arc<RecursionProgram<BabyBear>>

pub fn deferred_program( &self, input: &SP1DeferredWitnessValues<BabyBearPoseidon2>, ) -> Arc<RecursionProgram<BabyBear>>

pub fn get_recursion_core_inputs( &self, vk: &StarkVerifyingKey<BabyBearPoseidon2>, shard_proofs: &[ShardProof<BabyBearPoseidon2>], batch_size: usize, is_complete: bool, deferred_digest: [<<<BabyBearPoseidon2 as StarkGenericConfig>::Pcs as Pcs<<BabyBearPoseidon2 as StarkGenericConfig>::Challenge, <BabyBearPoseidon2 as StarkGenericConfig>::Challenger>>::Domain as PolynomialSpace>::Val; 8], ) -> Vec<SP1RecursionWitnessValues<BabyBearPoseidon2>>

pub fn get_recursion_deferred_inputs_with_initial_digest<'a>( &'a self, vk: &'a StarkVerifyingKey<BabyBearPoseidon2>, deferred_proofs: &[SP1ReduceProof<BabyBearPoseidon2>], deferred_digest: [<<<BabyBearPoseidon2 as StarkGenericConfig>::Pcs as Pcs<<BabyBearPoseidon2 as StarkGenericConfig>::Challenge, <BabyBearPoseidon2 as StarkGenericConfig>::Challenger>>::Domain as PolynomialSpace>::Val; 8], batch_size: usize, ) -> (Vec<SP1DeferredWitnessValues<BabyBearPoseidon2>>, [BabyBear; 8])

pub fn get_recursion_deferred_inputs<'a>( &'a self, vk: &'a StarkVerifyingKey<BabyBearPoseidon2>, deferred_proofs: &[SP1ReduceProof<BabyBearPoseidon2>], batch_size: usize, ) -> (Vec<SP1DeferredWitnessValues<BabyBearPoseidon2>>, [BabyBear; 8])

pub fn get_first_layer_inputs<'a>( &'a self, vk: &'a SP1VerifyingKey, shard_proofs: &[ShardProof<BabyBearPoseidon2>], deferred_proofs: &[SP1ReduceProof<BabyBearPoseidon2>], batch_size: usize, ) -> Vec<SP1CircuitWitness>

Generate the inputs for the first layer of recursive proofs.

pub fn hash_deferred_proofs( prev_digest: [<<<BabyBearPoseidon2 as StarkGenericConfig>::Pcs as Pcs<<BabyBearPoseidon2 as StarkGenericConfig>::Challenge, <BabyBearPoseidon2 as StarkGenericConfig>::Challenger>>::Domain as PolynomialSpace>::Val; 8], deferred_proofs: &[SP1ReduceProof<BabyBearPoseidon2>], ) -> [<<<BabyBearPoseidon2 as StarkGenericConfig>::Pcs as Pcs<<BabyBearPoseidon2 as StarkGenericConfig>::Challenge, <BabyBearPoseidon2 as StarkGenericConfig>::Challenger>>::Domain as PolynomialSpace>::Val; 8]

Accumulate deferred proofs into a single digest.

pub fn make_merkle_proofs( &self, input: SP1CompressWitnessValues<BabyBearPoseidon2>, ) -> SP1CompressWithVKeyWitnessValues<BabyBearPoseidon2>

Trait Implementations

impl<C> SubproofVerifier for SP1Prover<C>

where C: SP1ProverComponents,

fn verify_deferred_proof( &self, proof: &SP1ReduceProof<BabyBearPoseidon2>, vk: &StarkVerifyingKey<BabyBearPoseidon2>, vk_hash: [u32; 8], committed_value_digest: [u32; 8], ) -> Result<(), MachineVerificationError<BabyBearPoseidon2>>

Verify a deferred proof.