feat: move sdk from crates dir to aggregation mode dir

Author: MarcosNicolau

aggregation_mode/Cargo.lock

@@ -11,6 +11,7 @@ serde = { version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.117"
 serde_yaml = "0.9"
 alloy = { version = "1.1.1", features = ["default", "signer-keystore", "kzg"] }
+lambdaworks-crypto = { git = "https://github.com/lambdaclass/lambdaworks.git", rev = "5f8f2cfcc8a1a22f77e8dff2d581f1166eefb80b", features = ["serde"]}
 bincode = "1.3.3"
 aligned-sdk = { path = "../crates/sdk/" }
 db = { path = "./db" }

aggregation_mode/Cargo.toml

@@ -19,7 +19,7 @@ tokio = { version = "1", features = ["time"]}
 sha3 = "0.10.8"
 reqwest = { version = "0.12" }
 ciborium = "=0.2.2"
-lambdaworks-crypto = { git = "https://github.com/lambdaclass/lambdaworks.git", rev = "5f8f2cfcc8a1a22f77e8dff2d581f1166eefb80b", features = ["serde"]}
+lambdaworks-crypto = { workspace = true }
 rayon = "1.10.0"
 backon = "1.2.0"
 sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "uuid", "bigdecimal" ] }

aggregation_mode/proof_aggregator/Cargo.toml

@@ -5,10 +5,13 @@ edition = "2021"
 
 [dependencies]
 serde =  { workspace = true }
+serde_json = { workspace = true }
+alloy = { workspace = true }
+sp1-sdk = { workspace = true }
+lambdaworks-crypto = { workspace = true }
 tracing = { version = "0.1", features = ["log"] }
 tracing-subscriber = { version = "0.3.0", features = ["env-filter"] }
 bincode = "1.3.3"
 reqwest = { version = "0.12", features = ["json", "multipart"] }
 tokio = { version = "1", features = ["time"]}
-alloy = { workspace = true }
-sp1-sdk = { workspace = true }
+sha3 = { version = "0.10.8" }

aggregation_mode/sdk/Cargo.toml

