Struct ApiClient

pub struct ApiClient { /* private fields */ }

Available on (crate features client or prove) and non-target_os="zkvm" and crate feature client only.

A client implementation for interacting with a zkVM server.

Implementations

impl Client

pub fn new() -> Result<Self>

Construct a Client that connects to r0vm in a child process.

pub fn new_sub_process<P: AsRef<Path>>(server_path: P) -> Result<Self>

Construct a Client that connects to a sub-process which implements the server by calling the specified server_path.

pub fn new_sub_process_compat<P: AsRef<Path>>(server_path: P) -> Result<Self>

Construct a Client that connects to a sub-process which implements the server by calling the specified server_path.

Additionally allows for wider version mismatches, only rejecting major differences

pub fn from_env() -> Result<Self>

Construct a Client based on environment variables.

pub fn with_connector(connector: Box<dyn Connector>) -> Self

Construct a Client using the specified Connector to establish a connection with the server.

pub fn prove( &self, env: &ExecutorEnv<'_>, opts: &ProverOpts, binary: Asset, ) -> Result<ProveInfo>

Prove the specified ELF binary.

pub fn execute<F>( &self, env: &ExecutorEnv<'_>, binary: Asset, segments_out: AssetRequest, segment_callback: F, ) -> Result<SessionInfo>

where F: FnMut(SegmentInfo, Asset) -> Result<()>,

Execute the specified ELF binary.

pub fn prove_segment( &self, opts: &ProverOpts, segment: Asset, receipt_out: AssetRequest, ) -> Result<SegmentReceipt>

Prove the specified segment.

pub fn prove_zkr<Claim>( &self, proof_request: ProveZkrRequest, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<Claim>>

where Claim: Digestible + Debug + Clone + Serialize, MaybePruned<Claim>: TryFrom<MaybePruned, Error = Error>,

Available on crate feature unstable only.

Prove the specified ZKR proof request.

Availability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn prove_keccak<Claim>( &self, proof_request: ProveKeccakRequest, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<Claim>>

where Claim: Digestible + Debug + Clone + Serialize, MaybePruned<Claim>: TryFrom<MaybePruned, Error = Error>,

Available on crate feature unstable only.

Prove the specified keccak proof request.

Availability

This API is marked as unstable and is only available when the unstable crate feature is enabled. This comes with no stability guarantees, and could be changed or removed at any time.

pub fn lift( &self, opts: &ProverOpts, receipt: Asset, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<ReceiptClaim>>

Run the lift program to transform a SegmentReceipt into a SuccinctReceipt.

The lift program verifies the rv32im circuit STARK proof inside the recursion circuit, resulting in a recursion circuit STARK proof. This recursion proof has a single constant-time verification procedure, with respect to the original segment length, and is then used as the input to all other recursion programs (e.g. join, resolve, and identity_p254).

pub fn join( &self, opts: &ProverOpts, left_receipt: Asset, right_receipt: Asset, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<ReceiptClaim>>

Run the join program to compress two SuccinctReceipts in the same session into one.

By repeated application of the join program, any number of receipts for execution spans within the same session can be compressed into a single receipt for the entire session.

pub fn resolve( &self, opts: &ProverOpts, conditional_receipt: Asset, assumption_receipt: Asset, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<ReceiptClaim>>

Run the resolve program to remove an assumption from a conditional SuccinctReceipt upon verifying a SuccinctReceipt proving the validity of the assumption.

By applying the resolve program, a conditional receipt (i.e. a receipt for an execution using the env::verify API to logically verify a receipt) can be made into an unconditional receipt.

pub fn identity_p254( &self, opts: &ProverOpts, receipt: Asset, receipt_out: AssetRequest, ) -> Result<SuccinctReceipt<ReceiptClaim>>

Prove the verification of a recursion receipt using the Poseidon254 hash function for FRI.

The identity_p254 program is used as the last step in the prover pipeline before running the Groth16 prover. In Groth16 over BN254, it is much more efficient to verify a STARK that was produced with Poseidon over the BN254 base field compared to using Poseidon over BabyBear.

pub fn compress( &self, opts: &ProverOpts, receipt: Asset, receipt_out: AssetRequest, ) -> Result<Receipt>

Compress a Receipt, proving the same computation using a smaller representation.

Proving will, by default, produce a CompositeReceipt, which may contain an arbitrary number of receipts assembled into segments and assumptions. Together, these receipts collectively prove a top-level ReceiptClaim. This function can be used to compress all of the constituent receipts of a CompositeReceipt into a single SuccinctReceipt or Groth16Receipt that proves the same top-level claim.

Compression from Groth16Receipt to SuccinctReceipt is accomplished by iterative application of the recursion programs including lift, join, and resolve.

Compression from SuccinctReceipt to Groth16Receipt is accomplished by running a Groth16 recursive verifier, refered to as the “STARK-to-SNARK” operation.

NOTE: Compression to Groth16Receipt is currently only supported on x86 hosts, and requires Docker to be installed. See issue #1749 for more information.

If the receipt is already at least as compressed as the requested compression level (e.g. it is already succinct or Groth16 and a succinct receipt is required) this function is a no-op. As a result, it is idempotent.

pub fn verify(&self, receipt: Asset, image_id: impl Into<Digest>) -> Result<()>

Verify a Receipt.

Trait Implementations

impl Default for Client

fn default() -> Self

Returns the “default value” for a type.