Merge branch 'staging' into feat/aggregation-mode-sdk

Author: MauroToscano

Makefile

@@ -143,14 +143,10 @@ lint_contracts:
 	@cd contracts && npm run lint:sol
 
 anvil_start:
-	@echo "Starting Anvil..."
-	anvil --load-state contracts/scripts/anvil/state/alignedlayer-deployed-anvil-state.json
-
-anvil_start_with_block_time:
 	@echo "Starting Anvil..."
 	anvil --load-state contracts/scripts/anvil/state/alignedlayer-deployed-anvil-state.json --block-time 7
 
-anvil_start_with_block_time_with_more_prefunded_accounts:
+anvil_start_with_more_prefunded_accounts:
 	@echo "Starting Anvil..."
 	anvil --load-state contracts/scripts/anvil/state/alignedlayer-deployed-anvil-state.json --block-time 7 -a 2000
 
@@ -1168,7 +1164,7 @@ setup_local_aligned_all:
 	tmux new-session -d -s aligned_layer
 
 	tmux new-window -t aligned_layer -n anvil
-	tmux send-keys -t aligned_layer 'make anvil_start_with_block_time' C-m
+	tmux send-keys -t aligned_layer 'make anvil_start' C-m
 
 	tmux new-window -t aligned_layer -n aggregator
 	tmux send-keys -t aligned_layer:aggregator 'make aggregator_start' C-m

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,14 +1,19 @@
+use std::sync::LazyLock;
+
 use alloy::primitives::Keccak256;
-use sp1_aggregation_program::{ProofInput, SP1ProofInput};
+use sp1_aggregation_program::{ProofVkAndPubInputs, SP1VkAndPubInputs};
 use sp1_sdk::{
-    HashableKey, Prover, ProverClient, SP1ProofWithPublicValues, SP1Stdin, SP1VerifyingKey,
+    EnvProver, HashableKey, Prover, ProverClient, SP1ProofWithPublicValues, SP1Stdin,
+    SP1VerifyingKey,
 };
 
 use super::lib::{AggregatedProof, ProgramOutput, ProofAggregationError};
 
 const PROGRAM_ELF: &[u8] =
     include_bytes!("../../aggregation_programs/sp1/elf/sp1_aggregator_program");
 
+static SP1_PROVER_CLIENT: LazyLock<EnvProver> = LazyLock::new(ProverClient::from_env);
+
 pub struct SP1ProofWithPubValuesAndElf {
     pub proof_with_pub_values: SP1ProofWithPublicValues,
     pub elf: Vec<u8>,
@@ -17,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()
     }
@@ -40,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(),
             }));
@@ -66,7 +70,7 @@ pub(crate) fn aggregate_proofs(
     }
 
     #[cfg(feature = "prove")]
-    let client = ProverClient::from_env();
+    let client = &*SP1_PROVER_CLIENT;
     // If not in prove mode, create a mock proof via mock client
     #[cfg(not(feature = "prove"))]
     let client = ProverClient::builder().mock().build();
@@ -102,7 +106,7 @@ pub enum AlignedSP1VerificationError {
 pub(crate) fn verify(
     sp1_proof_with_pub_values_and_elf: &SP1ProofWithPubValuesAndElf,
 ) -> Result<(), AlignedSP1VerificationError> {
-    let client = ProverClient::from_env();
+    let client = &*SP1_PROVER_CLIENT;
 
     let (_pk, vk) = client.setup(&sp1_proof_with_pub_values_and_elf.elf);
 
@@ -122,7 +126,7 @@ pub(crate) fn verify(
 }
 
 pub fn vk_from_elf(elf: &[u8]) -> SP1VerifyingKey {
-    let prover = ProverClient::builder().cpu().build();
+    let prover = &*SP1_PROVER_CLIENT;
     let (_, vk) = prover.setup(elf);
     vk
 }

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)
 }

alerts/sender_with_alert.sh

@@ -111,11 +111,11 @@ do
     --proof "./scripts/test_files/gnark_groth16_bn254_infinite_script/infinite_proofs/ineq_${x}_groth16.proof" \
     --public_input "./scripts/test_files/gnark_groth16_bn254_infinite_script/infinite_proofs/ineq_${x}_groth16.pub" \
     --vk "./scripts/test_files/gnark_groth16_bn254_infinite_script/infinite_proofs/ineq_${x}_groth16.vk" \
-    --proof_generator_addr $SENDER_ADDRESS \
     --private_key $PRIVATE_KEY \
     --rpc_url $RPC_URL \
     --network $NETWORK \
     --max_fee 0.004ether \
+    --random_address \
     2>&1)
 
   echo "$submit"

batcher/aligned-batcher/src/connection.rs

@@ -57,17 +57,16 @@ pub(crate) async fn send_batch_inclusion_data_responses(
 }
 
 pub(crate) async fn send_message<T: Serialize>(ws_conn_sink: WsMessageSink, message: T) {
-    match cbor_serialize(&message) {
-        Ok(serialized_response) => {
-            if let Err(err) = ws_conn_sink
-                .write()
-                .await
-                .send(Message::binary(serialized_response))
-                .await
-            {
-                error!("Error while sending message: {}", err)
-            }
+    if let Ok(serialized_response) =
+        cbor_serialize(&message).inspect_err(|e| error!("Error while serializing message: {}", e))
+    {
+        if let Err(err) = ws_conn_sink
+            .write()
+            .await
+            .send(Message::binary(serialized_response))
+            .await
+        {
+            error!("Error while sending message: {}", err)
         }
-        Err(e) => error!("Error while serializing message: {}", e),
     }
 }