BM-1003: added the with_input_url method to RequestParams in the request builder API (#706)

added `with_input_url` to match the schema of `with_program_url`,

now you can use:
`client.new_request().with_program_url(program_url)?.with_input_url(input_url)?`

Author: sashaaldrick

crates/boundless-market/src/request_builder/mod.rs

@@ -422,6 +422,22 @@ impl RequestParams {
         Self { request_input: Some(value.into()), ..self }
     }
 
+    /// 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.
+    ///
+    /// ```rust
+    /// # use boundless_market::request_builder::RequestParams;
+    /// # || -> anyhow::Result<()> {
+    /// RequestParams::new()
+    ///     .with_input_url("https://fileserver.example/input.bin")?;
+    /// # Ok(())
+    /// # }().unwrap();
+    /// ```
+    pub fn with_input_url<T: TryInto<Url>>(self, value: T) -> Result<Self, T::Error> {
+        Ok(Self { request_input: Some(RequestInput::url(value.try_into()?)), ..self })
+    }
+
     /// Gets the cycle count, returning an error if not set.
     ///
     /// The cycle count is used to estimate proving costs.
@@ -934,6 +950,34 @@ mod tests {
         RequestParams::new().with_program_url(url).inspect_err(|e| match *e {}).unwrap();
     }
 
+    #[test]
+    fn request_params_with_input_url_infallible() {
+        // When passing a parsed URL, with_input_url should be infallible.
+        // NOTE: The `match *e {}` incantation is a compile-time assert that this error cannot
+        // occur.
+        let url = Url::parse("https://fileserver.example/input.bin").unwrap();
+        RequestParams::new().with_input_url(url).inspect_err(|e| match *e {}).unwrap();
+    }
+
+    #[test]
+    fn test_with_input_url() {
+        // Test with string URL
+        let params =
+            RequestParams::new().with_input_url("https://fileserver.example/input.bin").unwrap();
+
+        let input = params.request_input.unwrap();
+        assert_eq!(input.inputType, RequestInputType::Url);
+        assert_eq!(input.data.as_ref(), "https://fileserver.example/input.bin".as_bytes());
+
+        // Test with parsed URL
+        let url = Url::parse("https://fileserver.example/input2.bin").unwrap();
+        let params = RequestParams::new().with_input_url(url).unwrap();
+
+        let input = params.request_input.unwrap();
+        assert_eq!(input.inputType, RequestInputType::Url);
+        assert_eq!(input.data.as_ref(), "https://fileserver.example/input2.bin".as_bytes());
+    }
+
     #[allow(dead_code)]
     trait AssertSend: Send {}
 

examples/counter/apps/src/main.rs

@@ -44,6 +44,9 @@ struct Args {
     /// Address of the Counter contract.
     #[clap(short, long, env)]
     counter_address: Address,
+    /// URL where provers can download the program to be proven.
+    #[clap(long, env)]
+    program_url: Option<Url>,
     /// Configuration for the StorageProvider to use for uploading programs and inputs.
     #[clap(flatten, next_help_heading = "Storage Provider")]
     storage_config: StorageProviderConfig,
@@ -81,10 +84,19 @@ async fn run(args: Args) -> Result<()> {
         .await
         .context("failed to build boundless client")?;
 
+    // Use the default ECHO program with timestamp input
     // We use a timestamp as input to the ECHO guest code as the Counter contract
     // accepts only unique proofs. Using the same input twice would result in the same proof.
     let echo_message = format!("{:?}", SystemTime::now());
-    let request = client.new_request().with_program(ECHO_ELF).with_stdin(echo_message.as_bytes());
+
+    // Build the request based on whether program URL is provided
+    let request = if let Some(program_url) = args.program_url {
+        // Use the provided URL
+        client.new_request().with_program_url(program_url)?.with_stdin(echo_message.as_bytes())
+    } else {
+        client.new_request().with_program(ECHO_ELF).with_stdin(echo_message.as_bytes())
+    };
+
     let (request_id, expires_at) = client.submit_onchain(request).await?;
 
     // Wait for the request to be fulfilled. The market will return the journal and seal.
@@ -194,6 +206,7 @@ mod tests {
             counter_address,
             rpc_url: anvil.endpoint_url(),
             private_key: ctx.customer_signer,
+            program_url: None,
             storage_config: StorageProviderConfig::builder()
                 .storage_provider(StorageProviderType::Mock)
                 .build()