refactor: agg mode (#1871)

Author: MarcosNicolau

aggregation_mode/aggregation_programs/sp1/src/lib.rs

@@ -2,37 +2,37 @@ use serde::{Deserialize, Serialize};
 use sha3::{Digest, Keccak256};
 
 #[derive(Serialize, Deserialize)]
-pub struct SP1ProofInput {
+pub struct SP1VkAndPubInputs {
     pub vk: [u32; 8],
     pub public_inputs: Vec<u8>,
 }
 
-impl SP1ProofInput {
+impl SP1VkAndPubInputs {
     pub fn hash(&self) -> [u8; 32] {
         let mut hasher = Keccak256::new();
         for &word in &self.vk {
-            hasher.update(word.to_le_bytes());
+            hasher.update(word.to_be_bytes());
         }
         hasher.update(&self.public_inputs);
         hasher.finalize().into()
     }
 }
 
 #[derive(Serialize, Deserialize)]
-pub enum ProofInput {
-    SP1Compressed(SP1ProofInput),
+pub enum ProofVkAndPubInputs {
+    SP1Compressed(SP1VkAndPubInputs),
 }
 
-impl ProofInput {
+impl ProofVkAndPubInputs {
     pub fn hash(&self) -> [u8; 32] {
         match self {
-            ProofInput::SP1Compressed(proof) => proof.hash(),
+            ProofVkAndPubInputs::SP1Compressed(proof_data) => proof_data.hash(),
         }
     }
 }
 
 #[derive(Serialize, Deserialize)]
 pub struct Input {
-    pub proofs: Vec<ProofInput>,
+    pub proofs_vk_and_pub_inputs: Vec<ProofVkAndPubInputs>,
     pub merkle_root: [u8; 32],
 }

aggregation_mode/aggregation_programs/sp1/src/main.rs

@@ -3,7 +3,7 @@ sp1_zkvm::entrypoint!(main);
 
 use sha2::{Digest, Sha256};
 use sha3::Keccak256;
-use sp1_aggregation_program::{Input, ProofInput};
+use sp1_aggregation_program::{Input, ProofVkAndPubInputs};
 
 fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
     let mut hasher = Keccak256::new();
@@ -13,7 +13,7 @@ fn combine_hashes(hash_a: &[u8; 32], hash_b: &[u8; 32]) -> [u8; 32] {
 }
 
 /// Computes the merkle root for the given proofs using the vk
-fn compute_merkle_root(proofs: &[ProofInput]) -> [u8; 32] {
+fn compute_merkle_root(proofs: &[ProofVkAndPubInputs]) -> [u8; 32] {
     let mut leaves: Vec<[u8; 32]> = proofs
         .chunks(2)
         .map(|chunk| match chunk {
@@ -41,9 +41,9 @@ pub fn main() {
     let input = sp1_zkvm::io::read::<Input>();
 
     // Verify the proofs.
-    for proof in input.proofs.iter() {
+    for proof in input.proofs_vk_and_pub_inputs.iter() {
         match proof {
-            ProofInput::SP1Compressed(proof) => {
+            ProofVkAndPubInputs::SP1Compressed(proof) => {
                 let vkey = proof.vk;
                 let public_values = &proof.public_inputs;
                 let public_values_digest = Sha256::digest(public_values);
@@ -52,7 +52,7 @@ pub fn main() {
         }
     }
 
-    let merkle_root = compute_merkle_root(&input.proofs);
+    let merkle_root = compute_merkle_root(&input.proofs_vk_and_pub_inputs);
 
     assert_eq!(merkle_root, input.merkle_root);
 

aggregation_mode/src/aggregators/sp1_aggregator.rs

@@ -1,7 +1,7 @@
 use std::sync::LazyLock;
 
 use alloy::primitives::Keccak256;
-use sp1_aggregation_program::{ProofInput, SP1ProofInput};
+use sp1_aggregation_program::{ProofVkAndPubInputs, SP1VkAndPubInputs};
 use sp1_sdk::{
     EnvProver, HashableKey, Prover, ProverClient, SP1ProofWithPublicValues, SP1Stdin,
     SP1VerifyingKey,
@@ -22,9 +22,8 @@ pub struct SP1ProofWithPubValuesAndElf {
 impl SP1ProofWithPubValuesAndElf {
     pub fn hash_vk_and_pub_inputs(&self) -> [u8; 32] {
         let mut hasher = Keccak256::new();
-        for &word in &self.vk().hash_u32() {
-            hasher.update(word.to_le_bytes());
-        }
+        let vk_bytes = &self.vk().hash_bytes();
+        hasher.update(vk_bytes);
         hasher.update(self.proof_with_pub_values.public_values.as_slice());
         hasher.finalize().into()
     }
@@ -45,15 +44,15 @@ pub(crate) fn aggregate_proofs(
     let mut stdin = SP1Stdin::new();
 
     let mut program_input = sp1_aggregation_program::Input {
-        proofs: vec![],
+        proofs_vk_and_pub_inputs: vec![],
         merkle_root: input.merkle_root,
     };
 
     // write vk + public inputs
     for proof in input.proofs.iter() {
         program_input
-            .proofs
-            .push(ProofInput::SP1Compressed(SP1ProofInput {
+            .proofs_vk_and_pub_inputs
+            .push(ProofVkAndPubInputs::SP1Compressed(SP1VkAndPubInputs {
                 public_inputs: proof.proof_with_pub_values.public_values.to_vec(),
                 vk: proof.vk().hash_u32(),
             }));

aggregation_mode/src/backend/fetcher.rs

@@ -17,8 +17,8 @@ use tracing::{error, info};
 
 #[derive(Debug)]
 pub enum ProofsFetcherError {
-    QueryingLogs,
-    BlockNumber,
+    GetLogs(String),
+    GetBlockNumber(String),
 }
 
 pub struct ProofsFetcher {
@@ -59,7 +59,7 @@ impl ProofsFetcher {
             .from_block(from_block)
             .query()
             .await
-            .map_err(|_| ProofsFetcherError::QueryingLogs)?;
+            .map_err(|e| ProofsFetcherError::GetLogs(e.to_string()))?;
 
         info!("Logs collected {}", logs.len());
 
@@ -124,7 +124,7 @@ impl ProofsFetcher {
             .rpc_provider
             .get_block_number()
             .await
-            .map_err(|_| ProofsFetcherError::BlockNumber)?;
+            .map_err(|e| ProofsFetcherError::GetBlockNumber(e.to_string()))?;
 
         let number_of_blocks_in_the_past = self.fetch_from_secs_ago / self.block_time_secs;
 

aggregation_mode/src/backend/s3.rs

@@ -1,12 +1,13 @@
 use aligned_sdk::core::types::VerificationData;
 
 #[derive(Debug)]
+#[allow(dead_code)]
 pub enum GetBatchProofsError {
-    Fetching,
-    Deserialization,
-    EmptyBody,
-    StatusFailed,
-    ReqwestClientFailed,
+    FetchingS3Batch(String),
+    Deserialization(String),
+    EmptyBody(String),
+    StatusFailed((u16, String)),
+    ReqwestClientFailed(String),
 }
 
 // needed to make S3 bucket work
@@ -18,25 +19,32 @@ pub async fn get_aligned_batch_from_s3(
     let client = reqwest::Client::builder()
         .user_agent(DEFAULT_USER_AGENT)
         .build()
-        .map_err(|_| GetBatchProofsError::ReqwestClientFailed)?;
+        .map_err(|e| GetBatchProofsError::ReqwestClientFailed(e.to_string()))?;
 
     let response = client
         .get(url)
         .send()
         .await
-        .map_err(|_| GetBatchProofsError::Fetching)?;
+        .map_err(|e| GetBatchProofsError::FetchingS3Batch(e.to_string()))?;
     if !response.status().is_success() {
-        return Err(GetBatchProofsError::StatusFailed);
+        return Err(GetBatchProofsError::StatusFailed((
+            response.status().as_u16(),
+            response
+                .status()
+                .canonical_reason()
+                .unwrap_or("")
+                .to_string(),
+        )));
     }
 
     let bytes = response
         .bytes()
         .await
-        .map_err(|_| GetBatchProofsError::EmptyBody)?;
+        .map_err(|e| GetBatchProofsError::EmptyBody(e.to_string()))?;
     let bytes: &[u8] = bytes.iter().as_slice();
 
-    let data: Vec<VerificationData> =
-        ciborium::from_reader(bytes).map_err(|_| GetBatchProofsError::Deserialization)?;
+    let data: Vec<VerificationData> = ciborium::from_reader(bytes)
+        .map_err(|e| GetBatchProofsError::Deserialization(e.to_string()))?;
 
     Ok(data)
 }