SHARP smoke test

Cargo.toml

@@ -20,6 +20,7 @@ authors = ["Apoorv Sadana <@apoorvsadana>"]
 
 [workspace.dependencies]
 alloy = { git = "https://github.com/alloy-rs/alloy", rev = "7373f6db761d5a19888e3a0c527e8a3ca31e7a1e" }
+alloy-primitives = "0.7.4"
 async-trait = "0.1.77"
 axum = { version = "0.7.4" }
 axum-macros = "0.4.1"

crates/prover_services/sharp_service/Cargo.toml

@@ -5,6 +5,7 @@ edition.workspace = true
 
 [dependencies]
 alloy.workspace = true
+alloy-primitives.workspace = true
 async-trait.workspace = true
 uuid.workspace = true
 serde.workspace = true
@@ -18,3 +19,6 @@ utils.workspace = true
 thiserror.workspace = true
 hex.workspace = true
 url.workspace = true
+
+[dev-dependencies]
+tokio.workspace = true

crates/prover_services/sharp_service/src/client.rs

@@ -5,22 +5,24 @@ use uuid::Uuid;
 
 use crate::error::SharpError;
 
+/// SHARP endpoint for Sepolia testnet
 pub const DEFAULT_SHARP_URL: &str = "https://testnet.provingservice.io";
 
 /// SHARP API async wrapper
 pub struct SharpClient {
-    url: Url,
+    base_url: Url,
     client: reqwest::Client,
 }
 
 impl SharpClient {
     pub fn new(url: Url) -> Self {
-        Self { url, client: reqwest::Client::new() }
+        Self { base_url: url, client: reqwest::Client::new() }
     }
 
     pub async fn add_job(&self, encoded_pie: &str) -> Result<CairoJobResponse, SharpError> {
         let data = json!({ "action": "add_job", "request": { "cairo_pie": encoded_pie } });
-        let res = self.client.post(self.url.clone()).json(&data).send().await.map_err(SharpError::AddJobFailure)?;
+        let url = self.base_url.join("add_job").unwrap();
+        let res = self.client.post(url).json(&data).send().await.map_err(SharpError::AddJobFailure)?;
 
         match res.status() {
             reqwest::StatusCode::OK => res.json().await.map_err(SharpError::AddJobFailure),
@@ -30,8 +32,8 @@ impl SharpClient {
 
     pub async fn get_job_status(&self, job_key: &Uuid) -> Result<CairoStatusResponse, SharpError> {
         let data = json!({ "action": "get_status", "request": { "cairo_job_key": job_key } });
-        let res =
-            self.client.post(self.url.clone()).json(&data).send().await.map_err(SharpError::GetJobStatusFailure)?;
+        let url = self.base_url.join("get_status").unwrap();
+        let res = self.client.post(url).json(&data).send().await.map_err(SharpError::GetJobStatusFailure)?;
 
         match res.status() {
             reqwest::StatusCode::OK => res.json().await.map_err(SharpError::GetJobStatusFailure),

crates/prover_services/sharp_service/src/config.rs

@@ -2,6 +2,8 @@ use alloy::primitives::Address;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
+use crate::client::DEFAULT_SHARP_URL;
+
 /// SHARP proving service configuration
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct SharpConfig {
@@ -17,7 +19,7 @@ impl Default for SharpConfig {
     /// Default config for Sepolia testnet
     fn default() -> Self {
         Self {
-            service_url: "https://testnet.provingservice.io".parse().unwrap(),
+            service_url: DEFAULT_SHARP_URL.parse().unwrap(),
             rpc_node_url: "https://sepolia.drpc.org".parse().unwrap(),
             verifier_address: "0x07ec0D28e50322Eb0C159B9090ecF3aeA8346DFe".parse().unwrap(),
         }

crates/prover_services/sharp_service/src/error.rs

@@ -1,5 +1,5 @@
+use alloy_primitives::hex::FromHexError;
 use gps_fact_checker::error::FactCheckerError;
-use hex::FromHexError;
 use prover_service::ProverServiceError;
 use reqwest::StatusCode;
 

crates/prover_services/sharp_service/src/lib.rs

@@ -90,3 +90,45 @@ pub fn split_task_id(task_id: &TaskId) -> Result<(Uuid, B256), SharpError> {
     let fact = B256::from_str(fact_str).map_err(SharpError::FactParse)?;
     Ok((job_key, fact))
 }
+
+#[cfg(test)]
+mod tests {
+    use std::{path::PathBuf, time::Duration};
+
+    use cairo_vm::vm::runners::cairo_pie::CairoPie;
+    use prover_service::{ProverService, Task, TaskStatus};
+    use utils::settings::default::DefaultSettingsProvider;
+
+    use crate::SharpProverService;
+
+    /// DO NOT RUN THIS TEST IN CI PIPELINE
+    #[ignore]
+    #[tokio::test]
+    async fn sharp_smoke_test() {
+        let sharp_service = SharpProverService::with_settings(&DefaultSettingsProvider {});
+        let cairo_pie_path: PathBuf =
+            [env!("CARGO_MANIFEST_DIR"), "src", "artifacts", "fibonacci.zip"].iter().collect();
+        let cairo_pie = CairoPie::read_zip_file(&cairo_pie_path).unwrap();
+        // Submit task to the testnet prover
+        let task_id = sharp_service.submit_task(Task::CairoPie(cairo_pie)).await.unwrap();
+        println!("SHARP: task {} submitted", task_id);
+        for attempt in 0..10 {
+            tokio::time::sleep(Duration::from_millis((attempt + 1) * 1000)).await;
+            match sharp_service.get_task_status(&task_id).await.unwrap() {
+                TaskStatus::Failed(err) => {
+                    println!("SHARP: task failed with {}", err);
+                    panic!("{:#?}", err);
+                }
+                TaskStatus::Processing => {
+                    println!("SHARP: task is processing (attempt {})", attempt);
+                    continue;
+                }
+                TaskStatus::Succeeded => {
+                    println!("SHARP: task is completed");
+                    return;
+                }
+            }
+        }
+        panic!("SHARP: timeout");
+    }
+}