feat: submit and verify zisk proofs commands in cli

Author: MarcosNicolau

aggregation_mode/cli/src/commands/helpers.rs

@@ -1,16 +1,7 @@
-use clap::{self, ValueEnum};
 use std::str::FromStr;
 
 use agg_mode_sdk::types::Network;
 
 pub fn parse_network(value: &str) -> Result<Network, String> {
     Network::from_str(value).map_err(|_| format!("unsupported network supplied: {value}"))
 }
-
-#[derive(Debug, Clone, ValueEnum)]
-pub enum ProvingSystemArg {
-    #[clap(name = "SP1")]
-    SP1,
-    #[clap(name = "Risc0")]
-    Risc0,
-}

aggregation_mode/cli/src/commands/mod.rs

@@ -1,4 +1,4 @@
-use crate::commands::{deposit::SendPaymentArgs, submit::SubmitCommand, verify::VerifyOnChainArgs};
+use crate::commands::{deposit::SendPaymentArgs, submit::SubmitCommand, verify::VerifyCommand};
 use clap::{Parser, Subcommand};
 
 pub mod deposit;
@@ -17,8 +17,8 @@ pub enum Command {
     #[command(subcommand)]
     Submit(SubmitCommand),
     /// Check whether a proof has been verified on AlignedProofAggregationService contract
-    #[command(name = "verify-on-chain")]
-    VerifyOnChain(VerifyOnChainArgs),
+    #[command(subcommand, name = "verify-on-chain")]
+    VerifyOnChain(VerifyCommand),
     /// Send 1 ether to the aggregation mode payment service
     #[command(name = "deposit")]
     Deposit(SendPaymentArgs),

aggregation_mode/cli/src/commands/submit.rs

@@ -10,6 +10,8 @@ use crate::commands::helpers::parse_network;
 pub enum SubmitCommand {
     #[command(name = "sp1")]
     SP1(SubmitSP1Args),
+    #[command(name = "zisk")]
+    Zisk(SubmitZiskArgs),
 }
 
 #[derive(Debug, Clone, Args)]
@@ -24,11 +26,21 @@ pub struct SubmitSP1Args {
     network: Network,
 }
 
-pub async fn run(args: SubmitSP1Args) {
+#[derive(Debug, Clone, Args)]
+pub struct SubmitZiskArgs {
+    #[arg(short = 'p', long = "proof")]
+    proof_path: PathBuf,
+    #[arg(long = "private-key")]
+    private_key: String,
+    #[arg(short = 'n', long = "network", default_value = "devnet", value_parser = parse_network)]
+    network: Network,
+}
+
+pub async fn run_sp1(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 proof = load_sp1_proof(&args.proof_path).expect("Valid proof");
+    let vk = load_sp1_vk(&args.verifying_key_path).expect("Valid vk");
 
     let signer =
         LocalSigner::from_str(args.private_key.trim()).expect("failed to parse private key: {e}");
@@ -47,15 +59,38 @@ pub async fn run(args: SubmitSP1Args) {
     );
 }
 
-fn load_proof(path: &PathBuf) -> Result<SP1ProofWithPublicValues, String> {
+pub async fn run_zisk(args: SubmitZiskArgs) {
+    tracing::info!("Submitting Zisk proof to {:?} ", args.network);
+
+    let proof = std::fs::read(&args.proof_path)
+        .expect(&format!("failed to read proof from {}", args.proof_path.display()));
+
+    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_zisk_proof(&proof)
+        .await
+        .expect("failed to submit proof: {e:?}");
+
+    tracing::info!(
+        "Proof submitted successfully. Task ID: {}",
+        response.data.task_id
+    );
+}
+
+fn load_sp1_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> {
+fn load_sp1_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()))?;
 

aggregation_mode/cli/src/commands/verify.rs

@@ -5,13 +5,23 @@ use agg_mode_sdk::{
     types::Network,
 };
 use alloy::hex;
-use clap::{self, Args};
+use clap::{command, Args, Subcommand};
 use std::path::PathBuf;
 
-use crate::commands::helpers::{parse_network, ProvingSystemArg};
+use crate::commands::helpers::parse_network;
+
+#[derive(Debug, Subcommand)]
+pub enum VerifyCommand {
+    #[command(name = "sp1")]
+    SP1(VerifySP1Args),
+    #[command(name = "risc0")]
+    Risc0(VerifyRisc0Args),
+    #[command(name = "zisk")]
+    Zisk(VerifyZiskArgs),
+}
 
 #[derive(Debug, Clone, Args)]
-pub struct VerifyOnChainArgs {
+pub struct VerifySP1Args {
     #[arg(short = 'n', long = "network", default_value = "devnet", value_parser = parse_network)]
     network: Network,
     #[arg(long = "rpc-url")]
@@ -20,41 +30,93 @@ pub struct VerifyOnChainArgs {
     beacon_url: String,
     #[arg(long = "from-block")]
     from_block: Option<u64>,
-    #[arg(long = "proving-system")]
-    proving_system: ProvingSystemArg,
-    #[arg(
-        name = "Program verification key hash",
-        long = "vk-hash",
-        required = true
-    )]
-    program_vk: PathBuf,
-    #[arg(name = "Public input file name", long = "public-inputs")]
-    pub_input_file_name: Option<PathBuf>,
+    #[arg(long = "vk-hash")]
+    vk_hash: PathBuf,
+    #[arg(long = "public-inputs")]
+    public_inputs: PathBuf,
 }
 
-pub async fn run(args: VerifyOnChainArgs) {
-    let program_id_key: [u8; 32] = std::fs::read(&args.program_vk)
-        .expect("to read program vk file")
+#[derive(Debug, Clone, Args)]
+pub struct VerifyRisc0Args {
+    #[arg(short = 'n', long = "network", default_value = "devnet", value_parser = parse_network)]
+    network: Network,
+    #[arg(long = "rpc-url")]
+    rpc_url: String,
+    #[arg(long = "beacon-url")]
+    beacon_url: String,
+    #[arg(long = "from-block")]
+    from_block: Option<u64>,
+    #[arg(long = "image-id")]
+    image_id: PathBuf,
+    #[arg(long = "public-inputs")]
+    public_inputs: PathBuf,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct VerifyZiskArgs {
+    #[arg(short = 'n', long = "network", default_value = "devnet", value_parser = parse_network)]
+    network: Network,
+    #[arg(long = "rpc-url")]
+    rpc_url: String,
+    #[arg(long = "beacon-url")]
+    beacon_url: String,
+    #[arg(long = "from-block")]
+    from_block: Option<u64>,
+    #[arg(short = 'p', long = "proof")]
+    proof: PathBuf,
+}
+
+pub async fn run_sp1(args: VerifySP1Args) {
+    tracing::info!("Verifying SP1 proof on {:?}...", args.network);
+
+    let vk: [u8; 32] = std::fs::read(&args.vk_hash)
+        .expect("to read vk hash file")
         .try_into()
-        .expect("Invalid hexadecimal encoded vk hash");
+        .expect("Invalid vk hash (expected 32 bytes)");
 
-    let Some(pub_inputs_file_name) = args.pub_input_file_name else {
-        tracing::error!("Public input file not provided");
-        return;
-    };
-    let public_inputs =
-        std::fs::read(&pub_inputs_file_name).expect("to read program public inputs file");
+    let public_inputs = std::fs::read(&args.public_inputs).expect("to read public inputs file");
 
-    let provider =
-        ProofAggregationServiceProvider::new(args.network, args.rpc_url, args.beacon_url);
+    let verification_data = AggregationModeVerificationData::SP1 { vk, public_inputs };
 
-    let verification_data = AggregationModeVerificationData::SP1 {
-        vk: program_id_key,
-        public_inputs,
-    };
+    verify_proof(args.network, args.rpc_url, args.beacon_url, args.from_block, verification_data).await;
+}
+
+pub async fn run_risc0(args: VerifyRisc0Args) {
+    tracing::info!("Verifying Risc0 proof on {:?}...", args.network);
+
+    let image_id: [u8; 32] = std::fs::read(&args.image_id)
+        .expect("to read image id file")
+        .try_into()
+        .expect("Invalid image id (expected 32 bytes)");
+
+    let public_inputs = std::fs::read(&args.public_inputs).expect("to read public inputs file");
+
+    let verification_data = AggregationModeVerificationData::Risc0 { image_id, public_inputs };
+
+    verify_proof(args.network, args.rpc_url, args.beacon_url, args.from_block, verification_data).await;
+}
+
+pub async fn run_zisk(args: VerifyZiskArgs) {
+    tracing::info!("Verifying Zisk proof on {:?}...", args.network);
+
+    let proof = std::fs::read(&args.proof).expect("to read proof file");
+
+    let verification_data = AggregationModeVerificationData::Zisk { proof };
+
+    verify_proof(args.network, args.rpc_url, args.beacon_url, args.from_block, verification_data).await;
+}
+
+async fn verify_proof(
+    network: Network,
+    rpc_url: String,
+    beacon_url: String,
+    from_block: Option<u64>,
+    verification_data: AggregationModeVerificationData,
+) {
+    let provider = ProofAggregationServiceProvider::new(network, rpc_url, beacon_url);
 
     let proof_status = match provider
-        .check_proof_verification(args.from_block, verification_data)
+        .check_proof_verification(from_block, verification_data)
         .await
     {
         Ok(res) => res,

aggregation_mode/cli/src/main.rs

@@ -1,4 +1,4 @@
-use agg_mode_cli::commands::{self, submit::SubmitCommand, Cli, Command};
+use agg_mode_cli::commands::{self, submit::SubmitCommand, verify::VerifyCommand, Cli, Command};
 use clap::Parser;
 use tracing_subscriber::{EnvFilter, FmtSubscriber};
 
@@ -12,9 +12,14 @@ async fn main() {
 
     match cli.command {
         Command::Submit(subcommand) => match subcommand {
-            SubmitCommand::SP1(args) => commands::submit::run(args).await,
+            SubmitCommand::SP1(args) => commands::submit::run_sp1(args).await,
+            SubmitCommand::Zisk(args) => commands::submit::run_zisk(args).await,
+        },
+        Command::VerifyOnChain(subcommand) => match subcommand {
+            VerifyCommand::SP1(args) => commands::verify::run_sp1(args).await,
+            VerifyCommand::Risc0(args) => commands::verify::run_risc0(args).await,
+            VerifyCommand::Zisk(args) => commands::verify::run_zisk(args).await,
         },
-        Command::VerifyOnChain(args) => commands::verify::run(args).await,
         Command::Deposit(args) => commands::deposit::run(args).await,
     };
 }

aggregation_mode/sdk/src/blockchain/types.rs

@@ -91,34 +91,25 @@ pub enum AggregationModeVerificationData {
         image_id: [u8; 32],
         public_inputs: Vec<u8>,
     },
+    Zisk {
+        proof: Vec<u8>,
+    },
 }
 
 impl AggregationModeVerificationData {
-    pub fn program_id(&self) -> [u8; 32] {
-        match self {
-            Self::Risc0 { image_id, .. } => *image_id,
-            Self::SP1 { vk, .. } => *vk,
-        }
-    }
-
-    pub fn public_inputs(&self) -> &Vec<u8> {
-        match self {
-            Self::Risc0 { public_inputs, .. } => public_inputs,
-            Self::SP1 { public_inputs, .. } => public_inputs,
-        }
-    }
-
     pub fn proving_system_id(&self) -> u16 {
         match self {
             Self::SP1 { .. } => AggregationModeProvingSystem::SP1.id(),
             Self::Risc0 { .. } => AggregationModeProvingSystem::RISC0.id(),
+            Self::Zisk { .. } => AggregationModeProvingSystem::ZISK.id(),
         }
     }
 
     pub fn proving_system_id_bytes(&self) -> [u8; 2] {
         match self {
             Self::SP1 { .. } => AggregationModeProvingSystem::SP1.id_bytes(),
             Self::Risc0 { .. } => AggregationModeProvingSystem::RISC0.id_bytes(),
+            Self::Zisk { .. } => AggregationModeProvingSystem::ZISK.id_bytes(),
         }
     }
 
@@ -141,6 +132,12 @@ impl AggregationModeVerificationData {
                 hasher.update(public_inputs);
                 hasher.finalize().into()
             }
+            AggregationModeVerificationData::Zisk { proof } => {
+                let mut hasher = Keccak256::new();
+                hasher.update(self.proving_system_id_bytes());
+                hasher.update(proof);
+                hasher.finalize().into()
+            }
         }
     }
 }