BLS-aggregation integration tests

Makefile

@@ -5,7 +5,7 @@ __CONTRACTS__: ##
 start-anvil-chain-with-contracts-deployed: ##
 	./crates/contracts/anvil/start-anvil-chain-with-el-and-avs-deployed.sh
 
-deploy-contracts-to-anvil-and-save-state: ## 
+deploy-contracts-to-anvil-and-save-state: ##
 	./crates/contracts/anvil/deploy-contracts-save-anvil-state.sh
 
 __TESTING__: ##
@@ -14,9 +14,9 @@ reset-anvil:
 	-docker stop anvil
 	-docker rm anvil
 
-pr: reset-anvil ## 
-	$(MAKE) start-anvil-chain-with-contracts-deployed
-	docker start anvil
+pr: reset-anvil ##
+	$(MAKE) start-anvil-chain-with-contracts-deployed > /dev/null &
+	sleep 4 # needed to wait for anvil setup to finish
 	cargo test --workspace
 	cargo clippy --workspace --lib --examples --tests --benches --all-features
 	cargo +nightly fmt -- --check

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

@@ -207,7 +207,7 @@ impl AvsRegistryChainWriter {
 
                 match tx_result {
                     Ok(tx) => {
-                        info!(tx_hash = ?tx,"Succesfully deregistered operator with the AVS's registry coordinator" );
+                        info!(tx_hash = ?tx,"Sent transaction to deregister operator in the AVS's registry coordinator" );
                         Ok(*tx.tx_hash())
                     }
                     Err(e) => Err(AvsRegistryError::AlloyContractError(e)),

crates/contracts/anvil/start-anvil-chain-with-el-and-avs-deployed.sh

@@ -38,3 +38,4 @@ cd ../../contracts
 cast rpc anvil_mine 200 --rpc-url http://localhost:8545 > /dev/null
 echo "Anvil is ready. Advanced chain to block-number:" $(cast block-number)
 
+docker attach anvil

crates/crypto/bls/src/lib.rs

@@ -13,6 +13,9 @@ use ark_bn254::{Fq, Fr, G1Affine, G1Projective, G2Affine, G2Projective};
 use ark_ec::{AffineRepr, CurveGroup};
 use ark_ff::{fields::PrimeField, BigInt, BigInteger256, Fp2};
 use eigen_crypto_bn254::utils::map_to_curve;
+use eigen_utils::binding::IBLSSignatureChecker::{
+    G1Point as G1PointChecker, G2Point as G2PointChecker,
+};
 use eigen_utils::binding::{
     BLSApkRegistry,
     RegistryCoordinator::{self},
@@ -66,17 +69,12 @@ pub struct BlsKeyPair {
 impl BlsKeyPair {
     /// Input [`Fr`] as a [`String`]
     pub fn new(fr: String) -> Result<Self, BlsError> {
-        let sk_result = Fr::from_str(&fr);
-        match sk_result {
-            Ok(sk) => {
-                let pk = G1Projective::from(G1Affine::generator()) * sk;
-                Ok(Self {
-                    priv_key: sk,
-                    pub_key: BlsG1Point::new(pk.into_affine()),
-                })
-            }
-            Err(_) => Err(BlsError::InvalidBlsPrivateKey),
-        }
+        let sk = Fr::from_str(&fr).map_err(|_| BlsError::InvalidBlsPrivateKey)?;
+        let pk = G1Projective::from(G1Affine::generator()) * sk;
+        Ok(Self {
+            priv_key: sk,
+            pub_key: BlsG1Point::new(pk.into_affine()),
+        })
     }
 
     /// Get public key on G1
@@ -118,20 +116,69 @@ pub fn convert_to_g1_point(g1: G1Affine) -> Result<G1Point, BlsError> {
     let x_point_result = g1.x();
     let y_point_result = g1.y();
 
-    if let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) {
-        let x = BigInt::new(x_point.into_bigint().0);
-        let y = BigInt::new(y_point.into_bigint().0);
+    let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) else {
+        return Err(BlsError::InvalidG1Affine);
+    };
 
-        let x_u256 = U256::from_limbs(x.0);
-        let y_u256 = U256::from_limbs(y.0);
+    let x = BigInt::new(x_point.into_bigint().0);
+    let y = BigInt::new(y_point.into_bigint().0);
 
-        Ok(G1Point {
-            X: x_u256,
-            Y: y_u256,
-        })
-    } else {
-        Err(BlsError::InvalidG1Affine)
-    }
+    let x_u256 = U256::from_limbs(x.0);
+    let y_u256 = U256::from_limbs(y.0);
+
+    Ok(G1Point {
+        X: x_u256,
+        Y: y_u256,
+    })
+}
+
+/// Convert [`G1Affine`] to  Alloy [`G1Point`]
+pub fn convert_to_bls_checker_g1_point(g1: G1Affine) -> Result<G1PointChecker, BlsError> {
+    let x_point_result = g1.x();
+    let y_point_result = g1.y();
+
+    let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) else {
+        return Err(BlsError::InvalidG1Affine);
+    };
+    let x = BigInt::new(x_point.into_bigint().0);
+    let y = BigInt::new(y_point.into_bigint().0);
+
+    let x_u256 = U256::from_limbs(x.0);
+    let y_u256 = U256::from_limbs(y.0);
+
+    Ok(G1PointChecker {
+        X: x_u256,
+        Y: y_u256,
+    })
+}
+
+/// Convert [`G1Affine`] to  Alloy [`G1Point`]
+pub fn convert_to_bls_checker_g2_point(g2: G2Affine) -> Result<G2PointChecker, BlsError> {
+    let x_point_result = g2.x();
+    let y_point_result = g2.y();
+
+    let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) else {
+        return Err(BlsError::InvalidG2Affine);
+    };
+    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(G2PointChecker {
+        X: [x_u256_1, x_u256_0],
+        Y: [y_u256_1, y_u256_0],
+    })
 }
 
 /// Convert [`G2Affine`] to [`G2Point`]
@@ -142,29 +189,79 @@ pub fn convert_to_g2_point(g2: G2Affine) -> Result<G2Point, BlsError> {
     let y_point_result = g2.y();
     // let y_point_c1 = g2.y().unwrap().c1;
 
-    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 (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) else {
+        return Err(BlsError::InvalidG2Affine);
+    };
+    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(G2Point {
+        X: [x_u256_1, x_u256_0],
+        Y: [y_u256_1, y_u256_0],
+    })
+}
 
-        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);
+/// 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)
+}
 
