feat: include vk and public inputs in args

this way we users don't need to know the internals of the agg_mode proof commitment which is still unstable

Author: MarcosNicolau

batcher/aligned-sdk/src/agg_mode.rs

@@ -6,12 +6,34 @@ use ethers::{
     providers::{Http, Middleware, Provider},
     types::Filter,
 };
+use log::warn;
 use sha3::{Digest, Keccak256};
 
 /// How much to go back from current block if from_block is not provided
 /// 7500 blocks = 25hr
 const FROM_BLOCKS_AGO_DEFAULT: u64 = 7500;
 
+#[derive(Debug)]
+pub enum ProofData {
+    SP1 {
+        vk: [u8; 32],
+        public_inputs: Vec<u8>,
+    },
+}
+
+impl ProofData {
+    fn commitment(&self) -> [u8; 32] {
+        match self {
+            ProofData::SP1 { vk, public_inputs } => {
+                let mut hasher = Keccak256::new();
+                hasher.update(vk);
+                hasher.update(public_inputs);
+                hasher.finalize().into()
+            }
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum ProofVerificationAggModeError {
     ProvingSystemNotSupportedInAggMode,
@@ -41,7 +63,7 @@ pub enum ProofVerificationAggModeError {
 /// 6. Checking if the given proof hash exists within the blob’s proofs
 /// 7. Reconstructing the Merkle root and verifying it against the commitment stored in the contract
 pub async fn is_proof_verified_in_aggregation_mode(
-    proof_hash: [u8; 32],
+    proof_data: ProofData,
     network: Network,
     eth_rpc_url: String,
     beacon_client_url: String,
@@ -114,10 +136,10 @@ pub async fn is_proof_verified_in_aggregation_mode(
         };
 
         let blob_data = hex::decode(blob.blob.replace("0x", "")).expect("A valid hex encoded data");
-        let proof_hashes = decoded_blob(blob_data);
+        let proof_commitments = decoded_blob(blob_data);
 
-        if proof_hashes.contains(&proof_hash) {
-            if verify_blob_merkle_root(proof_hashes, merkle_root) {
+        if proof_commitments.contains(&proof_data.commitment()) {
+            if verify_blob_merkle_root(proof_commitments, merkle_root) {
                 return Ok(merkle_root);
             } else {
                 return Err(ProofVerificationAggModeError::UnmatchedBlobAndEventMerkleRoot);
@@ -171,9 +193,9 @@ pub fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
     hasher.finalize().into()
 }
 
-fn verify_blob_merkle_root(mut proof_hashes: Vec<[u8; 32]>, merkle_root: [u8; 32]) -> bool {
-    while proof_hashes.len() > 1 {
-        proof_hashes = proof_hashes
+fn verify_blob_merkle_root(mut commitments: Vec<[u8; 32]>, merkle_root: [u8; 32]) -> bool {
+    while commitments.len() > 1 {
+        commitments = commitments
             .chunks(2)
             .map(|chunk| match chunk {
                 [a, b] => combine_hashes(a, b),
@@ -183,5 +205,5 @@ fn verify_blob_merkle_root(mut proof_hashes: Vec<[u8; 32]>, merkle_root: [u8; 32
             .collect()
     }
 
-    proof_hashes[0] == merkle_root
+    commitments[0] == merkle_root
 }

batcher/aligned/src/main.rs

@@ -6,6 +6,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 
 use aligned_sdk::agg_mode;
+use aligned_sdk::agg_mode::ProofData;
 use aligned_sdk::communication::serialization::cbor_deserialize;
 use aligned_sdk::core::types::FeeEstimationType;
 use aligned_sdk::core::{
@@ -294,15 +295,19 @@ pub struct VerifyProofInAggModeArgs {
     eth_rpc_url: String,
     #[arg(name = "Ethereum Beacon client url", long = "beacon_url")]
     beacon_client_url: String,
-    #[arg(name = "Proof commitment", long = "proof-commitment")]
-    proof_commitment: String,
     #[clap(flatten)]
     network: NetworkArg,
     #[arg(
         name = "From which block to start, if not provided it defaults to fetch logs from the past 25hs",
         long = "from-block"
     )]
     from_block: Option<u64>,
+    #[arg(name = "Proving system", long = "proving_system")]
+    proving_system: ProvingSystemArg,
+    #[arg(name = "Public input file name", long = "public_input")]
+    pub_input_file_name: Option<PathBuf>,
+    #[arg(name = "Verification key hash", long = "vk")]
+    verification_key_hash: Option<PathBuf>,
 }
 
 #[derive(Args, Debug)]
@@ -758,13 +763,32 @@ async fn main() -> Result<(), AlignedError> {
             return Ok(());
         }
         AlignedCommands::VerifyProofInAggMode(args) => {
-            let proof_hash_bytes: [u8; 32] = hex::decode(args.proof_commitment.replace("0x", ""))
-                .expect("Proof to be a valid hex encoded hash")
-                .try_into()
-                .expect("Proof be raw bytes to be of len 32");
+            let proof_data = match args.proving_system {
+                ProvingSystemArg::SP1 => {
+                    let Some(vk_hash) = args.verification_key_hash else {
+                        error!("VK hash is necessary for sp1");
+                        return Ok(());
+                    };
+                    let vk = read_file(vk_hash)?
+                        .try_into()
+                        .expect("Invalid hexadecimal encoded vk hash");
+
+                    let Some(pub_inputs_file_name) = args.pub_input_file_name else {
+                        error!("Public input file not provided");
+                        return Ok(());
+                    };
+                    let public_inputs = read_file(pub_inputs_file_name)?;
+
+                    ProofData::SP1 { vk, public_inputs }
+                }
+                _ => {
+                    error!("Proving system not supported in aggregation mode");
+                    return Ok(());
+                }
+            };
 
             match agg_mode::is_proof_verified_in_aggregation_mode(
-                proof_hash_bytes,
+                proof_data,
                 args.network.into(),
                 args.eth_rpc_url,
                 args.beacon_client_url,