fix: beacon client matching blob versioned hash

Author: MarcosNicolau

batcher/aligned-sdk/Cargo.toml

@@ -25,4 +25,4 @@ hex = "0.4.3"
 ciborium = "=0.2.2"
 serde_repr = "0.1.19"
 dialoguer = "0.11.0"
-reqwest = { version = "0.12" }
+reqwest = { version = "0.12", features = ["json"] }

batcher/aligned-sdk/src/agg_mode.rs

@@ -1,14 +1,13 @@
 use crate::{
     beacon::{BeaconClient, BeaconClientError},
-    core::types::{Network, ProvingSystemId, VerificationData},
-    eth::aligned_proof_agg_service::aligned_proof_aggregation_service,
+    core::types::Network,
 };
 use ethers::{
     providers::{Http, Middleware, Provider},
     types::Filter,
 };
-use sha3::{Digest, Keccak256};
 
+#[derive(Debug)]
 pub enum ProofVerificationAggModeError {
     ProvingSystemNotSupportedInAggMode,
     EthereumProviderError(String),
@@ -18,58 +17,40 @@ pub enum ProofVerificationAggModeError {
 /// Given aligned verification data, it verifies if the proof was verified in the last aggregated proof
 /// Currently, this in Beta mode so there isn't a way to know exactly to which proof it belongs
 /// So currently we check if included in the last one and verify the merkle root commitment
+/// The step by step verification consists of:
+/// 1. Query the blob versioned hash of latest event from aligned proof aggregation service contract
+/// 2. Get the beacon block via the block parent beacon root
+/// 3. Fetch the blobs for that slot
+/// 4. Filter the blob with the blob versioned hash
+/// 5. Decode the blobs proofs
+/// 6. Find if the proofs hash is inside the blob proofs
+/// 7. Construct merkle root and verify it matches the one in the contract
 pub async fn is_proof_verified_in_aggregation_mode(
-    aligned_verification_data: &VerificationData,
+    proof_hash: String,
     network: Network,
     eth_rpc_url: String,
     beacon_client_url: String,
     from_block: u64,
 ) -> Result<bool, ProofVerificationAggModeError> {
-    let supported = match aligned_verification_data.proving_system {
-        ProvingSystemId::SP1 => true,
-        _ => false,
-    };
-
-    if !supported {
-        return Err(ProofVerificationAggModeError::ProvingSystemNotSupportedInAggMode);
-    }
-
     // TODO: check if the from_block is past 18 days as the blob_data won't be available anymore
 
-    let proof_hash: [u8; 32] = match aligned_verification_data.proving_system {
-        ProvingSystemId::SP1 => {
-            let mut hasher = Keccak256::new();
-            let vk = aligned_verification_data.verification_key.clone().unwrap();
-            let public_inputs = aligned_verification_data.pub_input.clone().unwrap();
-            hasher.update(&vk);
-            hasher.update(&public_inputs);
-            hasher.finalize().into()
-        }
-        // we already filter the supported ones
-        _ => unreachable!(),
-    };
-
-    /// We have to
-    /// 1. Query the blob versioned hash of latest event from aligned proof aggregation service contract
-    /// 2. Get the beacon block via the block parent beacon root
-    /// 3. Fetch the blobs for that slot
-    /// 4. Filter the blob with the blob versioned hash
-    /// 5. Decode the blobs proofs
-    /// 6. Find if the proofs hash is inside the blob proofs
-    /// 7. Construct merkle root and verify it matches the one in the contract
     let eth_rpc_provider = Provider::<Http>::try_from(eth_rpc_url)
         .map_err(|e| ProofVerificationAggModeError::EthereumProviderError(e.to_string()))?;
 
     let filter = Filter::new()
+        .address(network.get_aligned_proof_agg_service_address())
         .event("AggregatedProofVerified(bytes32,bytes32)")
         .from_block(from_block);
 
-    let mut to_check: Vec<(String, String, u64)> = vec![];
+    let mut to_check: Vec<([u8; 32], [u8; 32], u64)> = vec![];
 
     let logs = eth_rpc_provider.get_logs(&filter).await.unwrap();
     for log in logs {
-        let blob_versioned_hash = String::from_utf8(log.data[0..66].to_vec()).unwrap();
-        let merkle_root = String::from_utf8(log.topics.get(1).unwrap().0.to_vec()).unwrap();
+        let blob_versioned_hash: [u8; 32] = log.data[0..32]
+            .try_into()
+            .expect("Data has incorrect length");
+        let merkle_root = log.topics.get(1).expect("to decode merkle root in index").0;
+
         to_check.push((
             blob_versioned_hash,
             merkle_root,
@@ -88,22 +69,25 @@ pub async fn is_proof_verified_in_aggregation_mode(
             .unwrap();
         let beacon_parent_root = block.parent_beacon_block_root.unwrap();
 
-        let block = beacon_client
+        let beacon_block = beacon_client
             .get_block_header_from_parent_hash(beacon_parent_root.0)
             .await
             .map_err(ProofVerificationAggModeError::BeaconClient)?
             .unwrap();
 
         let blob = beacon_client
-            .get_blob_by_versioned_hash(block.header.message.slot, blob_versioned_hash.clone())
+            .get_blob_by_versioned_hash(
+                beacon_block.header.message.slot.parse().expect("a number"),
+                blob_versioned_hash,
+            )
             .await
             .map_err(ProofVerificationAggModeError::BeaconClient)?
             .unwrap();
 
         let proof_hashes = decoded_blob(blob.blob.into());
 
         // decoded blob and get all leaves and see if it the has is inside
-        if proof_hashes.contains(&blob_versioned_hash) {
+        if proof_hashes.contains(&[0u8; 32]) {
             return Ok(verify_merkle_root(proof_hashes, merkle_root));
         } else {
             continue;
@@ -113,12 +97,12 @@ pub async fn is_proof_verified_in_aggregation_mode(
     Ok(false)
 }
 
-fn decoded_blob(blob_data: Vec<u8>) -> Vec<String> {
+fn decoded_blob(blob_data: Vec<u8>) -> Vec<[u8; 32]> {
     let proof_hashes = vec![];
 
     proof_hashes
 }
 
-fn verify_merkle_root(proof_hashes: Vec<String>, merkle_root: String) -> bool {
+fn verify_merkle_root(proof_hashes: Vec<[u8; 32]>, merkle_root: [u8; 32]) -> bool {
     true
 }

batcher/aligned-sdk/src/beacon.rs

@@ -14,7 +14,7 @@ pub struct BeaconClient {
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
-enum BeaconResponse {
+enum BeaconAPIResponse {
     Success { data: Value },
     Error { code: u64, message: String },
 }
@@ -42,7 +42,7 @@ impl GetBlobResponse {
 
 #[derive(Deserialize, Debug)]
 pub struct BlobData {
-    pub index: u64,
+    pub index: String,
     pub blob: String,
     pub kzg_commitment: String,
     pub kzg_proof: String,
@@ -76,7 +76,7 @@ pub struct BeaconBlockHeader {
 
 #[derive(Deserialize, Debug)]
 pub struct BeaconBlockMessage {
-    pub slot: u64,
+    pub slot: String,
     pub proposer_index: String,
     pub parent_root: String,
     pub state_root: String,
@@ -128,18 +128,20 @@ impl BeaconClient {
     pub async fn get_blob_by_versioned_hash(
         &self,
         slot: u64,
-        blob_versioned_hash_hex: String,
+        blob_versioned_hash: [u8; 32],
     ) -> Result<Option<BlobData>, BeaconClientError> {
         let res = self.get_blobs_from_slot(slot).await?;
 
         let blob = res.blobs.into_iter().find(|blob| {
+            let kzg_commitment_bytes =
+                hex::decode(blob.kzg_commitment.replace("0x", "")).expect("A valid commitment");
+
             let mut hasher = Sha256::new();
-            hasher.update(blob.kzg_commitment.clone());
-            let mut hash: [u8; 32] = hasher.finalize().into();
-            hash[0] = KZG_VERSIONED_HASH;
-            let versioned_hash = format!("0x{}", hex::encode(hash));
+            hasher.update(&kzg_commitment_bytes);
+            let mut versioned_hash: [u8; 32] = hasher.finalize().into();
+            versioned_hash[0] = KZG_VERSIONED_HASH;
 
-            versioned_hash == blob_versioned_hash_hex
+            versioned_hash == blob_versioned_hash
         });
 
         Ok(blob)
@@ -155,14 +157,11 @@ impl BeaconClient {
             .header("accept", "application/json");
 
         let res = req.send().await.map_err(BeaconClientError::ReqwestError)?;
-        let beacon_response = res
-            .json::<BeaconResponse>()
-            .await
-            .map_err(BeaconClientError::ReqwestError)?;
+        let beacon_response = res.json().await.map_err(BeaconClientError::ReqwestError)?;
 
         match beacon_response {
-            BeaconResponse::Success { data } => Ok(data),
-            BeaconResponse::Error { code, message } => {
+            BeaconAPIResponse::Success { data } => Ok(data),
+            BeaconAPIResponse::Error { code, message } => {
                 Err(BeaconClientError::APIError { code, message })
             }
         }

batcher/aligned-sdk/src/lib.rs

@@ -17,6 +17,6 @@ pub mod eth {
     pub mod batcher_payment_service;
 }
 
-mod agg_mode;
+pub mod agg_mode;
 mod beacon;
 pub mod sdk;