Struct Client 

#[non_exhaustive]
pub struct Client<P = DynProvider, U = StandardUploader, D = StandardDownloader, R = StandardRequestBuilder, Si = PrivateKeySigner> {
    pub boundless_market: BoundlessMarketService<P>,
    pub set_verifier: SetVerifierService<P>,
    pub uploader: Option<U>,
    pub downloader: D,
    pub offchain_client: Option<OrderStreamClient>,
    pub signer: Option<Si>,
    pub request_builder: Option<R>,
    pub deployment: Deployment,
    pub funding_mode: FundingMode,
}

Available on non-target_os=zkvm only.

Client for interacting with the boundless market.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

boundless_market: BoundlessMarketService<P>

Boundless market service.

set_verifier: SetVerifierService<P>

Set verifier service.

uploader: Option<U>

StandardUploader to upload programs and inputs.

If not provided, this client will not be able to upload programs or inputs.

downloader: D

Downloader for fetching data from storage.

offchain_client: Option<OrderStreamClient>

OrderStreamClient to submit requests off-chain.

If not provided, requests not only be sent onchain via a transaction.

signer: Option<Si>

Alloy Signer for signing requests.

If not provided, requests must be pre-signed handing them to this client.

request_builder: Option<R>

RequestBuilder to construct ProofRequest.

If not provided, requests must be fully constructed before handing them to this client.

deployment: Deployment

Deployment of Boundless that this client is connected to.

funding_mode: FundingMode

Funding mode for onchain requests.

Defaults to FundingMode::Always. FundingMode::Never can be used to never send value with the request. FundingMode::AvailableBalance can be used to only send value if the current onchain balance is insufficient. FundingMode::BelowThreshold can be used to send value only if the balance is below a configurable threshold. FundingMode::MinMaxBalance can be used to maintain a minimum balance by funding requests accordingly.

Implementations

impl Client<NotProvided, NotProvided, NotProvided, NotProvided, NotProvided>

pub fn builder() -> ClientBuilder<NotProvided, NotProvided, NotProvided>

Create a ClientBuilder to construct a Client.

impl<P, D> Client<P, NotProvided, D, NotProvided, NotProvided>

where P: Provider<Ethereum> + 'static + Clone, D: StorageDownloader,

pub fn new( boundless_market: BoundlessMarketService<P>, set_verifier: SetVerifierService<P>, downloader: D, ) -> Self

Create a new client

impl<P, St, D, R, Si> Client<P, St, D, R, Si>

where P: Provider<Ethereum> + 'static + Clone,

pub fn provider(&self) -> P

Get the provider

pub fn caller(&self) -> Address

Get the caller address

pub fn with_boundless_market( self, boundless_market: BoundlessMarketService<P>, ) -> Self

Set the Boundless market service

pub fn with_set_verifier(self, set_verifier: SetVerifierService<P>) -> Self

Set the set verifier service

pub fn with_offchain_client(self, offchain_client: OrderStreamClient) -> Self

Set the offchain client

pub fn with_timeout(self, tx_timeout: Duration) -> Self

Set the transaction timeout

pub fn with_funding_mode(self, funding_mode: FundingMode) -> Self

Set the funding mode for onchain requests.

pub fn with_signer<Zi>(self, signer: Zi) -> Client<P, St, D, R, Zi>

Set the signer that will be used for signing ProofRequest.

use alloy::signers::local::PrivateKeySigner;

client.with_signer(PrivateKeySigner::from_str(
    "0x1cee2499e12204c2ed600d780a22a67b3c5fff3310d984cca1f24983d565265c")
    .unwrap());

pub async fn upload_program(&self, program: &[u8]) -> Result<Url, ClientError>

where St: StorageUploader,

Upload a program binary to the storage uploader.

pub async fn upload_input(&self, input: &[u8]) -> Result<Url, ClientError>

where St: StorageUploader,

Upload input to the storage uploader.

pub async fn download(&self, url: &str) -> Result<Vec<u8>, ClientError>

where D: StorageDownloader,

Downloads the content at the given URL using the configured downloader.

pub fn new_request<Params>(&self) -> Params

where R: RequestBuilder<Params>, Params: Default,

