fix BDNAggregate::aggregate_sigs

Author: moshababo

blssig/src/bdn/mod.rs

@@ -18,7 +18,6 @@ use rayon::prelude::*;
 
 /// BDN aggregation context for managing signature and public key aggregation
 pub struct BDNAggregation {
-    pub(crate) pub_keys: Vec<PublicKey>,
     pub(crate) coefficients: Vec<Scalar>,
     pub(crate) terms: Vec<PublicKey>,
 }
@@ -33,25 +32,33 @@ impl BDNAggregation {
         let terms = Self::calc_terms(&pub_keys, &coefficients);
 
         Ok(Self {
-            pub_keys,
             coefficients,
             terms,
         })
     }
 
     /// Aggregates signatures using BDN aggregation with coefficients.
-    /// Computes: sum((coef_i + 1) * sig_i)
-    pub fn aggregate_sigs(&self, sigs: Vec<Signature>) -> Result<Signature, BLSError> {
-        if sigs.len() != self.pub_keys.len() {
+    /// Computes: sum((coef_i + 1) * sig_i) for signatures at the given indices
+    pub fn aggregate_sigs(
+        &self,
+        indices: &[u64],
+        sigs: &[Signature],
+    ) -> Result<Signature, BLSError> {
+        if sigs.len() != indices.len() {
             return Err(BLSError::LengthMismatch {
-                pub_keys: self.pub_keys.len(),
+                pub_keys: indices.len(),
                 sigs: sigs.len(),
             });
         }
 
         let mut agg_point = G2Projective::identity();
-        for (i, sig) in sigs.iter().enumerate() {
-            let coef = self.coefficients[i];
+        for (sig, &idx) in sigs.iter().zip(indices.iter()) {
+            let idx = idx as usize;
+            if idx >= self.coefficients.len() {
+                return Err(BLSError::SignerIndexOutOfRange(idx));
+            }
+
+            let coef = self.coefficients[idx];
             let sig_point: G2Projective = (*sig).into();
             let sig_c = sig_point * coef;
             let sig_c = sig_c + sig_point;

blssig/src/verifier/mod.rs

@@ -193,7 +193,8 @@ impl Verifier for BLSVerifier {
         }
 
         let bdn = BDNAggregation::new(typed_pub_keys)?;
-        let agg_sig = bdn.aggregate_sigs(typed_sigs)?;
+        let indices: Vec<u64> = (0..typed_sigs.len() as u64).collect();
+        let agg_sig = bdn.aggregate_sigs(&indices, &typed_sigs)?;
         Ok(agg_sig.as_bytes())
     }
 

blssig/src/verifier/tests.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use super::BLSVerifier;
+use crate::bdn::BDNAggregation;
 use bls_signatures::{PrivateKey, Serialize};
 use filecoin_f3_gpbft::PubKey;
 use filecoin_f3_gpbft::api::Verifier;
@@ -68,3 +69,49 @@ fn test_invalid_signature() {
         "corrupted signature should fail verification"
     );
 }
+
+#[test]
+fn test_aggregate_signature_verification() {
+    let verifier = BLSVerifier::new();
+    let message = b"consensus message";
+
+    // Generate 10 validators for the power table
+    let mut signers = Vec::new();
+    let mut power_table = Vec::new();
+    for _ in 0..10 {
+        let private_key = PrivateKey::generate(&mut rand::thread_rng());
+        let signer = BLSSigner::new(private_key);
+        power_table.push(signer.public_key().clone());
+        signers.push(signer);
+    }
+
+    // Only 5 validators sign (indices 0, 2, 4, 6, 8)
+    let signers_subset = vec![0u64, 2, 4, 6, 8];
+    let sigs: Vec<Vec<u8>> = signers_subset
+        .iter()
+        .map(|&i| signers[i as usize].sign(message))
+        .collect();
+
+    // Aggregate using BDN with full power table
+    let typed_pub_keys: Vec<_> = power_table
+        .iter()
+        .map(|pk| bls_signatures::PublicKey::from_bytes(&pk.0).unwrap())
+        .collect();
+    let typed_sigs: Vec<_> = sigs
+        .iter()
+        .map(|sig| bls_signatures::Signature::from_bytes(sig).unwrap())
+        .collect();
+
+    let bdn = BDNAggregation::new(typed_pub_keys).expect("BDN creation should succeed");
+    let agg_sig = bdn
+        .aggregate_sigs(&signers_subset, &typed_sigs)
+        .expect("aggregation should succeed");
+
+    // Verify aggregate using full power table and signer indices
+    let result =
+        verifier.verify_aggregate(message, &agg_sig.as_bytes(), &power_table, &signers_subset);
+    assert!(
+        result.is_ok(),
+        "aggregate signature verification should succeed"
+    );
+}