feat: BLS aggregation

Cargo.toml

@@ -65,7 +65,6 @@ eigen-client-fireblocks = { path = "crates/chainio/clients/fireblocks" }
 eigen-contract-bindings = { path = "crates/contracts/bindings/" }
 eigen-crypto-bls = { path = "crates/crypto/bls/" }
 eigen-crypto-bn254 = { path = "crates/crypto/bn254/" }
-eigen-crypto-keystore = { path = "crates/crypto/keystore/" }
 eigen-logging = { path = "crates/logging/" }
 eigen-metrics = { version = "0.0.1-alpha", path = "crates/metrics/" }
 eigen-metrics-collectors-economic = { path = "crates/metrics/collectors/economic" }
@@ -110,10 +109,11 @@ tokio = { version = "1.37.0", features = ["test-util", "full", "sync"] }
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3", features = ["json"] }
 url = "2.5.2"
-uuid = { version = "1.10.0", features = ["v4"] }
 
 #misc
 rust-bls-bn254 = {git = "https://github.com/Layr-Labs/rust-bls-bn254.git", rev = "be3ef87", features = ["std"] }
+uuid = { version = "1.10.0", features = ["v4"] }
+
 
 #misc 
 parking_lot = "0.12"

crates/chainio/clients/avsregistry/src/error.rs

@@ -11,7 +11,7 @@ pub enum AvsRegistryError {
     GetBlsApkRegistry,
 
     /// Failed to get quorum count
-    #[error("Faield to get quorum count")]
+    #[error("Failed to get quorum count")]
     GetQuorumCount,
 
     /// Failed to ger operator state
@@ -141,6 +141,10 @@ pub enum AvsRegistryError {
     /// BlsError compatibility
     #[error("BlsError :{0}")]
     BlsError(String),
+
+    /// Invalid Quorum Numbers
+    #[error("Invalid number of quorum numbers")]
+    InvalidQuorumNums,
 }
 
 impl From<ElContractsError> for AvsRegistryError {

crates/chainio/clients/avsregistry/src/reader.rs

@@ -3,13 +3,15 @@ use alloy_primitives::{Address, Bytes, FixedBytes, B256, U256};
 use alloy_provider::Provider;
 use alloy_rpc_types::Filter;
 use ark_ff::Zero;
-use eigen_logging::logger::SharedLogger;
-use eigen_logging::tracing_logger::TracingLogger;
+use eigen_crypto_bls::{
+    alloy_registry_g1_point_to_g1_affine, alloy_registry_g2_point_to_g2_affine, BlsG1Point,
+    BlsG2Point,
+};
+use eigen_logging::{logger::SharedLogger, tracing_logger::TracingLogger};
 use eigen_types::operator::{bitmap_to_quorum_ids, OperatorPubKeys};
-use eigen_utils::NEW_PUBKEY_REGISTRATION_EVENT;
 use eigen_utils::{
     binding::{BLSApkRegistry, OperatorStateRetriever, RegistryCoordinator, StakeRegistry},
-    get_provider, get_ws_provider,
+    get_provider, get_ws_provider, NEW_PUBKEY_REGISTRATION_EVENT,
 };
 use num_bigint::BigInt;
 use std::collections::HashMap;
@@ -428,8 +430,12 @@ impl AvsRegistryChainReader {
                                         let g1_pub_key = data.pubkeyG1.clone();
                                         let g2_pub_key = data.pubkeyG2.clone();
                                         let operator_pub_key = OperatorPubKeys {
-                                            g1_pub_key,
-                                            g2_pub_key,
+                                            g1_pub_key: BlsG1Point::new(
+                                                alloy_registry_g1_point_to_g1_affine(g1_pub_key),
+                                            ),
+                                            g2_pub_key: BlsG2Point::new(
+                                                alloy_registry_g2_point_to_g2_affine(g2_pub_key),
+                                            ),
                                         };
                                         operator_pub_keys.push(operator_pub_key);
                                     }

crates/chainio/clients/eth/src/instrumented_client.rs

@@ -313,8 +313,8 @@ impl InstrumentedClient {
     /// * `block_count` - The number of blocks to include in the collection.
     /// * `last_block` - The last block number to include in the collection.
     /// * `reward_percentiles` - A sorted list of percentage points used to
-    /// sample the effective priority fees per gas from each block. The samples are
-    /// taken in ascending order and weighted by gas usage. The list is sorted increasingly.
+    ///   sample the effective priority fees per gas from each block. The samples are
+    ///   taken in ascending order and weighted by gas usage. The list is sorted increasingly.
     pub async fn fee_history(
         &self,
         block_count: u64,

crates/crypto/bls/src/lib.rs

@@ -11,16 +11,20 @@ pub mod error;
 use crate::error::BlsError;
 use ark_bn254::{Fq, Fr, G1Affine, G1Projective, G2Affine, G2Projective};
 use ark_ec::{AffineRepr, CurveGroup};
-use ark_ff::{fields::PrimeField, BigInt, BigInteger256};
+use ark_ff::{fields::PrimeField, BigInt, BigInteger256, Fp2};
 use eigen_crypto_bn254::utils::map_to_curve;
-use eigen_utils::binding::RegistryCoordinator::{self};
+use eigen_utils::binding::{
+    BLSApkRegistry,
+    RegistryCoordinator::{self},
+};
+use BLSApkRegistry::{G1Point as G1PointRegistry, G2Point as G2PointRegistry};
 use RegistryCoordinator::{G1Point, G2Point};
 pub type PrivateKey = Fr;
 pub type PublicKey = G1Affine;
 pub type BlsSignature = G1Affine;
 pub type OperatorId = B256;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BlsG1Point {
     g1: G1Affine,
 }
@@ -35,7 +39,7 @@ impl BlsG1Point {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BlsG2Point {
     g2: G2Affine,
 }
@@ -50,8 +54,8 @@ impl BlsG2Point {
     }
 }
 
-#[derive(Debug)]
 /// Bls key pair with public key on G1
+#[derive(Debug, Clone)]
 pub struct BlsKeyPair {
     /// Private Key
     priv_key: Fr,
@@ -163,8 +167,60 @@ pub fn convert_to_g2_point(g2: G2Affine) -> Result<G2Point, BlsError> {
     }
 }
 
+/// Convert [`G1Point`] to [`G1Affine`]
+pub fn alloy_registry_g1_point_to_g1_affine(g1_point: G1PointRegistry) -> G1Affine {
+    let x_point = g1_point.X.into_limbs();
+    let x = Fq::new(BigInteger256::new(x_point));
+    let y_point = g1_point.Y.into_limbs();
+    let y = Fq::new(BigInteger256::new(y_point));
+    G1Affine::new(x, y)
+}
+
+/// Convert [`G1Point`] to [`G1Affine`]
+pub fn alloy_registry_g2_point_to_g2_affine(g2_point: G2PointRegistry) -> G2Affine {
+    let x_fp2 = Fp2::new(
+        BigInteger256::new(g2_point.X[1].into_limbs()).into(),
+        BigInteger256::new(g2_point.X[0].into_limbs()).into(),
+    );
+    let y_fp2 = Fp2::new(
+        BigInteger256::new(g2_point.Y[1].into_limbs()).into(),
+        BigInteger256::new(g2_point.Y[0].into_limbs()).into(),
+    );
+    G2Affine::new(x_fp2, y_fp2)
+}
+
+/// Convert [`G2Affine`] to [`G2Point`]
+pub fn convert_to_registry_g2_point(g2: G2Affine) -> Result<G2PointRegistry, BlsError> {
+    let x_point_result = g2.x();
+    let y_point_result = g2.y();
+
+    if let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) {
+        let x_point_c0 = x_point.c0;
+        let x_point_c1 = x_point.c1;
+        let y_point_c0 = y_point.c0;
+        let y_point_c1 = y_point.c1;
+
+        let x_0 = BigInt::new(x_point_c0.into_bigint().0);
+        let x_1 = BigInt::new(x_point_c1.into_bigint().0);
+        let y_0 = BigInt::new(y_point_c0.into_bigint().0);
+        let y_1 = BigInt::new(y_point_c1.into_bigint().0);
+
+        let x_u256_0 = U256::from_limbs(x_0.0);
+        let x_u256_1 = U256::from_limbs(x_1.0);
+        let y_u256_0 = U256::from_limbs(y_0.0);
+        let y_u256_1 = U256::from_limbs(y_1.0);
+
+        Ok(G2PointRegistry {
+            X: [x_u256_1, x_u256_0],
+            Y: [y_u256_1, y_u256_0],
+        })
+    } else {
+        Err(BlsError::InvalidG2Affine)
+    }
+}
+
 /// Signature instance on [`G1Affine`]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Signature {
     g1_point: BlsG1Point,
 }
@@ -394,4 +450,57 @@ mod tests {
             signature.g1_point().g1()
         ));
     }