Initial parameters that will be used to build a ProofRequest using the RequestBuilder.

pub async fn build_request<Params>( &self, params: impl Into<Params>, ) -> Result<ProofRequest, ClientError>

where R: RequestBuilder<Params>, R::Error: Into<Error>,

Build a proof request from the given parameters.

Requires a RequestBuilder to be provided. After building, pricing validation is run to check if the request will likely be accepted by provers.

If a signer is available on the client, the request will be signed for full validation. If no signer is available, pricing validation still runs but without signing.

Pricing checks can be skipped by setting the BOUNDLESS_IGNORE_PREFLIGHT environment variable.

impl<P, U, D, R, Si> Client<P, U, D, R, Si>

where P: Provider<Ethereum> + 'static + Clone,

pub async fn submit_onchain<Params>( &self, params: impl Into<Params>, ) -> Result<(U256, u64), ClientError>

where Si: Signer, R: RequestBuilder<Params>, R::Error: Into<Error>,

Build and submit a proof request by sending an onchain transaction.

Requires a Signer to be provided to sign the request, and a RequestBuilder to be provided to build the request from the given parameters.

pub async fn submit_request_onchain( &self, request: &ProofRequest, ) -> Result<(U256, u64), ClientError>

where Si: Signer,

Submit a proof request in an onchain transaction.

Requires a signer to be set to sign the request.

pub async fn submit_request_onchain_with_signer( &self, request: &ProofRequest, signer: &impl Signer, ) -> Result<(U256, u64), ClientError>

Submit a proof request in a transaction.

Accepts a signer to sign the request. Note that the transaction will be signed by the alloy Provider on this Client.

pub async fn submit_request_onchain_with_signature( &self, request: &ProofRequest, signature: impl Into<Bytes>, ) -> Result<(U256, u64), ClientError>

Submit a pre-signed proof in an onchain transaction.

Accepts a signature bytes to be used as the request signature.

pub async fn submit<Params>( &self, params: impl Into<Params>, ) -> Result<(U256, u64), ClientError>

where Si: Signer, R: RequestBuilder<Params>, R::Error: Into<Error>,

Build and submit a proof request.

Automatically uses offchain submission via the order stream service if available, otherwise falls back to onchain submission.

Requires a Signer to be provided to sign the request, and a RequestBuilder to be provided to build the request from the given parameters.

pub async fn submit_request( &self, request: &ProofRequest, ) -> Result<(U256, u64), ClientError>

where Si: Signer,

Submit a proof request (already built).

Automatically uses offchain submission via the order stream service if available, otherwise falls back to onchain submission.

Requires a signer to be set on the Client to sign the request.

pub async fn submit_request_with_signer( &self, request: &ProofRequest, signer: &impl Signer, ) -> Result<(U256, u64), ClientError>

where Si: Signer,

Submit a proof request with a provided signer.

Automatically uses offchain submission via the order stream service if available, otherwise falls back to onchain submission.

Accepts a signer parameter to sign the request.

pub async fn submit_offchain<Params>( &self, params: impl Into<Params>, ) -> Result<(U256, u64), ClientError>

where Si: Signer, R: RequestBuilder<Params>, R::Error: Into<Error>,

Build and submit a proof request offchain via the order stream service.

Requires a Signer to be provided to sign the request, and a RequestBuilder to be provided to build the request from the given parameters.

pub async fn submit_request_offchain( &self, request: &ProofRequest, ) -> Result<(U256, u64), ClientError>

where Si: Signer,

Submit a proof request offchain via the order stream service.

Requires a signer to be set to sign the request.

pub async fn submit_request_offchain_with_signer( &self, request: &ProofRequest, signer: &impl Signer, ) -> Result<(U256, u64), ClientError>

Submit a proof request offchain via the order stream service.

Accepts a signer to sign the request.

pub async fn wait_for_request_fulfillment( &self, request_id: U256, check_interval: Duration, expires_at: u64, ) -> Result<Fulfillment, ClientError>

Wait for a request to be fulfilled.

The check interval is the time between each check for fulfillment. The timeout is the maximum time to wait for the request to be fulfilled.

