Struct NetworkProveBuilder 

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

A builder for creating a proof request to the network.

Implementations

impl NetworkProveBuilder<'_>

pub fn core(self) -> Self

Set the proof kind to SP1ProofMode::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::{Prover, ProverClient, SP1Stdin};

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

let client = ProverClient::builder().network().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 SP1ProofMode::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 SP1ProofMode::Core due to the need to recursively aggregate proofs into a single proof.

Example

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

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

let client = ProverClient::builder().network().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 SP1ProofMode::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 SP1ProofMode::Groth16 mode but this mode is more .

Example

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

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

let client = ProverClient::builder().network().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 SP1ProofMode::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::{Prover, ProverClient, SP1Stdin};

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

let client = ProverClient::builder().network().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 SP1ProofMode.

Details

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

Example

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

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

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

pub fn timeout(self, timeout: Duration) -> Self

Set the timeout for the proof’s generation.

Details

This method sets the timeout for the proof’s generation. If the proof is not generated within the timeout, the NetworkProveBuilder::run will return an error.

Example

use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::time::Duration;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let builder = client.prove(&pk, &stdin).timeout(Duration::from_secs(60)).run();

pub fn skip_simulation(self, skip_simulation: bool) -> Self

Set whether to skip the local execution simulation step.

Details

This method sets whether to skip the local execution simulation step. If the simulation step is skipped, the request will sent to the network without verifying that the execution succeeds locally (without generating a proof). This feature is recommended for users who want to optimize the latency of the proof generation on the network.

Example

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

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

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

pub fn strategy(self, strategy: FulfillmentStrategy) -> Self

Sets the fulfillment strategy for the client.

Details

The strategy determines how the client will fulfill requests.

Example

use sp1_sdk::{network::FulfillmentStrategy, Prover, ProverClient, SP1Stdin};

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

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

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

Sets the cycle limit for the proof request.

Details

The cycle limit determines the maximum number of cycles that the program should take to execute. By default, the cycle limit is determined by simulating the program locally. However, you can manually set it if you know the exact cycle count needed and want to skip the simulation step locally.

The cycle limit ensures that a prover on the network will stop generating a proof once the cycle limit is reached, which prevents denial of service attacks.

Example

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

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let proof = client
    .prove(&pk, &stdin)
    .cycle_limit(1_000_000) // Set 1M cycle limit.
    .skip_simulation(true) // Skip simulation since the limit is set manually.
    .run()
    .unwrap();

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

Sets the gas limit for the proof request.

Details

The gas limit determines the maximum amount of gas that the program should consume. By default, the gas limit is determined by simulating the program locally. However, you can manually set it if you know the exact gas count needed and want to skip the simulation step locally.

The gas limit ensures that a prover on the network will stop generating a proof once the gas limit is reached, which prevents denial of service attacks.

Example

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

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let proof = client
    .prove(&pk, &stdin)
    .gas_limit(1_000_000) // Set 1M gas limit.
    .skip_simulation(true) // Skip simulation since the limit is set manually.
    .run()
    .unwrap();

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

Set the minimum auction period for the proof request in seconds.

Details

The minimum auction period determines how long to wait before settling the auction for the proof request. The auction only settles after both the minimum time has passed and at least one bid is received. If a value is not specified, the default is 1 second.

Only relevant if the strategy is set to FulfillmentStrategy::Auction.

Example

use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::time::Duration;

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

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

pub fn whitelist(self, whitelist: Option<Vec<Address>>) -> Self

Set the whitelist for the proof request.

Details

The whitelist determines which provers are allowed to bid on the proof request.

Only relevant if the strategy is set to FulfillmentStrategy::Auction.

If whitelist is None when requesting a proof, a set of recently reliable provers will be used.

Example

use alloy_primitives::Address;
use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::str::FromStr;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let whitelist = vec![Address::from_str("0x123").unwrap(), Address::from_str("0x456").unwrap()];
let builder = client.prove(&pk, &stdin).whitelist(Some(whitelist)).run();

pub fn auctioneer(self, auctioneer: Address) -> Self

Set the auctioneer for the proof request.

