feat: post sp1 proof ep

Author: MarcosNicolau

aggregation_mode/batcher/src/db.rs

@@ -43,4 +43,51 @@ impl Db {
         .await
         .map(|res| res.flatten())
     }
+
+    pub async fn insert_proof(
+        &self,
+        address: &str,
+        proving_system_id: i32,
+        proof: &[u8],
+        program_commitment: &[u8],
+        merkle_path: Option<&[u8]>,
+        task_id: Option<Uuid>,
+    ) -> Result<Uuid, sqlx::Error> {
+        sqlx::query_scalar::<_, Uuid>(
+            "INSERT INTO proofs (
+                address,
+                proving_system_id,
+                proof,
+                program_commitment,
+                merkle_path,
+                task_id
+            ) VALUES ($1, $2, $3, $4, $5, $6)
+            RETURNING proof_id",
+        )
+        .bind(address)
+        .bind(proving_system_id)
+        .bind(proof)
+        .bind(program_commitment)
+        .bind(merkle_path)
+        .bind(task_id)
+        .fetch_one(&self.pool)
+        .await
+    }
+
+    pub async fn has_active_payment_event(
+        &self,
+        address: &str,
+        now_ts: i64,
+    ) -> Result<bool, sqlx::Error> {
+        sqlx::query_scalar::<_, bool>(
+            "SELECT EXISTS(
+                SELECT 1 FROM payment_events
+                WHERE address = $1 AND started_at < $2 AND $2 < valid_until
+            )",
+        )
+        .bind(address)
+        .bind(now_ts)
+        .fetch_one(&self.pool)
+        .await
+    }
 }

aggregation_mode/batcher/src/server/http.rs

@@ -1,4 +1,7 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
 use actix_web::{
+    http::StatusCode,
     web::{self, Data},
     App, HttpRequest, HttpResponse, HttpServer, Responder,
 };
@@ -9,7 +12,13 @@ use super::{
     types::{AppResponse, ProofMerkleQuery},
 };
 
-use crate::{config::Config, db::Db, server::types::SubmitProofRequest};
+use crate::{
+    config::Config,
+    db::Db,
+    server::types::{
+        SubmitProofRequest, SubmitProofRequestMessageRisc0, SubmitProofRequestMessageSP1,
+    },
+};
 
 #[derive(Clone, Debug)]
 pub struct BatcherServer {
@@ -60,23 +69,20 @@ impl BatcherServer {
                     "nonce": count
                 }
             ))),
-            Err(err) => {
-                tracing::error!(error = ?err, "failed to count proofs");
-                HttpResponse::InternalServerError()
-                    .json(AppResponse::new_unsucessfull("Internal server error", 500))
-            }
+            Err(_) => HttpResponse::InternalServerError()
+                .json(AppResponse::new_unsucessfull("Internal server error", 500)),
         }
     }
 
     // TODO: receive the proof and 1. decode it, 2. verify it, 3. add to the db
     async fn post_proof_sp1(
         req: HttpRequest,
-        body: web::Json<SubmitProofRequest>,
+        body: web::Json<SubmitProofRequest<SubmitProofRequestMessageSP1>>,
     ) -> impl Responder {
         let data = body.into_inner();
 
         // TODO: validate signature
-        let recovered_address = "";
+        let recovered_address = "0x0000000000000000000000000000000000000000";
 
         let Some(state) = req.app_data::<Data<BatcherServer>>() else {
             return HttpResponse::InternalServerError()
@@ -85,16 +91,68 @@ impl BatcherServer {
         let state = state.get_ref();
 
         let Ok(count) = state.db.count_proofs_by_address(recovered_address).await else {
-            return HttpResponse::InternalServerError().finish();
+            return HttpResponse::InternalServerError()
+                .json(AppResponse::new_unsucessfull("Internal server error", 500));
         };
 
-        HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!({})))
+        if data.nonce != (count as u64) {
+            return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
+                &format!("Invalid nonce, expected nonce = {count}"),
+                400,
+            ));
+        }
+
+        let now_ts = match SystemTime::now().duration_since(UNIX_EPOCH) {
+            Ok(duration) => duration.as_secs() as i64,
+            Err(_) => {
+                return HttpResponse::InternalServerError()
+                    .json(AppResponse::new_unsucessfull("Internal server error", 500));
+            }
+        };
+
+        let has_payment = match state
+            .db
+            .has_active_payment_event(recovered_address, now_ts)
+            .await
+        {
+            Ok(result) => result,
+            Err(_) => {
+                return HttpResponse::InternalServerError()
+                    .json(AppResponse::new_unsucessfull("Internal server error", 500));
+            }
+        };
+
+        if !has_payment {
+            return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
+                "You have to pay before submitting a proof",
+                400,
+            ));
+        }
+
+        match state
+            .db
+            .insert_proof(
+                recovered_address,
+                AggregationModeProvingSystem::SP1.as_u16() as i32,
+                &data.message.proof,
+                &data.message.program_vk_commitment,
+                None,
+                None,
+            )
+            .await
+        {
+            Ok(proof_id) => HttpResponse::Ok().json(AppResponse::new_sucessfull(
+                serde_json::json!({ "proof_id": proof_id.to_string() }),
+            )),
+            Err(_) => HttpResponse::InternalServerError()
+                .json(AppResponse::new_unsucessfull("Internal server error", 500)),
+        }
     }
 
     /// TODO: complete for risc0 (see `post_proof_sp1`)
     async fn post_proof_risc0(
         _req: HttpRequest,
-        _body: web::Json<SubmitProofRequest>,
+        _body: web::Json<SubmitProofRequest<SubmitProofRequestMessageRisc0>>,
     ) -> impl Responder {
         HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!({})))
     }

aggregation_mode/batcher/src/server/types.rs

@@ -27,24 +27,26 @@ impl AppResponse {
     }
 }
 
-// TODO: move this to the sdk once ready
-
 #[derive(Deserialize, Clone)]
 pub(super) struct ProofMerkleQuery {
     pub id: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
-pub(super) struct SubmitProofRequest {
-    pub message: SubmitProofRequestMessage,
+pub(super) struct SubmitProofRequest<T> {
+    pub nonce: u64,
+    pub message: T,
     pub signature: String,
 }
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub(super) struct SubmitProofRequestMessageSP1 {
+    pub proof: Vec<u8>,
+    pub program_vk_commitment: Vec<u8>,
+}
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
-pub(super) struct SubmitProofRequestMessage {
-    pub nonce: u64,
-    pub proving_system_id: AggregationModeProvingSystem,
+pub(super) struct SubmitProofRequestMessageRisc0 {
     pub proof: Vec<u8>,
-    pub public_inputs: Option<Vec<u8>>,
-    pub program_id: Vec<u8>,
+    pub program_image_id: Vec<u8>,
+    pub public_inputs: Vec<u8>,
 }

aggregation_mode/db/migrations/001_init.sql

@@ -9,10 +9,8 @@ CREATE TABLE proofs (
     proof_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     address CHAR(42), 
     proving_system_id INT,
-    vm_program_code BYTEA,
     proof BYTEA,
-    public_inputs BYTEA,
-    proof_commitment BYTEA,
+    program_commitment BYTEA,
     merkle_path BYTEA,
     task_id UUID REFERENCES tasks(task_id)
 );