pub async fn fetch_set_inclusion_receipt( &self, request_id: U256, image_id: B256, search_to_block: Option<u64>, search_from_block: Option<u64>, ) -> Result<(Bytes, SetInclusionReceipt<ReceiptClaim>), ClientError>

Get the SetInclusionReceipt for a request.

This method fetches the fulfillment data for a request and constructs the set inclusion receipt.

Parameters

• request_id - The unique identifier of the proof request
• image_id - The image ID for the receipt claim
• search_to_block - Optional lower bound for the block search range. The search will go backwards down to this block number. Combined with search_from_block to define a specific range.
• search_from_block - Optional upper bound for the block search range. The search starts backwards from this block. Defaults to the latest block if not specified. Set this to a block number near when the request was fulfilled to reduce RPC calls and cost when querying old fulfillments.

Default Search Behavior

Without explicit block bounds, the onchain search covers blocks according to EventQueryConfig.block_range and EventQueryConfig.max_iterations. Fulfillment events older than this default range will not be found unless you provide explicit search_to_block and search_from_block parameters.

Examples

use anyhow::Result;
use alloy::primitives::{B256, Bytes, U256};
use boundless_market::client::ClientBuilder;
use risc0_aggregation::SetInclusionReceipt;
use risc0_zkvm::ReceiptClaim;

async fn fetch_set_inclusion_receipt(request_id: U256, image_id: B256) -> Result<(Bytes, SetInclusionReceipt<ReceiptClaim>)> {
    let client = ClientBuilder::new().build().await?;

    // For recent requests
    let (journal, receipt) = client.fetch_set_inclusion_receipt(
        request_id,
        image_id,
        None,
        None,
    ).await?;

    // For old requests with explicit block range
    let (journal, receipt) = client.fetch_set_inclusion_receipt(
        request_id,
        image_id,
        Some(1000000),  // search_to_block
        Some(1500000),  // search_from_block
    ).await?;

    Ok((journal, receipt))
}

pub async fn fetch_proof_request( &self, request_id: U256, tx_hash: Option<B256>, request_digest: Option<B256>, search_to_block: Option<u64>, search_from_block: Option<u64>, ) -> Result<(ProofRequest, Bytes), ClientError>

Fetch a proof request and its signature, querying first offchain, and then onchain.

This method does not verify the signature, and the order cannot be guarenteed to be authorized by this call alone.

The request is first looked up offchain using the order stream service, then onchain using event queries. The offchain query is sent first, since it is quick to check. Querying onchain uses event logs, and will take more time to find requests that are further in the past.

Parameters

• request_id - The unique identifier of the proof request
• tx_hash - Optional transaction hash containing the request. Providing this will speed up onchain queries by fetching the transaction directly instead of searching through events.
• request_digest - Optional digest to differentiate between multiple requests with the same ID. If None, the first found request matching the ID will be returned.
• search_to_block - Optional lower bound for the block search range. The search will go backwards down to this block number. Combined with search_from_block to define a specific range.
• search_from_block - Optional upper bound for the block search range. The search starts backwards from this block. Defaults to the latest block if not specified. Set this to a block number near when the request was submitted to reduce RPC calls and cost when querying old requests.

Default Search Behavior

Without explicit block bounds, the onchain search covers blocks according to EventQueryConfig.block_range and EventQueryConfig.max_iterations. Fulfillment events older than this default range will not be found unless you provide explicit search_to_block and search_from_block parameters.

Providing both bounds overrides the default iteration limit to ensure the full specified range is searched.

Examples

let client = ClientBuilder::new().build().await?;

// Query a recent request (no block bounds needed)
let (request, sig) = client.fetch_proof_request(
    U256::from(123),
    None,
    None,
    None,
    None,
).await?;

// Query an old request with explicit block range (e.g., blocks 1000000 to 1500000)
let (request, sig) = client.fetch_proof_request(
    U256::from(456),
    None,
    None,
    Some(1000000),  // search_to_block (lower bound)
    Some(1500000),  // search_from_block (upper bound)
).await?;

Trait Implementations

impl<P: Clone, U: Clone, D: Clone, R: Clone, Si: Clone> Clone for Client<P, U, D, R, Si>

fn clone(&self) -> Client<P, U, D, R, Si>

Returns a duplicate of the value.

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

Performs copy-assignment from source.