feat: aggregation mode sdk (#1861)

Co-authored-by: MauroFab <[email protected]>

Author: MarcosNicolau

aggregation_mode/Cargo.lock

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

batcher/Cargo.lock

@@ -0,0 +1,146 @@
+use std::str::FromStr;
+
+use ethers::core::k256::sha2::{Digest, Sha256};
+use reqwest::{Client, Url};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+// 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)]
+pub enum BeaconClientError {
+    Url(url::ParseError),
+    ReqwestError(reqwest::Error),
+    APIError { code: u64, message: String },
+    Deserialization(serde_json::Error),
+}
+
+#[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(BeaconClientError::Deserialization)?;
+
+        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(BeaconClientError::Deserialization)
+    }
+
+    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(BeaconClientError::Url)?;
+        let req = self
+            .api_client
+            .get(url)
+            .header("content-type", "application/json")
+            .header("accept", "application/json");
+
+        let res = req.send().await.map_err(BeaconClientError::ReqwestError)?;
+        let beacon_response = res.json().await.map_err(BeaconClientError::ReqwestError)?;
+
+        match beacon_response {
+            BeaconAPIResponse::Success { data } => Ok(data),
+            BeaconAPIResponse::Error { code, message } => {
+                Err(BeaconClientError::APIError { code, message })
+            }
+        }
+    }
+}

batcher/aligned-sdk/Cargo.toml

@@ -71,6 +71,15 @@ pub const ALIGNED_SERVICE_MANAGER_MAINNET: &str = "0xeF2A435e5EE44B2041100EF8cbC
 pub const ALIGNED_SERVICE_MANAGER_MAINNET_STAGE: &str =
     "0x96b6a29D7B98519Ae66E6398BD27A76B30a5dC3f";
 
+// AlignedProofAggregationService
+pub const ALIGNED_PROOF_AGG_SERVICE_ADDRESS_MAINNET: &str = "0x0";
+pub const ALIGNED_PROOF_AGG_SERVICE_ADDRESS_MAINNET_STAGE: &str = "0x0";
+pub const ALIGNED_PROOF_AGG_SERVICE_ADDRESS_HOLESKY_STAGE: &str =
+    "0x7Eace34A8d4C4CacE633946C6F7CF4BeF3F33513";
+pub const ALIGNED_PROOF_AGG_SERVICE_ADDRESS_HOLESKY: &str = "0x0";
+pub const ALIGNED_PROOF_AGG_SERVICE_ADDRESS_DEVNET: &str =
+    "0xcbEAF3BDe82155F56486Fb5a1072cb8baAf547cc";
+
 /// Batcher URL's
 pub const BATCHER_URL_DEVNET: &str = "ws://localhost:8080";
 pub const BATCHER_URL_HOLESKY: &str = "wss://batcher.alignedlayer.com";