refactor: rename proofs for tasks

Author: MarcosNicolau

aggregation_mode/batcher/src/db.rs

@@ -25,30 +25,27 @@ impl Db {
         Ok(Self { pool })
     }
 
-    pub async fn count_proofs_by_address(&self, address: &str) -> Result<i64, sqlx::Error> {
-        let (count,) =
-            sqlx::query_as::<_, (i64,)>("SELECT COUNT(*) FROM proofs WHERE address = $1")
-                .bind(address.to_lowercase())
-                .fetch_one(&self.pool)
-                .await?;
+    pub async fn count_tasks_by_address(&self, address: &str) -> Result<i64, sqlx::Error> {
+        let (count,) = sqlx::query_as::<_, (i64,)>("SELECT COUNT(*) FROM tasks WHERE address = $1")
+            .bind(address.to_lowercase())
+            .fetch_one(&self.pool)
+            .await?;
 
         Ok(count)
     }
 
-    pub async fn get_merkle_path_by_proof_id(
+    pub async fn get_merkle_path_by_task_id(
         &self,
-        proof_id: Uuid,
+        task_id: Uuid,
     ) -> Result<Option<Vec<u8>>, sqlx::Error> {
-        sqlx::query_scalar::<_, Option<Vec<u8>>>(
-            "SELECT merkle_path FROM proofs WHERE proof_id = $1",
-        )
-        .bind(proof_id)
-        .fetch_optional(&self.pool)
-        .await
-        .map(|res| res.flatten())
+        sqlx::query_scalar::<_, Option<Vec<u8>>>("SELECT merkle_path FROM tasks WHERE task_id = $1")
+            .bind(task_id)
+            .fetch_optional(&self.pool)
+            .await
+            .map(|res| res.flatten())
     }
 
-    pub async fn insert_proof(
+    pub async fn insert_task(
         &self,
         address: &str,
         proving_system_id: i32,
@@ -57,14 +54,14 @@ impl Db {
         merkle_path: Option<&[u8]>,
     ) -> Result<Uuid, sqlx::Error> {
         sqlx::query_scalar::<_, Uuid>(
-            "INSERT INTO proofs (
+            "INSERT INTO tasks (
                 address,
                 proving_system_id,
                 proof,
                 program_commitment,
                 merkle_path
             ) VALUES ($1, $2, $3, $4, $5)
-            RETURNING proof_id",
+            RETURNING task_id",
         )
         .bind(address.to_lowercase())
         .bind(proving_system_id)

aggregation_mode/batcher/src/server/http.rs

@@ -69,7 +69,7 @@ impl BatcherServer {
         };
 
         let state = state.get_ref();
-        match state.db.count_proofs_by_address(address).await {
+        match state.db.count_tasks_by_address(address).await {
             Ok(count) => HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!(
                 {
                     "nonce": count
@@ -95,7 +95,7 @@ impl BatcherServer {
         };
         let state = state.get_ref();
 
-        let Ok(count) = state.db.count_proofs_by_address(&recovered_address).await else {
+        let Ok(count) = state.db.count_tasks_by_address(&recovered_address).await else {
             return HttpResponse::InternalServerError()
                 .json(AppResponse::new_unsucessfull("Internal server error", 500));
         };
@@ -142,7 +142,7 @@ impl BatcherServer {
 
         match state
             .db
-            .insert_proof(
+            .insert_task(
                 &recovered_address,
                 AggregationModeProvingSystem::SP1.as_u16() as i32,
                 &data.message.proof,
@@ -151,8 +151,8 @@ impl BatcherServer {
             )
             .await
         {
-            Ok(proof_id) => HttpResponse::Ok().json(AppResponse::new_sucessfull(
-                serde_json::json!({ "proof_id": proof_id.to_string() }),
+            Ok(task_id) => HttpResponse::Ok().json(AppResponse::new_sucessfull(
+                serde_json::json!({ "task_id": task_id.to_string() }),
             )),
             Err(_) => HttpResponse::InternalServerError()
                 .json(AppResponse::new_unsucessfull("Internal server error", 500)),
@@ -181,7 +181,7 @@ impl BatcherServer {
         // TODO: maybe also accept proof commitment in query param
         let Some(id) = params.id.clone() else {
             return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
-                "Provide proof `id` query param",
+                "Provide task `id` query param",
                 400,
             ));
         };
@@ -198,7 +198,7 @@ impl BatcherServer {
                 .json(AppResponse::new_unsucessfull("Proof id invalid uuid", 400));
         };
 
-        let db_result = state.db.get_merkle_path_by_proof_id(proof_id).await;
+        let db_result = state.db.get_merkle_path_by_task_id(proof_id).await;
         let merkle_path = match db_result {
             Ok(Some(merkle_path)) => merkle_path,
             Ok(None) => {

aggregation_mode/db/migrations/001_init.sql

@@ -1,13 +1,13 @@
-CREATE TYPE proof_status AS ENUM ('pending', 'processing', 'verified');
+CREATE TYPE task_status AS ENUM ('pending', 'processing', 'verified');
 
-CREATE TABLE proofs (
-    proof_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+CREATE TABLE tasks (
+    task_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     address CHAR(42), 
     proving_system_id INT,
     proof BYTEA,
     program_commitment BYTEA,
     merkle_path BYTEA,
-    status proof_status DEFAULT 'pending'
+    status task_status DEFAULT 'pending'
 );
 
 CREATE TABLE payment_events (