Struct CpuProveBuilder 

pub struct CpuProveBuilder<'a> { /* private fields */ }

A builder for proving a program on the CPU.

This builder provides a typed interface for configuring the SP1 RISC-V prover. The builder is used for only the crate::cpu::CpuProver client type.

Implementations

impl<'a> CpuProveBuilder<'a>

pub fn core(self) -> Self

Set the proof kind to [SP1ProofKind::Core] mode.

Details

This is the default mode for the prover. The proofs grow linearly in size with the number of cycles.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).core().run();

pub fn compressed(self) -> Self

Set the proof kind to [SP1ProofKind::Compressed] mode.

Details

This mode produces a proof that is of constant size, regardless of the number of cycles. It takes longer to prove than [SP1ProofKind::Core] due to the need to recursively aggregate proofs into a single proof.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).compressed().run();

pub fn plonk(self) -> Self

Set the proof mode to [SP1ProofKind::Plonk] mode.

Details

This mode produces a const size PLONK proof that can be verified on chain for roughly ~300k gas. This mode is useful for producing a maximally small proof that can be verified on chain. For more efficient SNARK wrapping, you can use the [SP1ProofKind::Groth16] mode but this mode is more .

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).plonk().run();

pub fn groth16(self) -> Self

Set the proof mode to [SP1ProofKind::Groth16] mode.

Details

This mode produces a Groth16 proof that can be verified on chain for roughly ~100k gas. This mode is useful for producing a proof that can be verified on chain with minimal gas.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).groth16().run();

pub fn mode(self, mode: SP1ProofMode) -> Self

Set the proof mode to the given [SP1ProofKind].

Details

This method is useful for setting the proof mode to a custom mode.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1ProofMode, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).mode(SP1ProofMode::Groth16).run();

pub fn shard_size(self, value: usize) -> Self

Set the shard size for proving.

Details

The value should be 2^16, 2^17, …, 2^22. You must be careful to set this value correctly, as it will affect the memory usage of the prover and the recursion/verification complexity. By default, the value is set to some predefined values that are optimized for performance based on the available amount of RAM on the system.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).shard_size(1 << 16).run();

pub fn shard_batch_size(self, value: usize) -> Self

Set the shard batch size for proving.

Details

This is the number of shards that are processed in a single batch in the prover. You should probably not change this value unless you know what you are doing.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).shard_batch_size(4).run();

pub fn cycle_limit(self, cycle_limit: u64) -> Self

Set the maximum number of cpu cycles to use for execution.

Details

If the cycle limit is exceeded, execution will return sp1_core_executor::ExecutionError::ExceededCycleLimit.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).cycle_limit(1000000).run();

pub fn deferred_proof_verification(self, value: bool) -> Self

Whether to enable deferred proof verification in the executor.

Arguments

• value - Whether to enable deferred proof verification in the executor.

Details

Default: true. If set to false, the executor will skip deferred proof verification. This is useful for reducing the execution time of the program and optimistically assuming that the deferred proofs are correct. Can also be used for mock proof setups that require verifying mock compressed proofs.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).deferred_proof_verification(false).run();

pub fn stdout<W: IoWriter>(self, writer: &'a mut W) -> Self

Override the default stdout of the guest program.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let mut stdout = Vec::new();

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
client.execute(elf, &stdin).stdout(&mut stdout).run();

pub fn stderr<W: IoWriter>(self, writer: &'a mut W) -> Self

Override the default stdout of the guest program.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let mut stderr = Vec::new();

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
client.execute(elf, &stdin).stderr(&mut stderr).run();

pub fn run(self) -> Result<SP1ProofWithPublicValues>

Run the prover with the built arguments.

Details

This method will run the prover with the built arguments. If the prover fails to run, the method will return an error.

Example

use sp1_sdk::{include_elf, Prover, ProverClient, SP1Stdin};

let elf = &[1, 2, 3];
let stdin = SP1Stdin::new();

let client = ProverClient::builder().cpu().build();
let (pk, vk) = client.setup(elf);
let proof = client.prove(&pk, &stdin).run().unwrap();