require addresss on receipts query, and simplify the db interface

Author: maximopalopoli

aggregation_mode/batcher/src/db.rs

@@ -64,46 +64,34 @@ impl Db {
 
     pub async fn get_tasks_by_address_and_nonce(
         &self,
-        address: Option<&str>,
-        nonce: Option<i64>,
-        limit: i64,
+        address: &str,
+        nonce: i64,
     ) -> Result<Vec<Receipt>, sqlx::Error> {
-        // TODO: use dynamic query building instead of match
-        match (address, nonce) {
-            (Some(addr), Some(n)) => {
-                sqlx::query_as::<_, Receipt>(
-                    "SELECT status,merkle_path,nonce,address FROM tasks
+        sqlx::query_as::<_, Receipt>(
+            "SELECT status,merkle_path,nonce,address FROM tasks
                 WHERE address = $1
-                AND nonce = $2
-                LIMIT $3",
-                )
-                .bind(addr.to_lowercase())
-                .bind(n)
-                .bind(limit)
-                .fetch_all(&self.pool)
-                .await
-            }
-            (Some(addr), None) => {
-                sqlx::query_as::<_, Receipt>(
-                    "SELECT status,merkle_path,nonce,address FROM tasks
+                AND nonce = $2",
+        )
+        .bind(address.to_lowercase())
+        .bind(nonce)
+        .fetch_all(&self.pool)
+        .await
+    }
+
+    pub async fn get_tasks_by_address(
+        &self,
+        address: &str,
+        limit: i64,
+    ) -> Result<Vec<Receipt>, sqlx::Error> {
+        sqlx::query_as::<_, Receipt>(
+            "SELECT status,merkle_path,nonce,address FROM tasks
                 WHERE address = $1
                 LIMIT $2",
-                )
-                .bind(addr.to_lowercase())
-                .bind(limit)
-                .fetch_all(&self.pool)
-                .await
-            }
-            _ => {
-                sqlx::query_as::<_, Receipt>(
-                    "SELECT status,merkle_path,nonce,address FROM tasks
-                LIMIT $1",
-                )
-                .bind(limit)
-                .fetch_all(&self.pool)
-                .await
-            }
-        }
+        )
+        .bind(address.to_lowercase())
+        .bind(limit)
+        .fetch_all(&self.pool)
+        .await
     }
 
     pub async fn insert_task(

aggregation_mode/batcher/src/server/http.rs

@@ -186,26 +186,45 @@ impl BatcherServer {
 
         let state = state.get_ref();
 
-        if params.address.is_none() && params.nonce.is_some() {
-            return HttpResponse::BadRequest().json(AppResponse::new_unsucessfull(
-                "Bad request: Cannot specify nonce without address",
-                400,
-            ));
-        }
+        let Some(address) = params.address.clone() else {
+            return HttpResponse::BadRequest()
+                .json(AppResponse::new_unsucessfull("Missing address", 400));
+        };
 
         // TODO: maybe also accept proof commitment in query param
-        let db_result = state
-            .db
-            .get_tasks_by_address_and_nonce(params.address.as_deref(), params.nonce, 100)
-            .await;
-        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,
-                ));
+        let receipts = if let Some(nonce) = params.nonce {
+            match state
+                .db
+                .get_tasks_by_address_and_nonce(&address, nonce)
+                .await
+            {
+                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,
+                        ),
+                    );
+                }
+            }
+        } else {
+            match state.db.get_tasks_by_address(&address, 100).await {
+                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,
+                        ),
+                    );
+                }
             }
         };