As a first version, return the merkle paths on the get_receipts query

Author: maximopalopoli

aggregation_mode/batcher/src/db.rs

@@ -45,21 +45,64 @@ impl Db {
             .map(|res| res.flatten())
     }
 
-    pub async fn get_tasks_by_address(
+    pub async fn get_tasks_by_address_and_nonce(
         &self,
-        address: &str,
+        address: Option<&str>,
+        nonce: Option<i64>,
         limit: i64,
     ) -> Result<Vec<Option<Vec<u8>>>, sqlx::Error> {
-        sqlx::query_scalar::<_, Option<Vec<u8>>>(
-            "SELECT merkle_path FROM tasks
-            WHERE address = $1
-            ORDER BY created_at DESC
-            LIMIT $2",
-        )
-        .bind(address.to_lowercase())
-        .bind(limit)
-        .fetch_all(&self.pool)
-        .await
+        // TODO: Return merkle paths, task status, address and nonce for each task
+        // 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
+                WHERE address = $1
+                AND nonce = $2
+                ORDER BY created_at DESC
+                LIMIT $3",
+                )
+                .bind(addr.to_lowercase())
+                .bind(n)
+                .bind(limit)
+                .fetch_all(&self.pool)
+                .await
+            }
+            (Some(addr), None) => {
+                sqlx::query_scalar::<_, Option<Vec<u8>>>(
+                    "SELECT merkle_path FROM tasks
+                WHERE address = $1
+                ORDER BY created_at DESC
+                LIMIT $2",
+                )
+                .bind(addr.to_lowercase())
+                .bind(limit)
+                .fetch_all(&self.pool)
+                .await
+            }
+            (None, Some(n)) => {
+                sqlx::query_scalar::<_, Option<Vec<u8>>>(
+                    "SELECT merkle_path FROM tasks
+                WHERE nonce = $1
+                ORDER BY created_at DESC
+                LIMIT $2",
+                )
+                .bind(n)
+                .bind(limit)
+                .fetch_all(&self.pool)
+                .await
+            }
+            (None, None) => {
+                sqlx::query_scalar::<_, Option<Vec<u8>>>(
+                    "SELECT merkle_path FROM tasks
+                ORDER BY created_at DESC
+                LIMIT $1",
+                )
+                .bind(limit)
+                .fetch_all(&self.pool)
+                .await
+            }
+        }
     }
 
     pub async fn insert_task(

aggregation_mode/batcher/src/server/helpers.rs

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

aggregation_mode/batcher/src/server/http.rs

@@ -11,7 +11,7 @@ use aligned_sdk::aggregation_layer::AggregationModeProvingSystem;
 use sqlx::types::BigDecimal;
 
 use super::{
-    helpers::format_merkle_path,
+    helpers::format_merkle_paths,
     types::{AppResponse, GetReceiptsParams},
 };
 
@@ -184,21 +184,10 @@ impl BatcherServer {
         let state = state.get_ref();
 
         // TODO: maybe also accept proof commitment in query param
-        let Some(address) = params.address.clone() else {
-            return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
-                "Provide task `address` query param",
-                400,
-            ));
-        };
-
-        if address.is_empty() {
-            return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
-                "Address cannot be empty",
-                400,
-            ));
-        }
-
-        let db_result = state.db.get_tasks_by_address(&address, 100).await;
+        let db_result = state
+            .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(_) => {
@@ -207,10 +196,10 @@ impl BatcherServer {
             }
         };
 
-        match format_merkle_path(&merkle_path) {
-            Ok(merkle_path) => {
+        match format_merkle_paths(merkle_paths) {
+            Ok(merkle_paths) => {
                 HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!({
-                    "merkle_path": merkle_path
+                    "merkle_paths": merkle_paths
                 })))
             }
             Err(_) => HttpResponse::InternalServerError()

aggregation_mode/batcher/src/server/types.rs

@@ -30,7 +30,7 @@ impl AppResponse {
 #[derive(Deserialize, Clone)]
 pub(super) struct GetReceiptsParams {
     pub address: Option<String>,
-    pub nonce: Option<u64>,
+    pub nonce: Option<i64>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]