@@ -0,0 +1,154 @@
+use std::str::FromStr;
+
+use alloy::{hex, signers::k256::sha2::Sha256};
+use reqwest::{Client, Url};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use sha3::Digest;
+
+// See https://eips.ethereum.org/EIPS/eip-4844#parameters
+pub const KZG_VERSIONED_HASH: u8 = 0x1;
+
+pub struct BeaconClient {
+    beacon_client_url: String,
+    api_client: Client,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+enum BeaconAPIResponse {
+    Success { data: Value },
+    Error { code: u64, message: String },
+}
+
+#[derive(Debug, Clone)]
+pub enum BeaconClientError {
+    Url(String),
+    ReqwestError(String),
+    APIError { code: u64, message: String },
+    Deserialization(String),
+}
+
+#[derive(Deserialize, Debug)]
+#[allow(dead_code)]
+// https://ethereum.github.io/beacon-APIs/#/Beacon/getBlobSidecars
+pub struct BlobData {
+    pub index: String,
+    pub blob: String,
+    pub kzg_commitment: String,
+    pub kzg_proof: String,
+    pub kzg_commitment_inclusion_proof: Vec<String>,
+}
+
+#[derive(Deserialize, Debug)]
+#[allow(dead_code)]
+// https://ethereum.github.io/beacon-APIs/#/Beacon/getBlockHeaders
+pub struct BeaconBlock {
+    pub root: String,
+    pub canonical: bool,
+    pub header: BeaconBlockHeader,
+}
+
+#[derive(Deserialize, Debug)]
+
+pub struct BeaconBlockHeader {
+    pub message: BeaconBlockMessage,
+}
+
+#[derive(Deserialize, Debug)]
+#[allow(dead_code)]
+pub struct BeaconBlockMessage {
+    pub slot: String,
+    pub proposer_index: String,
+    pub parent_root: String,
+    pub state_root: String,
+    pub body_root: String,
+}
+
+impl BeaconClient {
+    pub fn new(beacon_client_url: String) -> Self {
+        Self {
+            api_client: Client::new(),
+            beacon_client_url,
+        }
+    }
+
+    pub async fn get_block_header_from_parent_hash(
+        &self,
+        parent_block_hash: [u8; 32],
+    ) -> Result<Option<BeaconBlock>, BeaconClientError> {
+        let parent_block_hash_hex = format!("0x{}", hex::encode(parent_block_hash));
+        let data = self
+            .beacon_get(&format!(
+                "/eth/v1/beacon/headers?parent_root={}",
+                parent_block_hash_hex
+            ))
+            .await?;
+
+        let res = Vec::<BeaconBlock>::deserialize(data)
+            .map_err(|e| BeaconClientError::Deserialization(e.to_string()))?;
+
+        let block = res
+            .into_iter()
+            .find(|block| block.header.message.parent_root == parent_block_hash_hex);
+
+        Ok(block)
+    }
+
+    pub async fn get_blobs_from_slot(&self, slot: u64) -> Result<Vec<BlobData>, BeaconClientError> {
+        let data = self
+            .beacon_get(&format!("/eth/v1/beacon/blob_sidecars/{}", slot))
+            .await?;
+
+        Vec::<BlobData>::deserialize(data)
+            .map_err(|e| BeaconClientError::Deserialization(e.to_string()))
+    }
+
+    pub async fn get_blob_by_versioned_hash(
+        &self,
+        slot: u64,
+        blob_versioned_hash: [u8; 32],
+    ) -> Result<Option<BlobData>, BeaconClientError> {
+        let res = self.get_blobs_from_slot(slot).await?;
+
+        let blob = res.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(&kzg_commitment_bytes);
+            let mut versioned_hash: [u8; 32] = hasher.finalize().into();
+            versioned_hash[0] = KZG_VERSIONED_HASH;
+
+            versioned_hash == blob_versioned_hash
+        });
+
+        Ok(blob)
+    }
+
+    async fn beacon_get(&self, path: &str) -> Result<Value, BeaconClientError> {
+        let url = Url::from_str(&format!("{}{}", self.beacon_client_url, path))
+            .map_err(|e| BeaconClientError::Url(e.to_string()))?;
+        let req = self
+            .api_client
+            .get(url)
+            .header("content-type", "application/json")
+            .header("accept", "application/json");
+
+        let res = req
+            .send()
+            .await
+            .map_err(|e| BeaconClientError::ReqwestError(e.to_string()))?;
+        let beacon_response = res
+            .json()
+            .await
+            .map_err(|e| BeaconClientError::ReqwestError(e.to_string()))?;
+
+        match beacon_response {
+            BeaconAPIResponse::Success { data } => Ok(data),
+            BeaconAPIResponse::Error { code, message } => {
+                Err(BeaconClientError::APIError { code, message })
+            }
+        }
+    }
+}

aggregation_mode/sdk/abi/AlignedProofAggregationService.json

@@ -0,0 +1,34 @@
+pub fn decoded_blob(blob_data: &[u8]) -> Vec<[u8; 32]> {
+    let mut proof_hashes = vec![];
+
+    let mut current_hash = [0u8; 32];
+    let mut current_hash_count = 0;
+    let mut total_bytes_count = 0;
+
+    while total_bytes_count < blob_data.len() {
+        // Every 32 bytes there is a 0x0 acting as padding, so we need to skip the byte
+        let is_pad = total_bytes_count % 32 == 0;
+        if is_pad {
+            total_bytes_count += 1;
+            continue;
+        }
+
+        current_hash[current_hash_count] = blob_data[total_bytes_count];
+
+        if current_hash_count + 1 == 32 {
+            // if the current_hash is the zero hash, then there are no more proofs in the blob
+            if current_hash == [0u8; 32] {
+                break;
+            }
+            proof_hashes.push(current_hash);
+            current_hash = [0u8; 32];
+            current_hash_count = 0;
+        } else {
+            current_hash_count += 1;
+        }
+
+        total_bytes_count += 1;
+    }
+
+    proof_hashes
+}

aggregation_mode/sdk/src/beacon.rs

@@ -0,0 +1,9 @@
+// Modules
+mod helpers;
+pub mod provider;
+mod types;
+
+// Makes only the two types on this use public
+pub use types::{
+    AggregationModeProvingSystem, AggregationModeVerificationData, ProofVerificationAggModeError,
+};