Update spec tests to v1.1.0-beta.4 (#2548)

## Proposed Changes

Bump the spec tests to beta.4, including the new randomised tests (which all pass 🎉)

testing/ef_tests/src/cases/bls_aggregate_sigs.rs

@@ -13,6 +13,10 @@ pub struct BlsAggregateSigs {
 impl BlsCase for 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

@@ -21,6 +21,10 @@ pub struct BlsAggregateVerify {
 impl BlsCase for 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_eth_aggregate_pubkeys.rs

@@ -0,0 +1,48 @@
+use super::*;
+use crate::case_result::compare_result;
+use crate::cases::common::BlsCase;
+use bls::{AggregatePublicKey, PublicKeyBytes};
+use serde_derive::Deserialize;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct BlsEthAggregatePubkeys {
+    pub input: Vec<PublicKeyBytes>,
+    pub output: Option<PublicKeyBytes>,
+}
+
+impl BlsCase for BlsEthAggregatePubkeys {}
+
+impl Case for BlsEthAggregatePubkeys {
+    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
+        fork_name == ForkName::Altair
+    }
+
+    fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
+        let pubkeys_result = self
+            .input
+            .iter()
+            .map(|pkb| pkb.decompress())
+            .collect::<Result<Vec<_>, _>>();
+
+        let pubkeys = match pubkeys_result {
+            Ok(pubkeys) => pubkeys,
+            Err(bls::Error::InvalidInfinityPublicKey | bls::Error::BlstError(_))
+                if self.output.is_none() =>
+            {
+                return Ok(());
+            }
+            #[cfg(feature = "milagro")]
+            Err(bls::Error::MilagroError(_)) if self.output.is_none() => {
+                return Ok(());
+            }
+            Err(e) => return Err(Error::FailedToParseTest(format!("{:?}", e))),
+        };
+
+        let aggregate_pubkey =
+            AggregatePublicKey::aggregate(&pubkeys).map(|agg| agg.to_public_key());
+
+        let expected = self.output.as_ref().map(|pk| pk.decompress().unwrap());
+
+        compare_result::<_, bls::Error>(&aggregate_pubkey, &expected)
+    }
+}

testing/ef_tests/src/cases/bls_eth_fast_aggregate_verify.rs

@@ -0,0 +1,61 @@
+use super::*;
+use crate::case_result::compare_result;
+use crate::cases::common::BlsCase;
+use bls::{AggregateSignature, PublicKeyBytes};
+use serde_derive::Deserialize;
+use std::convert::TryInto;
+use types::Hash256;
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct BlsEthFastAggregateVerifyInput {
+    pub pubkeys: Vec<PublicKeyBytes>,
+    #[serde(alias = "messages")]
+    pub message: String,
+    pub signature: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct BlsEthFastAggregateVerify {
+    pub input: BlsEthFastAggregateVerifyInput,
+    pub output: bool,
+}
+
+impl BlsCase for BlsEthFastAggregateVerify {}
+
+impl Case for BlsEthFastAggregateVerify {
+    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
+        fork_name == ForkName::Altair
+    }
+
+    fn result(&self, _case_index: usize, _fork_name: ForkName) -> Result<(), Error> {
+        let message = Hash256::from_slice(
+            &hex::decode(&self.input.message[2..])
+                .map_err(|e| Error::FailedToParseTest(format!("{:?}", e)))?,
+        );
+
+        let pubkeys_result = self
+            .input
+            .pubkeys
+            .iter()
+            .map(|pkb| pkb.try_into())
+            .collect::<Result<Vec<_>, _>>();
+
+        let pubkeys = match pubkeys_result {
+            Ok(pubkeys) => pubkeys,
+            Err(bls::Error::InvalidInfinityPublicKey) if !self.output => {
+                return Ok(());
+            }
+            Err(e) => return Err(Error::FailedToParseTest(format!("{:?}", e))),
+        };
+
+        let pubkey_refs = pubkeys.iter().collect::<Vec<_>>();
+
+        let signature_ok = hex::decode(&self.input.signature[2..])
+            .ok()
+            .and_then(|bytes: Vec<u8>| AggregateSignature::deserialize(&bytes).ok())
+            .map(|signature| signature.eth_fast_aggregate_verify(message, &pubkey_refs))
+            .unwrap_or(false);
+
+        compare_result::<bool, ()>(&Ok(signature_ok), &Some(self.output))
+    }
+}

testing/ef_tests/src/cases/bls_fast_aggregate_verify.rs

@@ -23,6 +23,10 @@ pub struct BlsFastAggregateVerify {
 impl BlsCase for 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

@@ -20,6 +20,10 @@ pub struct BlsSign {
 impl BlsCase for 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

@@ -22,6 +22,10 @@ pub struct BlsVerify {
 impl BlsCase for 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/ssz_generic.rs

@@ -139,7 +139,6 @@ impl Case for SszGeneric {
                 let mut limit = parts[1];
 
                 // Test format is inconsistent, pretend the limit is 32 (arbitrary)
-                // https://github.com/ethereum/eth2.0-spec-tests
                 if limit == "no" {
                     limit = "32";
                 }