Update to Spec v0.10 (#817)

* Start updating types

* WIP

* Signature hacking

* Existing EF tests passing with fake_crypto

* Updates

* Delete outdated API spec

* The refactor continues

* It compiles

* WIP test fixes

* All release tests passing bar genesis state parsing

* Update and test YamlConfig

* Update to spec v0.10 compatible BLS

* Updates to BLS EF tests

* Add EF test for AggregateVerify

And delete unused hash2curve tests for uncompressed points

* Update EF tests to v0.10.1

* Use optional block root correctly in block proc

* Use genesis fork in deposit domain. All tests pass

* Cargo fmt

* Fast aggregate verify test

* Update REST API docs

* Cargo fmt

* Fix unused import

* Bump spec tags to v0.10.1

* Add `seconds_per_eth1_block` to chainspec

* Update to timestamp based eth1 voting scheme

* Return None from `get_votes_to_consider` if block cache is empty

* Handle overflows in `is_candidate_block`

* Revert to failing tests

* Fix eth1 data sets test

* Choose default vote according to spec

* Fix collect_valid_votes tests

* Fix `get_votes_to_consider` to choose all eligible blocks

* Uncomment winning_vote tests

* Add comments; remove unused code

* Reduce seconds_per_eth1_block for simulation

* Addressed review comments

* Add test for default vote case

* Fix logs

* Remove unused functions

* Meter default eth1 votes

* Fix comments

* Address review comments; remove unused dependency

* Disable/delete two outdated tests

* Bump eth1 default vote warn to error

* Delete outdated eth1 test

Co-authored-by: Pawan Dhananjay <pawandhananjay@gmail.com>

eth2/state_processing/src/per_epoch_processing/apply_rewards.rs

@@ -33,7 +33,7 @@ impl std::ops::AddAssign for Delta {
 
 /// Apply attester and proposer rewards.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 pub fn process_rewards_and_penalties<T: EthSpec>(
     state: &mut BeaconState<T>,
     validator_statuses: &mut ValidatorStatuses,
@@ -67,7 +67,7 @@ pub fn process_rewards_and_penalties<T: EthSpec>(
 
 /// For each attesting validator, reward the proposer who was first to include their attestation.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 fn get_proposer_deltas<T: EthSpec>(
     deltas: &mut Vec<Delta>,
     state: &BeaconState<T>,
@@ -100,7 +100,7 @@ fn get_proposer_deltas<T: EthSpec>(
 
 /// Apply rewards for participation in attestations during the previous epoch.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 fn get_attestation_deltas<T: EthSpec>(
     deltas: &mut Vec<Delta>,
     state: &BeaconState<T>,
@@ -133,7 +133,7 @@ fn get_attestation_deltas<T: EthSpec>(
 
 /// Determine the delta for a single validator, sans proposer rewards.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 fn get_attestation_delta<T: EthSpec>(
     validator: &ValidatorStatus,
     total_balances: &TotalBalances,

eth2/state_processing/src/per_epoch_processing/process_slashings.rs

@@ -2,7 +2,7 @@ use types::{BeaconStateError as Error, *};
 
 /// Process slashings.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 pub fn process_slashings<T: EthSpec>(
     state: &mut BeaconState<T>,
     total_balance: u64,

eth2/state_processing/src/per_epoch_processing/registry_updates.rs

@@ -5,7 +5,7 @@ use types::*;
 
 /// Performs a validator registry update, if required.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 pub fn process_registry_updates<T: EthSpec>(
     state: &mut BeaconState<T>,
     spec: &ChainSpec,
@@ -15,10 +15,6 @@ pub fn process_registry_updates<T: EthSpec>(
     // We assume it's safe to re-order the change in eligibility and `initiate_validator_exit`.
     // Rest assured exiting validators will still be exited in the same order as in the spec.
     let current_epoch = state.current_epoch();
-    let is_eligible = |validator: &Validator| {
-        validator.activation_eligibility_epoch == spec.far_future_epoch
-            && validator.effective_balance == spec.max_effective_balance
-    };
     let is_exiting_validator = |validator: &Validator| {
         validator.is_active_at(current_epoch)
             && validator.effective_balance <= spec.ejection_balance
@@ -27,16 +23,18 @@ pub fn process_registry_updates<T: EthSpec>(
         .validators
         .iter()
         .enumerate()
-        .filter(|(_, validator)| is_eligible(validator) || is_exiting_validator(validator))
+        .filter(|(_, validator)| {
+            validator.is_eligible_for_activation_queue(spec) || is_exiting_validator(validator)
+        })
         .partition_map(|(index, validator)| {
-            if is_eligible(validator) {
+            if validator.is_eligible_for_activation_queue(spec) {
                 Either::Left(index)
             } else {
                 Either::Right(index)
             }
         });
     for index in eligible_validators {
-        state.validators[index].activation_eligibility_epoch = current_epoch;
+        state.validators[index].activation_eligibility_epoch = current_epoch + 1;
     }
     for index in exiting_validators {
         initiate_validator_exit(state, index, spec)?;
@@ -47,22 +45,17 @@ pub fn process_registry_updates<T: EthSpec>(
         .validators
         .iter()
         .enumerate()
-        .filter(|(_, validator)| {
-            validator.activation_eligibility_epoch != spec.far_future_epoch
-                && validator.activation_epoch
-                    >= state.compute_activation_exit_epoch(state.finalized_checkpoint.epoch, spec)
-        })
-        .sorted_by_key(|(_, validator)| validator.activation_eligibility_epoch)
+        .filter(|(_, validator)| validator.is_eligible_for_activation(state, spec))
+        .sorted_by_key(|(index, validator)| (validator.activation_eligibility_epoch, *index))
         .map(|(index, _)| index)
         .collect_vec();
 
+    // Dequeue validators for activation up to churn limit
     let churn_limit = state.get_churn_limit(spec)? as usize;
     let delayed_activation_epoch = state.compute_activation_exit_epoch(current_epoch, spec);
     for index in activation_queue.into_iter().take(churn_limit) {
         let validator = &mut state.validators[index];
-        if validator.activation_epoch == spec.far_future_epoch {
-            validator.activation_epoch = delayed_activation_epoch;
-        }
+        validator.activation_epoch = delayed_activation_epoch;
     }
 
     Ok(())

eth2/state_processing/src/per_epoch_processing/validator_statuses.rs

@@ -144,7 +144,7 @@ impl ValidatorStatuses {
     /// - Active validators
     /// - Total balances for the current and previous epochs.
     ///
-    /// Spec v0.9.1
+    /// Spec v0.10.1
     pub fn new<T: EthSpec>(
         state: &BeaconState<T>,
         spec: &ChainSpec,
@@ -184,7 +184,7 @@ impl ValidatorStatuses {
     /// Process some attestations from the given `state` updating the `statuses` and
     /// `total_balances` fields.
     ///
-    /// Spec v0.9.1
+    /// Spec v0.10.1
     pub fn process_attestations<T: EthSpec>(
         &mut self,
         state: &BeaconState<T>,
@@ -263,7 +263,7 @@ impl ValidatorStatuses {
 /// Returns `true` if the attestation's FFG target is equal to the hash of the `state`'s first
 /// beacon block in the given `epoch`.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 fn target_matches_epoch_start_block<T: EthSpec>(
     a: &PendingAttestation<T>,
     state: &BeaconState<T>,
@@ -278,7 +278,7 @@ fn target_matches_epoch_start_block<T: EthSpec>(
 /// Returns `true` if a `PendingAttestation` and `BeaconState` share the same beacon block hash for
 /// the current slot of the `PendingAttestation`.
 ///
-/// Spec v0.9.1
+/// Spec v0.10.1
 fn has_common_beacon_block_root<T: EthSpec>(
     a: &PendingAttestation<T>,
     state: &BeaconState<T>,