refactor: add only base generator

also refactor curve and hasher types in test

Signed-off-by: pedro bufulin <pedro@semiotic.ai>

Author: pedrohba1

h2s2/src/ncs.rs

@@ -76,9 +76,9 @@ impl<P: Pairing, D: Digest + Send + Sync> HolographicHomomorphicSignatureScheme<
 
         // Generate a deterministic set of G1 generators based on the hardcoded G1 generator
         let g1_base_generator = P::G1::generator();
-        let g1_generators: Vec<P::G1> = (0..=n)
-            .map(|i| g1_base_generator.mul(&P::ScalarField::from(i as u64)))
-            .collect();
+        // In practice, we only ever use the first g1 generator
+        // so it is going to be generated only g1[0]
+        let g1_generators = vec![g1_base_generator];
 
         // Initialize parameters without secret/public keys
         let pp: H2S2Parameters<P> = H2S2Parameters {
@@ -214,18 +214,25 @@ impl<P: Pairing, D: Digest + Send + Sync> HolographicHomomorphicSignatureScheme<
 mod tests {
     use super::*;
     use ark_bn254::Bn254;
+    //we could also use the ark_bls12_381 curve which was intended to substitute this one:
+    //https://docs.rs/ark-bls12-381/latest/ark_bls12_381/
+    // Ethereum is reviewing using it:
+    // https://eips.ethereum.org/EIPS/eip-2537
+    // use ark_bls12_381::Bn254;
     use ark_std::test_rng;
-    use blake2::Blake2b512; // Use 512-bit Blake2b for digest
     use once_cell::sync::Lazy;
-
+    type Curve = Bn254;
+    type Fr = ark_bn254::Fr;
+    type Hasher = blake2::Blake2b512;
     static N: usize = 10; // Define the number of generators
-    static PARAMS: Lazy<H2S2Parameters<Bn254>> = Lazy::new(|| {
+
+    static PARAMS: Lazy<H2S2Parameters<Curve>> = Lazy::new(|| {
         let mut rng = test_rng();
 
-        let mut params = NCS::<Bn254, Blake2b512>::setup(N).expect("Setup failed");
+        let mut params = NCS::<Curve, Hasher>::setup(N).expect("Setup failed");
 
         // Generate the secret and public keys using keygen
-        let (pk, sk) = NCS::<Bn254, Blake2b512>::keygen(&params, &mut rng).expect("Keygen failed");
+        let (pk, sk) = NCS::<Curve, Hasher>::keygen(&params, &mut rng).expect("Keygen failed");
 
         params.secret_key = Some(sk);
         params.public_key = pk;
@@ -234,19 +241,21 @@ mod tests {
 
     #[test]
     fn test_setup_and_keygen() {
+        // Use the correct WBConfig implementation for G1
+
         let mut rng = test_rng();
         let n = 10;
 
-        let params = NCS::<Bn254, Blake2b512>::setup(n).expect("Setup failed");
+        let params = &*PARAMS; // Explicit reference to PARAMS
 
-        let (pk, sk) = NCS::<Bn254, Blake2b512>::keygen(&params, &mut rng).expect("Keygen failed");
+        let (pk, sk) = NCS::<Curve, Hasher>::keygen(&params, &mut rng).expect("Keygen failed");
 
         assert_eq!(
             params.g1_generators.len(),
-            n + 1,
+            1,
             "Incorrect number of G1 generators"
         );
-        assert_eq!(params.max_lanes, n, "Max lanes value mismatch");
+        assert_eq!(params.max_lanes, n, "Max lanes value 'mismatch");
 
         // Verify the public key matches the secret key and G2 generator relationship
         let calculated_public_key = params.g2_generator.mul(sk);
@@ -263,7 +272,7 @@ mod tests {
         let params = &*PARAMS;
         let mut rng = test_rng();
         let (hash_aggregate, alloc_id) =
-            NCS::<Bn254, Blake2b512>::precompute(&params, &mut rng, N).expect("Precompute failed");
+            NCS::<Curve, Hasher>::precompute(&params, &mut rng, N).expect("Precompute failed");
 
         println!("Precomputed Hash Aggregate: {:?}", hash_aggregate);
         println!("allocation_id {:?}", alloc_id);
@@ -276,20 +285,20 @@ mod tests {
 
         // Precompute the hash aggregate and allocation ID
         let (_, allocation_id) =
-            NCS::<Bn254, Blake2b512>::precompute(&params, &mut rng, N).expect("Precompute failed");
+            NCS::<Curve, Hasher>::precompute(&params, &mut rng, N).expect("Precompute failed");
 
         // Generate messages for each lane/index
-        let messages: Vec<ark_bn254::Fr> = (0..N).map(|_| ark_bn254::Fr::rand(&mut rng)).collect();
+        let messages: Vec<Fr> = (0..N).map(|_| Fr::rand(&mut rng)).collect();
 
         // Iterate through indices and sign each message
         for index in 0..N {
             // Sign the message with the current index
             let signature =
-                NCS::<Bn254, Blake2b512>::sign(&params, allocation_id, index, messages[index])
+                NCS::<Curve, Hasher>::sign(&params, allocation_id, index, messages[index])
                     .expect("Sign failed");
 
             // Verify the signature with the same index
-            let is_valid = NCS::<Bn254, Blake2b512>::verify(
+            let is_valid = NCS::<Curve, Hasher>::verify(
                 &params,
                 allocation_id,
                 index,
@@ -314,23 +323,23 @@ mod tests {
         let params = &*PARAMS;
 
         // Generate random messages for each lane/index
-        let messages: Vec<ark_bn254::Fr> = (0..N).map(|_| ark_bn254::Fr::rand(&mut rng)).collect();
+        let messages: Vec<Fr> = (0..N).map(|_| Fr::rand(&mut rng)).collect();
 
         // Precompute the hash aggregate and allocation ID
         let (hash_aggregate, allocation_id) =
-            NCS::<Bn254, Blake2b512>::precompute(&params, &mut rng, N).expect("Precompute failed");
+            NCS::<Curve, Hasher>::precompute(&params, &mut rng, N).expect("Precompute failed");
 
         // Generate individual signatures for each message
         let mut signatures: Vec<_> = (0..N)
             .map(|index| {
-                NCS::<Bn254, Blake2b512>::sign(&params, allocation_id, index, messages[index])
+                NCS::<Curve, Hasher>::sign(&params, allocation_id, index, messages[index])
                     .expect("Sign failed")
             })
             .collect();
 
         // Verify each individual signature
         for (index, signature) in signatures.iter().enumerate() {
-            let is_valid = NCS::<Bn254, Blake2b512>::verify(
+            let is_valid = NCS::<Curve, Hasher>::verify(
                 &params,
                 allocation_id,
                 index,
@@ -346,15 +355,12 @@ mod tests {
 
         // Aggregate the signatures
         let aggregated_signature =
-            NCS::<Bn254, Blake2b512>::evaluate(&signatures, &weights).expect("Evaluate failed");
+            NCS::<Curve, Hasher>::evaluate(&signatures, &weights).expect("Evaluate failed");
 
         // Verify the aggregated signature
-        let is_valid = NCS::<Bn254, Blake2b512>::verify_aggregate(
-            &params,
-            &hash_aggregate,
-            &aggregated_signature,
-        )
-        .expect("Verify failed");
+        let is_valid =
+            NCS::<Curve, Hasher>::verify_aggregate(&params, &hash_aggregate, &aggregated_signature)
+                .expect("Verify failed");
 
         assert!(
             is_valid,
@@ -376,10 +382,10 @@ mod tests {
 
         // Aggregate the signatures, including the duplicate
         let tampered_aggregate_signature =
-            NCS::<Bn254, Blake2b512>::evaluate(&signatures, &weights).expect("Evaluate failed");
+            NCS::<Curve, Hasher>::evaluate(&signatures, &weights).expect("Evaluate failed");
 
         // Verify the aggregated signature with the tampered signature table
-        let is_valid = NCS::<Bn254, Blake2b512>::verify_aggregate(
+        let is_valid = NCS::<Curve, Hasher>::verify_aggregate(
             &params,
             &hash_aggregate,
             &tampered_aggregate_signature,