Struct RequestParams 

#[non_exhaustive]
pub struct RequestParams {
    pub program: Option<Cow<'static, [u8]>>,
    pub env: Option<GuestEnv>,
    pub program_url: Option<Url>,
    pub request_input: Option<RequestInput>,
    pub cycles: Option<u64>,
    pub image_id: Option<Digest>,
    pub journal: Option<Journal>,
    pub request_id: Option<RequestId>,
    pub offer: OfferParams,
    pub requirements: RequirementParams,
}

Available on non-target_os=zkvm only.

Parameters for building a proof request.

This struct holds all the necessary information for constructing a ProofRequest. It provides a builder pattern for incrementally setting fields and methods for validating and accessing the parameters.

Most fields are optional and can be populated during the request building process by various layers. The structure serves as the central data container that passes through the request builder pipeline.

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.

program: Option<Cow<'static, [u8]>>

RISC-V guest program that will be run in the zkVM.

env: Option<GuestEnv>

Guest execution environment, providing the input for the guest. See GuestEnv.

program_url: Option<Url>

Uploaded program URL, from which provers will fetch the program.

request_input: Option<RequestInput>

Prepared input for the ProofRequest, containing either a URL or inline input. See RequestInput.

cycles: Option<u64>

Count of the RISC Zero execution cycles. Used to estimate proving cost.

image_id: Option<Digest>

Image ID identifying the program being executed.

journal: Option<Journal>

Contents of the Journal that results from the execution.

request_id: Option<RequestId>

RequestId to use for the proof request.

offer: OfferParams

OfferParams for constructing the Offer to send along with the request.

requirements: RequirementParams

RequirementParams for constructing the Requirements for the resulting proof.

Implementations

impl RequestParams

pub fn new() -> Self

Creates a new empty instance of RequestParams.

This is equivalent to calling Default::default() and is provided as a convenience method for better readability when building requests.

pub fn require_program(&self) -> Result<&[u8], MissingFieldError>

Gets the program bytes, returning an error if not set.

This method is used by layers in the request building pipeline to access the program when it’s required for processing.

