Struct NetworkProver

pub struct NetworkProver { /* private fields */ }

An implementation of crate::ProverClient that can generate proofs on a remote RPC server.

Implementations

impl NetworkProver

pub fn new(signer: impl Into<NetworkSigner>, rpc_url: &str) -> Self

Creates a new NetworkProver with the given signer.

Details

• signer: The network signer to use for signing requests. Can be a NetworkSigner, private key string, or anything that implements Into<NetworkSigner>.
• rpc_url: The rpc url to use for the prover network.

Examples

Using a private key string:

use sp1_sdk::NetworkProver;

let prover = NetworkProver::new("0x...", "...");

Using a NetworkSigner:

use sp1_sdk::{NetworkProver, NetworkSigner};

let signer = NetworkSigner::local("0x...").unwrap();
let prover = NetworkProver::new(signer, "...");

pub fn with_tee_signers(self, tee_signers: Vec<Address>) -> Self

Sets the list of TEE signers, used for verifying TEE proofs.

pub async fn get_balance(&self) -> Result<U256>

Get the credit balance of your account on the prover network.

Example

use sp1_sdk::{ProverClient, SP1Stdin};

tokio_test::block_on(async {
    let client = ProverClient::builder().network().build();
    let balance = client.get_balance().await.unwrap();
})

pub fn execute<'a>( &'a self, elf: &'a [u8], stdin: &SP1Stdin, ) -> CpuExecuteBuilder<'a>

Creates a new CpuExecuteBuilder for simulating the execution of a program on the CPU.

Details

Note that this does not use the network in any capacity. The method is provided for convenience.

Example

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

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

let client = ProverClient::builder().cpu().build();
let (public_values, execution_report) = client.execute(elf, &stdin).run().unwrap();

pub fn prove<'a>( &'a self, pk: &'a SP1ProvingKey, stdin: &'a SP1Stdin, ) -> NetworkProveBuilder<'a>

A request to generate a proof for a given proving key and input.

Details

• pk: The proving key to use for the proof.
• stdin: The input to use for the 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 proof = client.prove(&pk, &stdin).run();

pub async fn register_program( &self, vk: &SP1VerifyingKey, elf: &[u8], ) -> Result<B256>

Registers a program if it is not already registered.

Details

• vk: The verifying key to use for the program.
• elf: The elf to use for the program.

Note that this method requires that the user honestly registers the program (i.e., the elf matches the vk).

Example

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

let elf = &[1, 2, 3];
let client = ProverClient::builder().network().build();
let (pk, vk) = client.setup(elf);

let vk_hash = client.register_program(&vk, elf);

pub async fn get_proof_status( &self, request_id: B256, ) -> Result<(GetProofRequestStatusResponse, Option<SP1ProofWithPublicValues>)>

Gets the status of a proof request. Re-exposes the status response from the client.

Details

• request_id: The request ID to get the status of.

Example

use sp1_sdk::{network::B256, ProverClient};

tokio_test::block_on(async {
    let request_id = B256::from_slice(&vec![1u8; 32]);
    let client = ProverClient::builder().network().build();
    let (status, maybe_proof) = client.get_proof_status(request_id).await.unwrap();
})

pub async fn get_proof_request( &self, request_id: B256, ) -> Result<Option<ProofRequest>>

Gets the proof request details, if available.

The ProofRequest type contains useful information about the request, like the cycle count, or the gas used.

Details

• request_id: The request ID to get the status of.

Example

use sp1_sdk::{network::B256, ProverClient};

tokio_test::block_on(async {
    let request_id = B256::from_slice(&vec![1u8; 32]);
    let client = ProverClient::builder().network().build();
    let request = client.get_proof_request(request_id).await.unwrap();
})

pub async fn process_proof_status( &self, request_id: B256, remaining_timeout: Option<Duration>, ) -> Result<(Option<SP1ProofWithPublicValues>, FulfillmentStatus)>

Gets the status of a proof request with handling for timeouts and unfulfillable requests.

Returns the proof if it is fulfilled and the fulfillment status. Handles statuses indicating that the proof is unfulfillable or unexecutable with errors.

Details

• request_id: The request ID to get the status of.
• remaining_timeout: The remaining timeout for the proof request.

Example

use sp1_sdk::{network::B256, ProverClient};

tokio_test::block_on(async {
    let request_id = B256::from_slice(&vec![1u8; 32]);
    let client = ProverClient::builder().network().build();
    let (maybe_proof, fulfillment_status) =
        client.process_proof_status(request_id, None).await.unwrap();
})

pub async fn wait_proof( &self, request_id: B256, timeout: Option<Duration>, auction_timeout: Option<Duration>, ) -> Result<SP1ProofWithPublicValues>

Waits for a proof to be generated and returns the proof. If a timeout is supplied, the function will return an error if the proof is not generated within the timeout. If auction_timeout is supplied, the function will return an error if the proof request remains in “requested” status for longer than the auction timeout.

Trait Implementations

impl Prover<CpuProverComponents> for NetworkProver

fn setup(&self, elf: &[u8]) -> (SP1ProvingKey, SP1VerifyingKey)

Generate the proving and verifying keys for the given program.

fn inner(&self) -> &SP1Prover

The inner SP1Prover struct used by the prover.

fn prove( &self, pk: &SP1ProvingKey, stdin: &SP1Stdin, mode: SP1ProofMode, ) -> Result<SP1ProofWithPublicValues>

Proves the given program on the given input in the given proof mode.

fn verify( &self, bundle: &SP1ProofWithPublicValues, vkey: &SP1VerifyingKey, ) -> Result<(), SP1VerificationError>

Verify that an SP1 proof is valid given its vkey and metadata. For Plonk proofs, verifies that the public inputs of the PlonkBn254 proof match the hash of the VK and the committed public values of the SP1ProofWithPublicValues.

fn version(&self) -> &str

The version of the current SP1 circuit.

fn execute( &self, elf: &[u8], stdin: &SP1Stdin, ) -> Result<(SP1PublicValues, ExecutionReport)>

Executes the program on the given input.