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 async fn new( signer: impl Into<NetworkSigner>, rpc_url: &str, network_mode: NetworkMode, ) -> Self

Creates a new NetworkProver with the given signer and network mode.

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.
• network_mode: The network mode determining which proving strategy to use.

Examples

Using a private key string:

use sp1_sdk::{network::NetworkMode, NetworkProver};

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

Using a NetworkSigner:

use sp1_sdk::{
    network::{signer::NetworkSigner, NetworkMode},
    NetworkProver,
};

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

pub async fn new_with_machine( signer: impl Into<NetworkSigner>, rpc_url: &str, network_mode: NetworkMode, machine: Machine<SP1Field, RiscvAir<SP1Field>>, ) -> Self

Same as new but with a custom machine

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

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

pub fn network_mode(&self) -> NetworkMode

Gets the network mode of this prover.

pub fn default_fulfillment_strategy(&self) -> FulfillmentStrategy

Gets the default fulfillment strategy for this prover’s network mode.

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().await;
    let balance = client.get_balance().await.unwrap();
})

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

tokio_test::block_on(async {
    let elf = Elf::Static(&[1, 2, 3]);
    let client = ProverClient::builder().network().build().await;
    let pk = client.setup(elf).await.unwrap();
    let vk_hash = client.register_program(&pk.verifying_key(), pk.elf()).await.unwrap();
});

pub async fn get_proof_request_params( &self, mode: SP1ProofMode, ) -> Result<GetProofRequestParamsResponse>

Gets the proof request parameters from the network.

Details

• mode: The proof mode to get the parameters for.

Example

use sp1_sdk::{ProverClient, SP1ProofMode};
tokio_test::block_on(async {
    let client = ProverClient::builder().network().build().await;
    let params = client.get_proof_request_params(SP1ProofMode::Compressed).await.unwrap();
})

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().await;
    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().await;
    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().await;
    let (maybe_proof, fulfillment_status) =
        client.process_proof_status(request_id, None).await.unwrap();
})

pub async fn cancel_request(&self, request_id: B256) -> Result<()>

Cancels a proof request by updating the deadline to the current time. Only available in Mainnet mode (auction-based proving).

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 Clone for NetworkProver

fn clone(&self) -> NetworkProver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> ProveRequest<'a, NetworkProver> for NetworkProveBuilder<'a>

fn base(&mut self) -> &mut BaseProveRequest<'a, NetworkProver>

Get the base request for the prover.

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

Set the proof mode to the given [SP1ProofKind].

fn compressed(self) -> Self

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

fn plonk(self) -> Self

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

fn groth16(self) -> Self

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

fn core(self) -> Self

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

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

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

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

Whether to enable deferred proof verification in the executor.

fn expected_exit_code(self, code: StatusCode) -> Self

Set the expected exit code of the program.

fn with_proof_nonce(self, nonce: [u32; 4]) -> Self

Set the proof nonce for this execution.

impl Prover for NetworkProver

type ProvingKey = SP1ProvingKey

The proving key used for this prover type.

type Error = Error

The possible errors that can occur when proving.

type ProveRequest<'a> = NetworkProveBuilder<'a>

The prove request builder.

fn inner(&self) -> &SP1NodeCore

The inner [LocalProver] struct used by the prover.

fn setup( &self, elf: Elf, ) -> impl SendFutureResult<Self::ProvingKey, Self::Error>

Setup the prover with the given ELF.

fn prove<'a>( &'a self, pk: &'a Self::ProvingKey, stdin: SP1Stdin, ) -> Self::ProveRequest<'a>

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

fn verify( &self, proof: &SP1ProofWithPublicValues, vkey: &SP1VerifyingKey, status_code: Option<StatusCode>, ) -> Result<(), SP1VerificationError>

Verify the given proof.

fn version(&self) -> &str

The version of the current SP1 circuit.

fn execute(&self, elf: Elf, stdin: SP1Stdin) -> ExecuteRequest<'_, Self>

Execute the program on the given input.