pub fn with_program(self, value: impl Into<Cow<'static, [u8]>>) -> Self

Sets the program to be executed in the zkVM.

pub fn require_env(&self) -> Result<&GuestEnv, MissingFieldError>

Gets the guest environment, returning an error if not set.

The guest environment contains the input data for the program.

pub fn with_env(self, value: impl Into<GuestEnv>) -> Self

Sets the GuestEnv, providing the guest with input.

Can be constructed with GuestEnvBuilder.

use boundless_market::GuestEnv;

RequestParams::new()
    .with_program(ECHO_ELF)
    .with_env(GuestEnv::builder()
        .write_frame(b"hello!")
        .write_frame(b"goodbye."));

See also Self::with_env and GuestEnvBuilder

pub fn with_stdin(self, value: impl Into<Vec<u8>>) -> Self

Sets the GuestEnv to be contain the given bytes as stdin.

Note that the bytes are passed directly to the guest without encoding. If your guest expects the input to be encoded in any way (e.g. bincode), the caller must encode the data before passing it.

If the GuestEnv is already set, this replaces it.

RequestParams::new()
    .with_program(ECHO_ELF)
    .with_stdin(b"hello!");

See also Self::with_env and GuestEnvBuilder

pub fn require_program_url(&self) -> Result<&Url, MissingFieldError>

Gets the program URL, returning an error if not set.

The program URL is where provers will download the program to execute.

pub fn with_program_url<T: TryInto<Url>>( self, value: T, ) -> Result<Self, T::Error>

Set the program URL, where provers can download the program to be proven.

RequestParams::new()
    .with_program_url("https://fileserver.example/guest.bin")?;

pub fn require_request_input(&self) -> Result<&RequestInput, MissingFieldError>

Gets the request input, returning an error if not set.

The request input contains the input data for the guest program, either inline or as a URL.

pub fn with_request_input(self, value: impl Into<RequestInput>) -> Self

Sets the encoded input data for the request. This data will be decoded by the prover into a GuestEnv that will be used to run the guest.

If not provided, the this will be constructed from the data given via RequestParams::with_env or RequestParams::with_stdin. If the input is set with both this method and one of those two, the input specified here takes precedence.

pub fn with_input_url<T: TryInto<Url>>(self, value: T) -> Result<Self, T::Error>

Sets the input as a URL from which provers can download the input data.

This is a convenience method that creates a RequestInput with URL type.

RequestParams::new()
    .with_input_url("https://fileserver.example/input.bin")?;

pub fn require_cycles(&self) -> Result<u64, MissingFieldError>

Gets the cycle count, returning an error if not set.

The cycle count is used to estimate proving costs.

pub fn with_cycles(self, value: u64) -> Self

Sets the cycle count for the proof request.

This is used to estimate proving costs and determine appropriate pricing.

pub fn require_journal(&self) -> Result<&Journal, MissingFieldError>

Gets the journal, returning an error if not set.

The journal contains the output from the guest program execution.

pub fn with_journal(self, value: impl Into<Journal>) -> Self

Sets the journal for the request.

The journal is the output from the guest program execution and is used to configure verification requirements.

pub fn require_image_id(&self) -> Result<Digest, MissingFieldError>

Gets the image ID, returning an error if not set.

The image ID uniquely identifies the program being executed.

pub fn with_image_id(self, value: impl Into<Digest>) -> Self

Sets the image ID for the request.

The image ID is the hash of the program binary and uniquely identifies the program being executed.

pub fn require_request_id(&self) -> Result<&RequestId, MissingFieldError>

Gets the request ID, returning an error if not set.

The request ID contains the requestor’s address and a unique index, and is used to track the request throughout its lifecycle.

pub fn with_request_id(self, value: impl Into<RequestId>) -> Self

Sets the request ID for the proof request.

The request ID contains the requestor’s address and a unique index, and is used to track the request throughout its lifecycle.

pub fn with_offer(self, value: impl Into<OfferParams>) -> Self

Configure the Offer on the ProofRequest by either providing a complete offer, or a partial offer via OfferParams.

use alloy::primitives::utils::parse_units;

RequestParams::new()
    .with_offer(OfferParams::builder()
        .max_price(parse_units("0.01", "ether").unwrap())
        .ramp_up_period(30)
        .lock_timeout(120)
        .timeout(240));

pub fn with_requirements(self, value: impl Into<RequirementParams>) -> Self

Configure the Requirements on the ProofRequest by either providing the complete requirements, or partial requirements via RequirementParams.

use alloy::primitives::address;

RequestParams::new()
    .with_requirements(RequirementParams::builder()
        .callback_address(address!("0x00000000000000000000000000000000deadbeef")));

pub fn with_groth16_proof(self) -> Self

Request a stand-alone Groth16 proof for this request.

This is a convinience method to set the selector on the requirements. Note that calling RequestParams::with_requirements after this function will overwrite the change.

pub fn with_blake3_groth16_proof(self) -> Self

Request a stand-alone Blake3 Groth16 proof for this request.

This is a convinience method to set the selector on the requirements. Note that calling RequestParams::with_requirements after this function will overwrite the change.

Trait Implementations

impl Adapt<Finalizer> for RequestParams

type Output = ProofRequest

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &Finalizer, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl<P> Adapt<OfferLayer<P>> for RequestParams

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

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &OfferLayer<P>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl<D> Adapt<PreflightLayer<D>> for RequestParams

where D: StorageDownloader,

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &PreflightLayer<D>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl Adapt<PreflightLayer<NotProvided>> for RequestParams

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, _: &PreflightLayer<NotProvided>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl<P> Adapt<RequestIdLayer<P>> for RequestParams

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

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &RequestIdLayer<P>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl Adapt<RequirementsLayer> for RequestParams

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &RequirementsLayer, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl Adapt<StorageLayer<NotProvided>> for RequestParams

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &StorageLayer<NotProvided>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl<S> Adapt<StorageLayer<S>> for RequestParams

where S: StorageUploader,

type Output = RequestParams

The output type after processing by the layer.

type Error = Error

Error type that may be returned during processing.

async fn process_with( self, layer: &StorageLayer<S>, ) -> Result<Self::Output, Self::Error>

Processes this value with the provided layer.

impl Clone for RequestParams

fn clone(&self) -> RequestParams

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestParams

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

Debug implementation that does not print the contents of the program.

impl Default for RequestParams

fn default() -> RequestParams

Returns the “default value” for a type.

impl<Program, Env> From<(Program, Env)> for RequestParams

where Program: Into<Cow<'static, [u8]>>, Env: Into<GuestEnv>,

fn from(value: (Program, Env)) -> Self

Converts to this type from the input type.

impl<P, S, D> Layer<RequestParams> for StandardRequestBuilder<P, S, D>

where P: Provider<Ethereum> + 'static + Clone, D: StorageDownloader, RequestParams: Adapt<StorageLayer<S>, Output = RequestParams, Error = Error> + Adapt<PreflightLayer<D>, Output = RequestParams, Error = Error>,

type Output = ProofRequest

The output type produced by this layer.

type Error = Error

Error type that may be returned by this layer.

async fn process( &self, input: RequestParams, ) -> Result<ProofRequest, Self::Error>

Processes the input and returns the transformed output.