-        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);
+/// 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)
+}
 
-        Ok(G2Point {
-            X: [x_u256_1, x_u256_0],
-            Y: [y_u256_1, y_u256_0],
-        })
-    } else {
-        Err(BlsError::InvalidG2Affine)
-    }
+/// 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();
+
+    let (Some(x_point), Some(y_point)) = (x_point_result, y_point_result) else {
+        return Err(BlsError::InvalidG2Affine);
+    };
+    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],
+    })
 }
 
 /// Convert [`G1Point`] to [`G1Affine`]
@@ -239,7 +336,6 @@ impl Signature {
 
 #[cfg(test)]
 mod tests {
-
     use super::*;
     use ark_bn254::Fq2;
     use eigen_crypto_bn254::utils::verify_message;

crates/services/avsregistry/src/chaincaller.rs

@@ -108,7 +108,12 @@ impl AvsRegistryService for AvsRegistryServiceChainCaller {
                 let mut pub_key_g1 = G1Projective::from(PublicKey::identity());
                 let mut total_stake: U256 = U256::from(0);
                 for operator in operators_avs_state.values() {
-                    if !operator.stake_per_quorum[quorum_num].is_zero() {
+                    if !operator
+                        .stake_per_quorum
+                        .get(quorum_num)
+                        .unwrap_or(&U256::ZERO)
+                        .is_zero()
+                    {
                         if let Some(pub_keys) = &operator.operator_info.pub_keys {
                             pub_key_g1 += pub_keys.g1_pub_key.g1();
                             total_stake += operator.stake_per_quorum[quorum_num];

crates/services/bls_aggregation/Cargo.toml

@@ -24,4 +24,9 @@ tokio = { workspace = true, features = ["full"] }
 [dev-dependencies]
 alloy-node-bindings.workspace = true
 eigen-logging.workspace = true
+eigen-testing-utils.workspace = true
+eigen-utils.workspace = true
+eigen-services-operatorsinfo.workspace = true
+alloy-provider.workspace = true
+serial_test = "3.1"
 sha2 = "0.10.8"

crates/services/bls_aggregation/src/bls_agg.rs

@@ -23,16 +23,16 @@ use tokio::time::{timeout, Duration};
 #[allow(unused)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BlsAggregationServiceResponse {
-    task_index: TaskIndex,
-    task_response_digest: TaskResponseDigest,
-    non_signers_pub_keys_g1: Vec<BlsG1Point>,
-    quorum_apks_g1: Vec<BlsG1Point>,
-    signers_apk_g2: BlsG2Point,
-    signers_agg_sig_g1: Signature,
-    non_signer_quorum_bitmap_indices: Vec<u32>,
-    quorum_apk_indices: Vec<u32>,
-    total_stake_indices: Vec<u32>,
-    non_signer_stake_indices: Vec<Vec<u32>>,
+    pub task_index: TaskIndex,
+    pub task_response_digest: TaskResponseDigest,
+    pub non_signers_pub_keys_g1: Vec<BlsG1Point>,
+    pub quorum_apks_g1: Vec<BlsG1Point>,
+    pub signers_apk_g2: BlsG2Point,
+    pub signers_agg_sig_g1: Signature,
+    pub non_signer_quorum_bitmap_indices: Vec<u32>,
+    pub quorum_apk_indices: Vec<u32>,
+    pub total_stake_indices: Vec<u32>,
+    pub non_signer_stake_indices: Vec<Vec<u32>>,
 }
 
 /// Possible errors raised in BLS aggregation