Details

Only the specified auctioneer will be able to manage the auction for this request.

Only relevant if the strategy is set to FulfillmentStrategy::Auction.

Example

use alloy_primitives::Address;
use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::str::FromStr;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let auctioneer = Address::from_str("0x0000000000000000000000000000000000000000").unwrap();
let builder = client.prove(&pk, &stdin).auctioneer(auctioneer).run();

pub fn executor(self, executor: Address) -> Self

Set the executor for the proof request.

Details

Only the specified executor will be able to fulfill this request. This is useful for whitelisting specific provers for private or prioritized jobs.

Example

use alloy_primitives::Address;
use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::str::FromStr;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let executor = Address::from_str("0x0000000000000000000000000000000000000000").unwrap();
let builder = client.prove(&pk, &stdin).executor(executor).run();

pub fn verifier(self, verifier: Address) -> Self

Set the verifier for the proof request.

Details

Only the specified verifier will be able to verify the proof. Only relevant if the mode is not SP1ProofMode::Compressed, as this mode will be verified within the VApp.

Example

use alloy_primitives::Address;
use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::str::FromStr;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let verifier = Address::from_str("0x0000000000000000000000000000000000000000").unwrap();
let builder = client.prove(&pk, &stdin).verifier(verifier).run();

pub fn treasury(self, treasury: Address) -> Self

Set the treasury for the proof request.

Details

The treasury is the address that will receive the protocol fee portion of the proof request reward when it is fulfilled.

Example

use alloy_primitives::Address;
use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::str::FromStr;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let treasury = Address::from_str("0x0000000000000000000000000000000000000000").unwrap();
let builder = client.prove(&pk, &stdin).treasury(treasury).run();

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

Sets the max price per PGU for the proof request.

Details

The max price per PGU (prover gas unit) lets you specify the maximum amount of PROVE you are willing to pay per PGU, protecting you from unexpected price escalation. If a value is not specified, a default value will be used.

Only relevant if the strategy is set to FulfillmentStrategy::Auction.

Example

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

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let proof = client
    .prove(&pk, &stdin)
    .max_price_per_pgu(1_000_000_000_000_000_000u64) // Set 1 PROVE (18 decimals).
    .run()
    .unwrap();

pub fn auction_timeout(self, auction_timeout: Duration) -> Self

Sets the auction timeout for the proof request.

Details

The auction timeout determines how long to wait for a prover to bid on the proof request. If no provers bid on the request within this timeout, the proof request will be canceled. If a value is not specified, the default is 30 seconds.

Only relevant if the strategy is set to FulfillmentStrategy::Auction.

Example

use sp1_sdk::{Prover, ProverClient, SP1Stdin};
use std::time::Duration;

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let proof = client
    .prove(&pk, &stdin)
    .auction_timeout(Duration::from_secs(60)) // Wait 60 seconds for a prover to pick up the request.
    .run()
    .unwrap();

pub fn request(self) -> Result<B256>

Request a proof from the prover network.

Details

This method will request a proof from the prover network. If the prover fails to request a proof, the method will return an error. It will not wait for the proof to be generated.

Example

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

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

let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);
let request_id = client.prove(&pk, &stdin).request().unwrap();

pub async fn request_async(self) -> Result<B256>

Request a proof from the prover network asynchronously.

Details

This method will request a proof from the prover network asynchronously. If the prover fails to request a proof, the method will return an error. It will not wait for the proof to be generated.

Example

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

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

    let client = ProverClient::builder().network().build();
    let (pk, vk) = client.setup(elf);
    let request_id = client.prove(&pk, &stdin).request_async().await.unwrap();
})

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::{Prover, ProverClient, SP1Stdin};

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

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

pub async fn run_async(self) -> Result<SP1ProofWithPublicValues>

Run the prover with the built arguments asynchronously.

Details

This method will run the prover with the built arguments asynchronously.

Example

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

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

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

Trait Implementations

impl<'a> IntoFuture for NetworkProveBuilder<'a>

type Output = Result<SP1ProofWithPublicValues, Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <NetworkProveBuilder<'a> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.