Return Receipt type on receipt endpoint query

Author: maximopalopoli

aggregation_mode/batcher/src/db.rs

@@ -14,6 +14,23 @@ pub enum DbError {
     ConnectError(String),
 }
 
+#[derive(Debug, Clone, sqlx::Type, serde::Serialize)]
+#[sqlx(type_name = "task_status")]
+#[sqlx(rename_all = "lowercase")]
+enum TaskStatus {
+    Pending,
+    Processing,
+    Verified,
+}
+
+#[derive(Debug, Clone, sqlx::FromRow, sqlx::Type, serde::Serialize)]
+pub(crate) struct Receipt {
+    status: TaskStatus,
+    pub(crate) merkle_path: Option<Vec<u8>>,
+    nonce: i64,
+    address: String,
+}
+
 impl Db {
     pub async fn try_new(connection_url: &str) -> Result<Self, DbError> {
         let pool = PgPoolOptions::new()
@@ -50,13 +67,12 @@ impl Db {
         address: Option<&str>,
         nonce: Option<i64>,
         limit: i64,
-    ) -> Result<Vec<Option<Vec<u8>>>, sqlx::Error> {
-        // TODO: Return merkle paths, task status, address and nonce for each task
+    ) -> Result<Vec<Receipt>, sqlx::Error> {
         // TODO: use dynamic query building instead of match
         match (address, nonce) {
             (Some(addr), Some(n)) => {
-                sqlx::query_scalar::<_, Option<Vec<u8>>>(
-                    "SELECT merkle_path FROM tasks
+                sqlx::query_as::<_, Receipt>(
+                    "SELECT status,merkle_path,nonce,address FROM tasks
                 WHERE address = $1
                 AND nonce = $2
                 LIMIT $3",
@@ -68,8 +84,8 @@ impl Db {
                 .await
             }
             (Some(addr), None) => {
-                sqlx::query_scalar::<_, Option<Vec<u8>>>(
-                    "SELECT merkle_path FROM tasks
+                sqlx::query_as::<_, Receipt>(
+                    "SELECT status,merkle_path,nonce,address FROM tasks
                 WHERE address = $1
                 LIMIT $2",
                 )
@@ -79,8 +95,8 @@ impl Db {
                 .await
             }
             (None, Some(n)) => {
-                sqlx::query_scalar::<_, Option<Vec<u8>>>(
-                    "SELECT merkle_path FROM tasks
+                sqlx::query_as::<_, Receipt>(
+                    "SELECT status,merkle_path,nonce,address FROM tasks
                 WHERE nonce = $1
                 LIMIT $2",
                 )
@@ -90,8 +106,8 @@ impl Db {
                 .await
             }
             (None, None) => {
-                sqlx::query_scalar::<_, Option<Vec<u8>>>(
-                    "SELECT merkle_path FROM tasks
+                sqlx::query_as::<_, Receipt>(
+                    "SELECT status,merkle_path,nonce,address FROM tasks
                 LIMIT $1",
                 )
                 .bind(limit)

aggregation_mode/batcher/src/server/helpers.rs

@@ -1,22 +1,28 @@
-pub(super) fn format_merkle_paths(paths: Vec<Option<Vec<u8>>>) -> Result<Vec<Vec<String>>, String> {
+use crate::db::Receipt;
+
+pub(super) fn format_merkle_paths(
+    paths: Vec<Receipt>,
+) -> Result<Vec<(Receipt, Vec<String>)>, String> {
     paths
-        .iter()
-        .map(|path_opt| match path_opt {
-            Some(bytes) => {
-                if bytes.is_empty() {
-                    return Ok(vec![]);
+        .into_iter()
+        .map(|receipt| {
+            if let Some(merkle_path) = &receipt.merkle_path {
+                if merkle_path.is_empty() {
+                    return Ok((receipt, vec![]));
                 }
-
-                if bytes.len() % 32 != 0 {
+                if merkle_path.len() % 32 != 0 {
                     return Err("merkle path length is not a multiple of 32 bytes".into());
                 }
 
-                Ok(bytes
+                let formatted_merkle_path = merkle_path
                     .chunks(32)
                     .map(|chunk| format!("0x{}", hex::encode(chunk)))
-                    .collect())
+                    .collect();
+
+                Ok((receipt, formatted_merkle_path))
+            } else {
+                Ok((receipt, vec![]))
             }
-            None => Ok(vec![]),
         })
         .collect()
 }

aggregation_mode/batcher/src/server/http.rs

@@ -178,8 +178,10 @@ impl BatcherServer {
         params: web::Query<GetReceiptsParams>,
     ) -> impl Responder {
         let Some(state) = req.app_data::<Data<BatcherServer>>() else {
-            return HttpResponse::InternalServerError()
-                .json(AppResponse::new_unsucessfull("Internal server error", 500));
+            return HttpResponse::InternalServerError().json(AppResponse::new_unsucessfull(
+                "Internal server error: Failed to get app data",
+                500,
+            ));
         };
 
         let state = state.get_ref();
@@ -189,22 +191,27 @@ impl BatcherServer {
             .db
             .get_tasks_by_address_and_nonce(params.address.as_deref(), params.nonce, 100)
             .await;
-        let merkle_paths = match db_result {
-            Ok(merkle_paths) => merkle_paths,
-            Err(_) => {
-                return HttpResponse::InternalServerError()
-                    .json(AppResponse::new_unsucessfull("Internal server error", 500));
+        let receipts = match db_result {
+            Ok(receipts) => receipts,
+            Err(e) => {
+                return HttpResponse::InternalServerError().json(AppResponse::new_unsucessfull(
+                    format!("Internal server error: Failed to get tasks by address and nonce: {e}")
+                        .as_str(),
+                    500,
+                ));
             }
         };
 
-        match format_merkle_paths(merkle_paths) {
-            Ok(merkle_paths) => {
+        match format_merkle_paths(receipts) {
+            Ok(receipts) => {
                 HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!({
-                    "merkle_paths": merkle_paths
+                    "receipts": receipts
                 })))
             }
-            Err(_) => HttpResponse::InternalServerError()
-                .json(AppResponse::new_unsucessfull("Internal server error", 500)),
+            Err(e) => HttpResponse::InternalServerError().json(AppResponse::new_unsucessfull(
+                format!("Internal server error: {e}").as_str(),
+                500,
+            )),
         }
     }
 }