feat: cli to send signed proofs

Author: MarcosNicolau

aggregation_mode/Cargo.lock

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["./batcher", "./proof_aggregator", "./db", "./sdk"]
+members = ["./batcher", "./proof_aggregator", "./db", "./sdk", "./cli"]
 
 [workspace.package]
 version = "0.1.0"

aggregation_mode/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "agg_mode_cli"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde =  { workspace = true }
+tracing = { version = "0.1", features = ["log"] }
+tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
+bincode = "1.3.3"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "time"] }
+alloy = { workspace = true }
+agg_mode_sdk = { path = "../sdk"}
+sp1-sdk = "5.0.0"
+clap = { version = "4.5.4", features = ["derive"] }

aggregation_mode/cli/Cargo.toml

@@ -0,0 +1 @@
+pub mod submit;

aggregation_mode/cli/src/commands/mod.rs

@@ -0,0 +1,70 @@
+use agg_mode_sdk::{gateway::provider::AggregationModeGatewayProvider, types::Network};
+use alloy::signers::local::LocalSigner;
+use clap::{command, Args, Subcommand};
+use sp1_sdk::{SP1ProofWithPublicValues, SP1VerifyingKey};
+use std::{path::PathBuf, str::FromStr};
+
+#[derive(Debug, Subcommand)]
+pub enum SubmitCommand {
+    #[command(name = "sp1")]
+    SP1(SubmitSP1Args),
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct SubmitSP1Args {
+    #[arg(short = 'p', long = "proof")]
+    proof_path: PathBuf,
+    #[arg(long = "vk")]
+    verifying_key_path: PathBuf,
+    #[arg(long = "private-key")]
+    private_key: String,
+    #[arg(short = 'n', long = "network", default_value = "devnet", value_parser = parse_network)]
+    network: Network,
+}
+
+fn parse_network(value: &str) -> Result<Network, String> {
+    Network::from_str(value).map_err(|_| format!("unsupported network supplied: {value}"))
+}
+
+pub async fn run(args: SubmitSP1Args) {
+    tracing::info!("Submitting SP1 proof to {:?} ", args.network);
+
+    let proof = load_proof(&args.proof_path).expect("Valid proof");
+    let vk = load_vk(&args.verifying_key_path).expect("Valid vk");
+
+    let signer =
+        LocalSigner::from_str(args.private_key.trim()).expect("failed to parse private key: {e}");
+
+    let provider = AggregationModeGatewayProvider::new_with_signer(args.network.clone(), signer)
+        .expect("failed to initialize gateway client: {e:?}");
+
+    let response = provider
+        .submit_sp1_proof(&proof, &vk)
+        .await
+        .expect("failed to submit proof: {e:?}");
+
+    tracing::info!(
+        "Proof submitted successfully. Task ID: {}",
+        response.data.task_id
+    );
+}
+
+fn load_proof(path: &PathBuf) -> Result<SP1ProofWithPublicValues, String> {
+    let bytes = std::fs::read(path)
+        .map_err(|e| format!("failed to read proof from {}: {e}", path.display()))?;
+
+    bincode::deserialize(&bytes)
+        .map_err(|e| format!("failed to deserialize proof {}: {e}", path.display()))
+}
+
+fn load_vk(path: &PathBuf) -> Result<SP1VerifyingKey, String> {
+    let bytes = std::fs::read(path)
+        .map_err(|e| format!("failed to read verifying key from {}: {e}", path.display()))?;
+
+    bincode::deserialize(&bytes).map_err(|e| {
+        format!(
+            "failed to deserialize verifying key {}: {e}",
+            path.display()
+        )
+    })
+}

aggregation_mode/cli/src/commands/submit.rs

@@ -0,0 +1 @@
+pub mod commands;

aggregation_mode/cli/src/lib.rs

@@ -0,0 +1,30 @@
+use agg_mode_cli::commands::{self, submit::SubmitCommand};
+use clap::{Parser, Subcommand};
+use tracing_subscriber::{EnvFilter, FmtSubscriber};
+
+#[derive(Debug, Parser)]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Debug, Subcommand)]
+enum Command {
+    #[command(subcommand)]
+    Submit(SubmitCommand),
+}
+
+#[tokio::main]
+async fn main() {
+    let filter = EnvFilter::new("info");
+    let subscriber = FmtSubscriber::builder().with_env_filter(filter).finish();
+    tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    let cli = Cli::parse();
+
+    match cli.command {
+        Command::Submit(subcommand) => match subcommand {
+            SubmitCommand::SP1(args) => commands::submit::run(args).await,
+        },
+    };
+}

aggregation_mode/cli/src/main.rs

@@ -5,7 +5,7 @@ use sp1_sdk::{SP1ProofWithPublicValues, SP1VerifyingKey};
 
 use crate::{
     gateway::types::{
-        GatewayResponse, NonceResponse, Receipt, ReceiptsQueryParams, ReceiptsResponse,
+        EmptyData, GatewayResponse, NonceResponse, Receipt, ReceiptsQueryParams,
         SubmitProofResponse, SubmitSP1ProofMessage,
     },
     types::Network,
@@ -56,18 +56,19 @@ impl<S: Signer> AggregationModeGatewayProvider<S> {
         &self.gateway_url
     }
 
-    pub async fn get_nonce_for(&self, address: String) -> Result<u64, GatewayError> {
+    pub async fn get_nonce_for(
+        &self,
+        address: String,
+    ) -> Result<GatewayResponse<NonceResponse>, GatewayError> {
         let url = format!("{}/nonce/{}", self.gateway_url, address);
-        let response: NonceResponse = self.send_request(self.http_client.get(url)).await?;
-
-        Ok(response.nonce)
+        self.send_request(self.http_client.get(url)).await
     }
 
     pub async fn get_receipts_for(
         &self,
         address: String,
         nonce: Option<u64>,
-    ) -> Result<Vec<Receipt>, GatewayError> {
+    ) -> Result<GatewayResponse<Vec<Receipt>>, GatewayError> {
         let query = ReceiptsQueryParams {
             address: address,
             nonce,
@@ -78,16 +79,14 @@ impl<S: Signer> AggregationModeGatewayProvider<S> {
             .get(format!("{}/receipts", self.gateway_url))
             .query(&query);
 
-        let response: ReceiptsResponse = self.send_request(request).await?;
-
-        Ok(response.receipts)
+        self.send_request(request).await
     }
 
     pub async fn submit_sp1_proof(
         &self,
         proof: &SP1ProofWithPublicValues,
         vk: &SP1VerifyingKey,
-    ) -> Result<SubmitProofResponse, GatewayError> {
+    ) -> Result<GatewayResponse<SubmitProofResponse>, GatewayError> {
         let serialized_proof = bincode::serialize(proof)
             .map_err(|e| GatewayError::ProofSerialization(e.to_string()))?;
         let serialized_vk =
@@ -97,11 +96,12 @@ impl<S: Signer> AggregationModeGatewayProvider<S> {
             return Err(GatewayError::SignerNotConfigured);
         };
         let signer_address = signer.address().to_string();
-        let nonce = self.get_nonce_for(signer_address).await?;
-        let message = SubmitSP1ProofMessage::new(nonce, serialized_proof, serialized_vk)
-            .sign(signer, &self.network)
-            .await
-            .map_err(|e| GatewayError::MessageSignature(e))?;
+        let nonce_response = self.get_nonce_for(signer_address).await?;
+        let message =
+            SubmitSP1ProofMessage::new(nonce_response.data.nonce, serialized_proof, serialized_vk)
+                .sign(signer, &self.network)
+                .await
+                .map_err(|e| GatewayError::MessageSignature(e))?;
 
         let form = multipart::Form::new()
             .text("nonce", message.nonce.to_string())
@@ -128,24 +128,29 @@ impl<S: Signer> AggregationModeGatewayProvider<S> {
     async fn send_request<T: DeserializeOwned>(
         &self,
         request: reqwest::RequestBuilder,
-    ) -> Result<T, GatewayError> {
+    ) -> Result<GatewayResponse<T>, GatewayError> {
         let response = request
             .send()
             .await
             .map_err(|e| GatewayError::Request(e.to_string()))?;
 
-        let payload: GatewayResponse<T> = response
-            .json()
-            .await
-            .map_err(|e| GatewayError::Request(e.to_string()))?;
+        if !(200..300).contains(&response.status().as_u16()) {
+            let payload: GatewayResponse<EmptyData> = response
+                .json()
+                .await
+                .map_err(|e| GatewayError::Request(e.to_string()))?;
 
-        if payload.status != 200 {
             return Err(GatewayError::Api {
                 status: payload.status,
                 message: payload.message,
             });
         }
 
-        Ok(payload.data)
+        let payload: GatewayResponse<T> = response
+            .json()
+            .await
+            .map_err(|e| GatewayError::Request(e.to_string()))?;
+
+        Ok(payload)
     }
 }

aggregation_mode/sdk/src/gateway/provider.rs

@@ -8,14 +8,17 @@ use serde::{Deserialize, Serialize};
 use crate::types::Network;
 
 #[derive(Debug, Deserialize)]
-pub(super) struct GatewayResponse<T> {
+pub struct GatewayResponse<T> {
     pub status: u16,
     pub message: String,
     pub data: T,
 }
 
 #[derive(Debug, Deserialize)]
-pub(super) struct NonceResponse {
+pub(super) struct EmptyData {}
+
+#[derive(Debug, Deserialize)]
+pub struct NonceResponse {
     pub nonce: u64,
 }