feat: update SDK for network

crates/perf/src/main.rs

@@ -177,13 +177,13 @@ fn main() {
             let (_, _) = time_operation(|| prover.execute(&elf, &stdin));
 
             let (proof, _) = time_operation(|| {
-                prover.prove(&pk, stdin.clone()).groth16().skip_simulation(true).run().unwrap()
+                prover.prove(&pk, &stdin).groth16().skip_simulation(true).run().unwrap()
             });
 
             let (_, _) = time_operation(|| prover.verify(&proof, &vk));
 
             let (proof, _) = time_operation(|| {
-                prover.prove(&pk, stdin).plonk().skip_simulation(true).run().unwrap()
+                prover.prove(&pk, &stdin).plonk().skip_simulation(true).run().unwrap()
             });
 
             let (_, _) = time_operation(|| prover.verify(&proof, &vk));

crates/sdk/src/cpu/builder.rs

@@ -26,6 +26,10 @@ impl CpuProverBuilder {
     /// ```
     #[must_use]
     pub fn build(self) -> CpuProver {
-        if self.mock { CpuProver::mock() } else { CpuProver::new() }
+        if self.mock {
+            CpuProver::mock()
+        } else {
+            CpuProver::new()
+        }
     }
 }

crates/sdk/src/network/client.rs

@@ -20,14 +20,14 @@ use tonic::{
 
 use super::utils::Signable;
 use crate::network::proto::artifact::{
-    artifact_store_client::ArtifactStoreClient, CreateArtifactRequest,
+    artifact_store_client::ArtifactStoreClient, ArtifactType, CreateArtifactRequest,
 };
 use crate::network::proto::network::{
     prover_network_client::ProverNetworkClient, CreateProgramRequest, CreateProgramRequestBody,
-    CreateProgramResponse, FulfillmentStatus, FulfillmentStrategy, GetNonceRequest,
-    GetProgramRequest, GetProgramResponse, GetProofRequestStatusRequest,
-    GetProofRequestStatusResponse, MessageFormat, ProofMode, RequestProofRequest,
-    RequestProofRequestBody, RequestProofResponse,
+    CreateProgramResponse, FulfillmentStatus, FulfillmentStrategy, GetFilteredProofRequestsRequest,
+    GetFilteredProofRequestsResponse, GetNonceRequest, GetProgramRequest, GetProgramResponse,
+    GetProofRequestStatusRequest, GetProofRequestStatusResponse, MessageFormat, ProofMode,
+    RequestProofRequest, RequestProofRequestBody, RequestProofResponse,
 };
 
 /// A client for interacting with the network.
@@ -105,7 +105,8 @@ impl NetworkClient {
     ) -> Result<CreateProgramResponse> {
         // Create the program artifact.
         let mut store = self.artifact_store_client().await?;
-        let program_uri = self.create_artifact_with_content(&mut store, &elf).await?;
+        let program_uri =
+            self.create_artifact_with_content(&mut store, ArtifactType::Program, &elf).await?;
 
         // Serialize the verifying key.
         let vk_encoded = bincode::serialize(&vk)?;
@@ -130,6 +131,44 @@ impl NetworkClient {
             .into_inner())
     }
 
+    /// Get all the proof requests that meet the filter criteria.
+    #[allow(clippy::too_many_arguments)]
+    pub async fn get_filtered_proof_requests(
+        &self,
+        version: Option<String>,
+        fulfillment_status: Option<i32>,
+        execution_status: Option<i32>,
+        minimum_deadline: Option<u64>,
+        vk_hash: Option<Vec<u8>>,
+        requester: Option<Vec<u8>>,
+        fulfiller: Option<Vec<u8>>,
+        from: Option<u64>,
+        to: Option<u64>,
+        limit: Option<u32>,
+        page: Option<u32>,
+        mode: Option<i32>,
+    ) -> Result<GetFilteredProofRequestsResponse> {
+        let mut rpc = self.prover_network_client().await?;
+        let res = rpc
+            .get_filtered_proof_requests(GetFilteredProofRequestsRequest {
+                version,
+                fulfillment_status,
+                execution_status,
+                minimum_deadline,
+                vk_hash,
+                requester,
+                fulfiller,
+                from,
+                to,
+                limit,
+                page,
+                mode,
+            })
+            .await?
+            .into_inner();
+        Ok(res)
+    }
+
     /// Get the status of a given proof.
     ///
     /// # Details
@@ -190,7 +229,8 @@ impl NetworkClient {
 
         // Create the stdin artifact.
         let mut store = self.artifact_store_client().await?;
-        let stdin_uri = self.create_artifact_with_content(&mut store, &stdin).await?;
+        let stdin_uri =
+            self.create_artifact_with_content(&mut store, ArtifactType::Stdin, &stdin).await?;
 
         // Send the request.
         let mut rpc = self.prover_network_client().await?;
@@ -248,10 +288,14 @@ impl NetworkClient {
     pub(crate) async fn create_artifact_with_content<T: Serialize>(
         &self,
         store: &mut ArtifactStoreClient<Channel>,
+        artifact_type: ArtifactType,
         item: &T,
     ) -> Result<String> {
         let signature = self.signer.sign_message_sync("create_artifact".as_bytes())?;
-        let request = CreateArtifactRequest { signature: signature.as_bytes().to_vec() };
+        let request = CreateArtifactRequest {
+            artifact_type: artifact_type.into(),
+            signature: signature.as_bytes().to_vec(),
+        };
         let response = store.create_artifact(request).await?.into_inner();
 
         let presigned_url = response.artifact_presigned_url;

crates/sdk/src/network/error.rs

@@ -0,0 +1,39 @@
+use thiserror::Error;
+use tonic::Status;
+
+/// An error that can occur when interacting with the prover network.
+#[derive(Error, Debug)]
+pub enum Error {
+    /// The program execution failed.
+    #[error("Program simulation failed")]
+    SimulationFailed,
+
+    /// The proof request is unexecutable.
+    #[error("Proof request 0x{} is unexecutable", hex::encode(.request_id))]
+    RequestUnexecutable {
+        /// The ID of the request that cannot be executed.
+        request_id: Vec<u8>,
+    },
+
+    /// The proof request is unfulfillable.
+    #[error("Proof request 0x{} is unfulfillable", hex::encode(.request_id))]
+    RequestUnfulfillable {
+        /// The ID of the request that cannot be fulfilled.
+        request_id: Vec<u8>,
+    },
+
+    /// The proof request timed out.
+    #[error("Proof request 0x{} timed out", hex::encode(.request_id))]
+    RequestTimedOut {
+        /// The ID of the request that timed out.
+        request_id: Vec<u8>,
+    },
+
+    /// An error occurred while interacting with the RPC server.
+    #[error("RPC error")]
+    RpcError(#[from] Status),
+
+    /// An unknown error occurred.
+    #[error("Other error: {0}")]
+    Other(#[from] anyhow::Error),
+}

crates/sdk/src/network/mod.rs

@@ -11,9 +11,12 @@ mod sign_message;
 #[allow(clippy::too_many_lines)]
 pub mod proto;
 pub mod builder;
+mod error;
 pub mod prove;
 pub mod utils;
 
+pub use error::*;
+
 pub use crate::network::client::NetworkClient;
 pub use crate::network::proto::network::FulfillmentStrategy;
 

crates/sdk/src/network/proto/artifact.rs

@@ -4,6 +4,9 @@ pub struct CreateArtifactRequest {
     /// The signature of the user on a pre-defined message. Used for authentication.
     #[prost(bytes = "vec", tag = "1")]
     pub signature: ::prost::alloc::vec::Vec<u8>,
+    /// The type of artifact to create.
+    #[prost(enumeration = "ArtifactType", tag = "2")]
+    pub artifact_type: i32,
 }
 #[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, ::prost::Message)]
 pub struct CreateArtifactResponse {
@@ -14,11 +17,58 @@ pub struct CreateArtifactResponse {
     #[prost(string, tag = "2")]
     pub artifact_presigned_url: ::prost::alloc::string::String,
 }
+#[derive(
+    serde::Serialize,
+    serde::Deserialize,
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    ::prost::Enumeration,
+)]
+#[repr(i32)]
+pub enum ArtifactType {
+    UnspecifiedArtifactType = 0,
+    /// A program artifact.
+    Program = 1,
+    /// A stdin artifact.
+    Stdin = 2,
+    /// A proof artifact.
+    Proof = 3,
+}
+impl ArtifactType {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Self::UnspecifiedArtifactType => "UNSPECIFIED_ARTIFACT_TYPE",
+            Self::Program => "PROGRAM",
+            Self::Stdin => "STDIN",
+            Self::Proof => "PROOF",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "UNSPECIFIED_ARTIFACT_TYPE" => Some(Self::UnspecifiedArtifactType),
+            "PROGRAM" => Some(Self::Program),
+            "STDIN" => Some(Self::Stdin),
+            "PROOF" => Some(Self::Proof),
+            _ => None,
+        }
+    }
+}
 /// Generated client implementations.
 pub mod artifact_store_client {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::http::Uri;
-    use tonic::codegen::{Body, Bytes, CompressionEncoding, GrpcMethod, InterceptedService, StdError, http};
+    use tonic::codegen::*;
     #[derive(Debug, Clone)]
     pub struct ArtifactStoreClient<T> {
         inner: tonic::client::Grpc<T>,
@@ -57,11 +107,11 @@ pub mod artifact_store_client {
             F: tonic::service::Interceptor,
             T::ResponseBody: Default,
             T: tonic::codegen::Service<
-                    http::Request<tonic::body::BoxBody>,
-                    Response = http::Response<
-                        <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
-                    >,
+                http::Request<tonic::body::BoxBody>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                 >,
+            >,
             <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
                 Into<StdError> + std::marker::Send + std::marker::Sync,
         {
@@ -123,7 +173,7 @@ pub mod artifact_store_client {
 /// Generated server implementations.
 pub mod artifact_store_server {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
-    use tonic::codegen::{Arc, Body, BoxFuture, CompressionEncoding, Context, EnabledCompressionEncodings, InterceptedService, Poll, StdError, async_trait, empty_body, http};
+    use tonic::codegen::*;
     /// Generated trait containing gRPC methods that should be implemented for use with ArtifactStoreServer.
     #[async_trait]
     pub trait ArtifactStore: std::marker::Send + std::marker::Sync + 'static {