feat: nonce endpoint

Author: MarcosNicolau

Makefile

@@ -308,6 +308,9 @@ agg_mode_docker_up:
 agg_mode_docker_down:
 	@cd aggregation_mode && docker-compose down
 
+agg_mode_docker_clean: agg_mode_docker_down
+	docker volume rm aggregation-mode_postgres_data
+
 agg_mode_run_migrations: agg_mode_docker_up
 	cargo run --manifest-path ./aggregation_mode/Cargo.toml --release --bin migrate -- postgres://postgres:postgres@localhost:5435/
 

aggregation_mode/batcher/src/db.rs

@@ -20,4 +20,14 @@ 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)
+                .fetch_one(&self.pool)
+                .await?;
+
+        Ok(count)
+    }
 }

aggregation_mode/batcher/src/main.rs

@@ -1,7 +1,8 @@
 use std::env;
 
 use agg_mode_batcher::config::Config;
-use agg_mode_batcher::{db::Db, server::BatcherServer};
+use agg_mode_batcher::{db::Db, server::http::BatcherServer};
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
 fn read_config_filepath_from_args() -> String {
     let args: Vec<String> = env::args().collect();
@@ -17,6 +18,10 @@ fn read_config_filepath_from_args() -> String {
 
 #[actix_web::main]
 async fn main() {
+    let filter = EnvFilter::new("info,sp1_cuda=warn");
+    let subscriber = FmtSubscriber::builder().with_env_filter(filter).finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
     let config_file_path = read_config_filepath_from_args();
     tracing::info!("Loading config from {}...", config_file_path);
     let config = Config::from_file(&config_file_path).expect("Config is valid");
@@ -25,7 +30,9 @@ async fn main() {
     let db = Db::try_new(&config.db_connection_url)
         .await
         .expect("db to start");
-    let http_server = BatcherServer::new(db.clone(), config);
 
+    let http_server = BatcherServer::new(db.clone(), config.clone());
+
+    tracing::info!("Starting server at port {}", config.port);
     http_server.start().await.expect("Server to keep running");
 }

aggregation_mode/batcher/src/server.rs

@@ -0,0 +1,77 @@
+use actix_web::{
+    web::{self, Data},
+    App, HttpRequest, HttpResponse, HttpServer, Responder,
+};
+
+use super::types::AppResponse;
+
+use crate::{config::Config, db::Db};
+
+#[derive(Clone, Debug)]
+pub struct BatcherServer {
+    db: Db,
+    config: Config,
+}
+
+impl BatcherServer {
+    pub fn new(db: Db, config: Config) -> Self {
+        Self { db, config }
+    }
+
+    pub async fn start(&self) -> Result<(), std::io::Error> {
+        // Note: BatcherServer is thread safe so we can just clone it (no need to add mutexes)
+        let port = self.config.port;
+        let state = self.clone();
+
+        HttpServer::new(move || {
+            App::new()
+                .app_data(Data::new(state.clone()))
+                .route("/nonce/{address}", web::get().to(Self::get_nonce))
+                .route(
+                    "/proof/merkle/:receipt",
+                    web::get().to(Self::get_proof_merkle_path),
+                )
+                .route("/proof", web::post().to(Self::post_proof))
+        })
+        .bind(("127.0.0.1", port))?
+        .run()
+        .await
+    }
+
+    async fn get_nonce(req: HttpRequest) -> impl Responder {
+        let Some(address) = req.match_info().get("address") else {
+            return HttpResponse::BadRequest()
+                .json(AppResponse::new_unsucessfull("Missing address", 400));
+        };
+
+        // TODO: validate valid ethereum address
+
+        let Some(state) = req.app_data::<Data<BatcherServer>>() else {
+            return HttpResponse::InternalServerError()
+                .json(AppResponse::new_unsucessfull("Internal server error", 500));
+        };
+
+        let state = state.get_ref();
+        match state.db.count_proofs_by_address(address).await {
+            Ok(count) => HttpResponse::Ok().json(AppResponse::new_sucessfull(serde_json::json!(
+                {
+                    "nonce": count
+                }
+            ))),
+            Err(err) => {
+                tracing::error!(error = ?err, "failed to count proofs");
+                HttpResponse::InternalServerError().finish()
+            }
+        }
+    }
+
+    // TODO: receive the proof and 1. decode it, 2. verify it, 3. add to the db
+    async fn post_proof(req: HttpRequest) -> impl Responder {
+        HttpResponse::Ok()
+    }
+
+    // TODO: get the proof merkle path for the receipt id (proof commitment)
+    async fn get_proof_merkle_path(req: HttpRequest) -> impl Responder {
+        HttpResponse::Ok()
+    }
+}

aggregation_mode/batcher/src/server/http.rs

@@ -0,0 +1,2 @@
+pub mod http;
+mod types;

aggregation_mode/batcher/src/server/mod.rs

@@ -0,0 +1,27 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Serialize, Deserialize)]
+pub(super) struct AppResponse {
+    status: u16,
+    message: String,
+    data: Value,
+}
+
+impl AppResponse {
+    pub(super) fn new_sucessfull(data: Value) -> Self {
+        Self {
+            status: 200,
+            message: "Ok".to_string(),
+            data,
+        }
+    }
+
+    pub(super) fn new_unsucessfull(message: &str, status: u16) -> Self {
+        Self {
+            status,
+            message: message.to_string(),
+            data: serde_json::json!({}),
+        }
+    }
+}

aggregation_mode/batcher/src/server/types.rs

@@ -13,6 +13,7 @@ CREATE TABLE proofs (
     proof BYTEA,
     public_inputs BYTEA,
     proof_commitment BYTEA,
+    merkle_path BYTEA,
     task_id UUID REFERENCES tasks(task_id)
 );
 

aggregation_mode/db/migrations/001_init.sql

@@ -1,3 +1,3 @@
 port: 8089
-db_connection_url: "postgres://postgres:postgres@localhost/"
+db_connection_url: "postgres://postgres:postgres@localhost:5435/"
 eth_rpc_url: "http://localhost:8545"