Struct Client 

pub struct Client { /* private fields */ }

SP1 Aggregating Proving Client

A cryptographically sound implementation of the Proving trait that uses SP1 to generate zero-knowledge proofs for state diff lists (SDLs).

This client optionally proves local laws and aggregates the resulting proof with the proof of the global laws.

The proving client can be configured to generate proofs on the CPU or a prover network, such as Succinct Network.

Usage Notes

• Proof generation is computationally intensive and may take significant time.
• Consider running the prover on dedicated hardware for production use.

Example

use delta_crypto::hash::HashDigest;
use delta_proving_clients::{Proving, sp1};
use delta_verifiable::types::{VerifiableWithDiffs, VerificationContext};

async fn generate_real_proof(
    sdl_hash: HashDigest,
    verifiables: Vec<VerifiableWithDiffs>,
    context: VerificationContext
) -> Result<(), Box<dyn std::error::Error>> {
    let client = sp1::Client::global_laws_cpu();

    // Generate a cryptographically sound proof (also expensive)
    let proof = client.prove(sdl_hash, &verifiables, &context, &[])?;
    println!("Generated proof for SDL {}", sdl_hash);

    Ok(())
}

Implementations

impl Client

pub fn global_laws_cpu() -> Client

Create a new CPU-based proving client for the global laws.

pub fn local_laws_cpu(elf: &[u8]) -> Client

Create a new CPU-based proving client for the global laws and local laws

Parameters

• elf - the raw bytes of the local laws ELF

pub fn with_local_laws_cpu(self, elf: &[u8]) -> Client

Set a new CPU-based proving client for local laws

Parameters

• elf - the raw bytes of the local laws ELF

pub fn global_laws_succinct(private_key: &str, rpc_url: &str) -> Client

Create a new succinct network-based proving client for the global laws.

Parameters

• private_key - The Secp256k1 private key of the account used for authentication with the Succinct Network. This key will be used to sign proof requests to ensure they are securely processed. Refer to the SP1 documentation for details on key setup.
• rpc_url - The RPC URL to connect to the network.

pub fn global_laws_succinct_with_strategy( private_key: &str, rpc_url: &str, strategy: FulfillmentStrategy, ) -> Client

Create a new succinct network-based proving client for the global laws with a specific fulfillment strategy.

Parameters

• private_key - see Self::global_laws_succinct
• rpc_url - see Self::global_laws_succinct
• strategy - the fulfillment strategy to use when dispatching proofs on the network

pub fn local_laws_succinct( elf: &[u8], private_key: &str, rpc_url: &str, ) -> Client

Create a new succinct network-based proving client for the global laws and local laws

Parameters

• elf - the raw bytes of the local laws ELF
• private_key - see Self::global_laws_succinct
• rpc_url - see Self::global_laws_succinct

pub fn local_laws_succinct_with_strategy( elf: &[u8], private_key: &str, rpc_url: &str, strategy: FulfillmentStrategy, ) -> Client

Create a new succinct network-based proving client for the global laws and local laws with a configurable fulfillment strategy for both provers.

pub fn with_local_laws_succinct( self, elf: &[u8], private_key: &str, rpc_url: &str, ) -> Client

Set a new succinct network-based proving client for local laws

Parameters

• elf - the raw bytes of the local laws ELF
• private_key - see Self::global_laws_succinct
• rpc_url - see Self::global_laws_succinct

pub fn with_local_laws_succinct_with_strategy( self, elf: &[u8], private_key: &str, rpc_url: &str, strategy: FulfillmentStrategy, ) -> Client

Set a new succinct network-based proving client for local laws with a configurable fulfillment strategy.

Parameters

• elf - the raw bytes of the local laws ELF program
• private_key - the Succinct network Secp256k1 private key used to sign requests
• rpc_url - the Succinct network RPC endpoint to submit proof jobs to
• strategy - how the network should fulfill the proof request

pub fn global_laws_cuda(backend_url: &str) -> Client

Create a new network CUDA-based proving client for the global laws.

Parameters

• backend_url: url to the sp1 CUDA backend. cf. the SP1 CUDA backend

pub fn local_laws_cuda(elf: &[u8], backend_url: &str) -> Client

Create a new CUDA-based proving client for the global laws and local laws

Parameters

• elf - the raw bytes of the local laws ELF
• backend_url - url to the sp1 CUDA backend

pub fn with_local_laws_cuda(self, elf: &[u8], backend_url: &str) -> Client

Set a new CUDA-based proving client for local laws

Parameters

• elf - the raw bytes of the local laws ELF
• backend_url - url to the sp1 CUDA backend

pub fn with_global_mode(self, mode: SP1ProofMode) -> Client

Change the proof mode of the global laws proving.

By default the mode is set to DEFAULT_PROOF_MODE for the global prover. Local laws are always proven in [SP1ProofMode::Compressed] mode for aggregation to work.

Trait Implementations

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Proving for Client

type Error = Error

Error type that can occur when proving

fn local_laws_vkey(&self) -> Option<HashDigest>

Return the verification key of the enforced local laws, if configured.

fn prove( &self, sdl_hash: HashDigest, verifiables: &[VerifiableWithDiffs], context: &VerificationContext, local_laws_input: &[u8], ) -> Result<SDLProof, <Client as Proving>::Error>

Generate a proof for the SDL specified by sdl_hash, using the verifiables and context.