Add a new bls test (#3235)

## Issue Addressed

Which issue # does this PR address?
#2629 

## Proposed Changes

Please list or describe the changes introduced by this PR.

1. ci would dowload the bls test cases from https://github.com/ethereum/bls12-381-tests/
2. all the bls test cases(except eth ones) would use cases in the archive from step one
3. The bls test cases from https://github.com/ethereum/consensus-spec-tests would stay there and no use . For the future , these bls test cases would be remove suggested from https://github.com/ethereum/consensus-spec-tests/issues/25 . So it would do no harm and compatible for future cases.

## Additional Info

Please provide any additional information. For example, future considerations
or information useful for reviewers.


Question: 

I am not sure if I should implement tests about `deserialization_G1`, `deserialization_G2` and `hash_to_G2` for the issue.

testing/ef_tests/src/cases/bls_aggregate_sigs.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{AggregateSignature, Signature};
 use serde_derive::Deserialize;
 
@@ -10,13 +10,9 @@ pub struct BlsAggregateSigs {
     pub output: String,
 }
 
-impl BlsCase for BlsAggregateSigs {}
+impl_bls_load_case!(BlsAggregateSigs);
 
 impl Case for BlsAggregateSigs {
-    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name == ForkName::Base
-    }
-
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let mut aggregate_signature = AggregateSignature::infinity();
 

testing/ef_tests/src/cases/bls_aggregate_verify.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{AggregateSignature, PublicKeyBytes};
 use serde_derive::Deserialize;
 use types::Hash256;
@@ -18,13 +18,9 @@ pub struct BlsAggregateVerify {
     pub output: bool,
 }
 
-impl BlsCase for BlsAggregateVerify {}
+impl_bls_load_case!(BlsAggregateVerify);
 
 impl Case for BlsAggregateVerify {
-    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name == ForkName::Base
-    }
-
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let messages = self
             .input

testing/ef_tests/src/cases/bls_batch_verify.rs

@@ -0,0 +1,67 @@
+use super::*;
+use crate::case_result::compare_result;
+use crate::impl_bls_load_case;
+use bls::{verify_signature_sets, BlsWrappedSignature, PublicKeyBytes, Signature, SignatureSet};
+use serde_derive::Deserialize;
+use std::borrow::Cow;
+use std::str::FromStr;
+use types::Hash256;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct BlsBatchVerifyInput {
+    pubkeys: Vec<PublicKeyBytes>,
+    messages: Vec<String>,
+    signatures: Vec<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct BlsBatchVerify {
+    pub input: BlsBatchVerifyInput,
+    pub output: bool,
+}
+
+impl_bls_load_case!(BlsBatchVerify);
+
+impl Case for BlsBatchVerify {
+    fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
+        let messages = self
+            .input
+            .messages
+            .iter()
+            .map(|s| Hash256::from_str(s).map_err(|e| Error::FailedToParseTest(format!("{:?}", e))))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let pubkeys = self
+            .input
+            .pubkeys
+            .iter()
+            .map(|pkb| {
+                pkb.decompress()
+                    .map_err(|_| Error::FailedToParseTest("pubkeys parse error".to_string()))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let signatures = self
+            .input
+            .signatures
+            .iter()
+            .map(|s| {
+                Signature::from_str(s).map_err(|e| Error::FailedToParseTest(format!("{:?}", e)))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let signature_set = messages
+            .iter()
+            .zip(pubkeys.iter())
+            .zip(signatures.iter())
+            .map(|((&message, pubkey), signature)| {
+                let wraped_signature = BlsWrappedSignature::from(signature);
+                SignatureSet::single_pubkey(wraped_signature, Cow::Borrowed(pubkey), message)
+            })
+            .collect::<Vec<_>>();
+
+        let signature_valid = verify_signature_sets(signature_set.iter());
+
+        compare_result::<bool, ()>(&Ok(signature_valid), &Some(self.output))
+    }
+}

testing/ef_tests/src/cases/bls_eth_aggregate_pubkeys.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{AggregatePublicKey, PublicKeyBytes};
 use serde_derive::Deserialize;
 
@@ -10,7 +10,7 @@ pub struct BlsEthAggregatePubkeys {
     pub output: Option<PublicKeyBytes>,
 }
 
-impl BlsCase for BlsEthAggregatePubkeys {}
+impl_bls_load_case!(BlsEthAggregatePubkeys, "data.yaml");
 
 impl Case for BlsEthAggregatePubkeys {
     fn is_enabled_for_fork(fork_name: ForkName) -> bool {

testing/ef_tests/src/cases/bls_eth_fast_aggregate_verify.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{AggregateSignature, PublicKeyBytes};
 use serde_derive::Deserialize;
 use std::convert::TryInto;
@@ -20,7 +20,7 @@ pub struct BlsEthFastAggregateVerify {
     pub output: bool,
 }
 
-impl BlsCase for BlsEthFastAggregateVerify {}
+impl_bls_load_case!(BlsEthFastAggregateVerify, "data.yaml");
 
 impl Case for BlsEthFastAggregateVerify {
     fn is_enabled_for_fork(fork_name: ForkName) -> bool {

testing/ef_tests/src/cases/bls_fast_aggregate_verify.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{AggregateSignature, PublicKeyBytes};
 use serde_derive::Deserialize;
 use std::convert::TryInto;
@@ -20,13 +20,9 @@ pub struct BlsFastAggregateVerify {
     pub output: bool,
 }
 
-impl BlsCase for BlsFastAggregateVerify {}
+impl_bls_load_case!(BlsFastAggregateVerify);
 
 impl Case for BlsFastAggregateVerify {
-    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name == ForkName::Base
-    }
-
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let message = Hash256::from_slice(
             &hex::decode(&self.input.message[2..])

testing/ef_tests/src/cases/bls_sign_msg.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::SecretKey;
 use serde_derive::Deserialize;
 use types::Hash256;
@@ -17,13 +17,9 @@ pub struct BlsSign {
     pub output: Option<String>,
 }
 
-impl BlsCase for BlsSign {}
+impl_bls_load_case!(BlsSign);
 
 impl Case for BlsSign {
-    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name == ForkName::Base
-    }
-
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         // Convert private_key and message to required types
         let sk = hex::decode(&self.input.privkey[2..])

testing/ef_tests/src/cases/bls_verify_msg.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::case_result::compare_result;
-use crate::cases::common::BlsCase;
+use crate::impl_bls_load_case;
 use bls::{PublicKeyBytes, Signature, SignatureBytes};
 use serde_derive::Deserialize;
 use std::convert::TryInto;
@@ -19,13 +19,9 @@ pub struct BlsVerify {
     pub output: bool,
 }
 
-impl BlsCase for BlsVerify {}
+impl_bls_load_case!(BlsVerify);
 
 impl Case for BlsVerify {
-    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        fork_name == ForkName::Base
-    }
-
     fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
         let message = hex::decode(&self.input.message[2..])
             .map_err(|e| Error::FailedToParseTest(format!("{:?}", e)))?;

testing/ef_tests/src/cases/common.rs

@@ -1,24 +1,11 @@
-use crate::cases::LoadCase;
-use crate::decode::yaml_decode_file;
-use crate::error::Error;
 use serde_derive::Deserialize;
 use ssz::Encode;
 use ssz_derive::{Decode, Encode};
 use std::convert::TryFrom;
 use std::fmt::Debug;
-use std::path::Path;
 use tree_hash::TreeHash;
 use types::ForkName;
 
-/// Trait for all BLS cases to eliminate some boilerplate.
-pub trait BlsCase: serde::de::DeserializeOwned {}
-
-impl<T: BlsCase> LoadCase for T {
-    fn load_from_dir(path: &Path, _fork_name: ForkName) -> Result<Self, Error> {
-        yaml_decode_file(&path.join("data.yaml"))
-    }
-}
-
 /// Macro to wrap U128 and U256 so they deserialize correctly.
 macro_rules! uint_wrapper {
     ($wrapper_name:ident, $wrapped_type:ty) => {
@@ -80,3 +67,24 @@ pub fn previous_fork(fork_name: ForkName) -> ForkName {
         ForkName::Merge => ForkName::Altair, // TODO: Check this when tests are released..
     }
 }
+
+#[macro_export]
+macro_rules! impl_bls_load_case {
+    ($case_name:ident) => {
+        use $crate::decode::yaml_decode_file;
+        impl LoadCase for $case_name {
+            fn load_from_dir(path: &Path, _fork_name: ForkName) -> Result<Self, Error> {
+                yaml_decode_file(&path)
+            }
+        }
+    };
+
+    ($case_name:ident, $sub_path_name:expr) => {
+        use $crate::decode::yaml_decode_file;
+        impl LoadCase for $case_name {
+            fn load_from_dir(path: &Path, _fork_name: ForkName) -> Result<Self, Error> {
+                yaml_decode_file(&path.join($sub_path_name))
+            }
+        }
+    };
+}