feat: stateless proving with Moongate

Author: leruaa

crates/cuda/proto/api.proto

@@ -6,6 +6,7 @@ service ProverService {
     rpc Setup(SetupRequest) returns (SetupResponse) {}
     rpc Ready(ReadyRequest) returns (ReadyResponse) {}
     rpc ProveCore(ProveCoreRequest) returns (ProveCoreResponse) {}
+    rpc ProveCoreStateless(ProveCoreRequest) returns (ProveCoreResponse) {}
     rpc Compress(CompressRequest) returns (CompressResponse) {}
     rpc Shrink(ShrinkRequest) returns (ShrinkResponse) {}
     rpc Wrap(WrapRequest) returns (WrapResponse) {}

crates/cuda/src/lib.rs

@@ -76,6 +76,19 @@ pub struct ProveCoreRequestPayload {
     pub stdin: SP1Stdin,
 }
 
+/// The payload for the [sp1_prover::SP1Prover::stateless_prove_core] method.
+///
+/// We use this object to serialize and deserialize the payload from the client to the server.
+/// The ELF is included in the payload to allow to build the program and the pk on the Moongate
+/// server
+#[derive(Serialize, Deserialize)]
+pub struct StatelessProveCoreRequestPayload {
+    /// The input stream.
+    pub stdin: SP1Stdin,
+    /// The ELF.
+    pub elf: Vec<u8>,
+}
+
 /// The payload for the [sp1_prover::SP1Prover::compress] method.
 ///
 /// We use this object to serialize and deserialize the payload from the client to the server.
@@ -259,6 +272,22 @@ impl SP1CudaProver {
         Ok(proof)
     }
 
+    /// Executes the [sp1_prover::SP1Prover::prove_core] method inside the container.
+    ///
+    /// You will need at least 24GB of VRAM to run this method.
+    pub fn prove_core_stateless(
+        &self,
+        elf: Vec<u8>,
+        stdin: &SP1Stdin,
+    ) -> Result<SP1CoreProof, SP1CoreProverError> {
+        let payload = StatelessProveCoreRequestPayload { elf, stdin: stdin.clone() };
+        let request =
+            crate::proto::api::ProveCoreRequest { data: bincode::serialize(&payload).unwrap() };
+        let response = block_on(async { self.client.prove_core_stateless(request).await }).unwrap();
+        let proof: SP1CoreProof = bincode::deserialize(&response.result).unwrap();
+        Ok(proof)
+    }
+
     /// Executes the [sp1_prover::SP1Prover::compress] method inside the container.
     ///
     /// You will need at least 24GB of VRAM to run this method.

crates/cuda/src/proto/api.rs

@@ -87,6 +87,11 @@ pub trait ProverService {
         ctx: twirp::Context,
         req: ProveCoreRequest,
     ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse>;
+    async fn prove_core_stateless(
+        &self,
+        ctx: twirp::Context,
+        req: ProveCoreRequest,
+    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse>;
     async fn compress(
         &self,
         ctx: twirp::Context,
@@ -129,6 +134,13 @@ where
     ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse> {
         T::prove_core(&*self, ctx, req).await
     }
+    async fn prove_core_stateless(
+        &self,
+        ctx: twirp::Context,
+        req: ProveCoreRequest,
+    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse> {
+        T::prove_core_stateless(&*self, ctx, req).await
+    }
     async fn compress(
         &self,
         ctx: twirp::Context,
@@ -174,6 +186,12 @@ where
                 api.prove_core(ctx, req).await
             },
         )
+        .route(
+            "/ProveCoreStateless",
+            |api: T, ctx: twirp::Context, req: ProveCoreRequest| async move {
+                api.prove_core_stateless(ctx, req).await
+            },
+        )
         .route(
             "/Compress",
             |api: T, ctx: twirp::Context, req: CompressRequest| async move {
@@ -208,6 +226,10 @@ pub trait ProverServiceClient: Send + Sync + std::fmt::Debug {
         &self,
         req: ProveCoreRequest,
     ) -> Result<ProveCoreResponse, twirp::ClientError>;
+    async fn prove_core_stateless(
+        &self,
+        req: ProveCoreRequest,
+    ) -> Result<ProveCoreResponse, twirp::ClientError>;
     async fn compress(
         &self,
         req: CompressRequest,
@@ -238,6 +260,12 @@ impl ProverServiceClient for twirp::client::Client {
     ) -> Result<ProveCoreResponse, twirp::ClientError> {
         self.request("api.ProverService/ProveCore", req).await
     }
+    async fn prove_core_stateless(
+        &self,
+        req: ProveCoreRequest,
+    ) -> Result<ProveCoreResponse, twirp::ClientError> {
+        self.request("api.ProverService/ProveCoreStateless", req).await
+    }
     async fn compress(
         &self,
         req: CompressRequest,

crates/sdk/src/cuda/mod.rs

@@ -96,7 +96,7 @@ impl Prover<CpuProverComponents> for CudaProver {
         kind: SP1ProofMode,
     ) -> Result<SP1ProofWithPublicValues> {
         // Generate the core proof.
-        let proof = self.cuda_prover.prove_core(stdin)?;
+        let proof = self.cuda_prover.prove_core_stateless(pk.elf.clone(), stdin)?;
         if kind == SP1ProofMode::Core {
             return Ok(SP1ProofWithPublicValues::new(
                 SP1Proof::Core(proof.proof.0),