+
+    #[test]
+    fn test_alloy_registry_g2_point_to_g2_affine() {
+        let registry_g2_point = G2PointRegistry {
+            X: [
+                U256::from_str(
+                    "5757009320127825712028542414399286695979413866882055578475552905478799178978",
+                )
+                .unwrap(),
+                U256::from_str(
+                    "21244616545128868564944750577089226156588822099825362793595203506897139322148",
+                )
+                .unwrap(),
+            ],
+            Y: [
+                U256::from_str(
+                    "14151879035050941576498647371309462393327101480686968228451570672809612016186",
+                )
+                .unwrap(),
+                U256::from_str(
+                    "3459884663217117850014821742383597128426843416583591466170557027357262534805",
+                )
+                .unwrap(),
+            ],
+        };
+
+        let g2_affine = alloy_registry_g2_point_to_g2_affine(registry_g2_point);
+        let expected_g2_affine = G2Affine {
+            x: Fq2::new(
+                Fq::from_str(
+                    "21244616545128868564944750577089226156588822099825362793595203506897139322148",
+                )
+                .unwrap(),
+                Fq::from_str(
+                    "5757009320127825712028542414399286695979413866882055578475552905478799178978",
+                )
+                .unwrap(),
+            ),
+            y: Fq2::new(
+                Fq::from_str(
+                    "3459884663217117850014821742383597128426843416583591466170557027357262534805",
+                )
+                .unwrap(),
+                Fq::from_str(
+                    "14151879035050941576498647371309462393327101480686968228451570672809612016186",
+                )
+                .unwrap(),
+            ),
+            infinity: false,
+        };
+
+        assert_eq!(g2_affine, expected_g2_affine);
+    }
 }

crates/services/avsregistry/Cargo.toml

@@ -10,11 +10,10 @@ license-file.workspace = true
 
 [dependencies]
 alloy-primitives.workspace = true
-eigen-chainio-utils.workspace = true
+ark-bn254.workspace = true
+ark-ec.workspace = true
 eigen-client-avsregistry.workspace = true
 eigen-crypto-bls.workspace = true
-eigen-crypto-bn254.workspace = true
-eigen-logging.workspace = true
 eigen-services-operatorsinfo.workspace = true
 eigen-types.workspace = true
 eigen-utils.workspace = true