Altair consensus changes and refactors (#2279)

## Proposed Changes

Implement the consensus changes necessary for the upcoming Altair hard fork.

## Additional Info

This is quite a heavy refactor, with pivotal types like the `BeaconState` and `BeaconBlock` changing from structs to enums. This ripples through the whole codebase with field accesses changing to methods, e.g. `state.slot` => `state.slot()`.


Co-authored-by: realbigsean <seananderson33@gmail.com>

beacon_node/operation_pool/src/attestation.rs

@@ -1,7 +1,13 @@
 use crate::max_cover::MaxCover;
-use state_processing::common::{get_attesting_indices, get_base_reward};
+use state_processing::common::{
+    altair, base, get_attestation_participation_flag_indices, get_attesting_indices,
+};
 use std::collections::HashMap;
-use types::{Attestation, BeaconState, BitList, ChainSpec, EthSpec};
+use types::{
+    beacon_state::BeaconStateBase,
+    consts::altair::{PARTICIPATION_FLAG_WEIGHTS, WEIGHT_DENOMINATOR},
+    Attestation, BeaconState, BitList, ChainSpec, EthSpec,
+};
 
 #[derive(Debug, Clone)]
 pub struct AttMaxCover<'a, T: EthSpec> {
@@ -18,7 +24,22 @@ impl<'a, T: EthSpec> AttMaxCover<'a, T> {
         total_active_balance: u64,
         spec: &ChainSpec,
     ) -> Option<Self> {
-        let fresh_validators = earliest_attestation_validators(att, state);
+        if let BeaconState::Base(ref base_state) = state {
+            Self::new_for_base(att, state, base_state, total_active_balance, spec)
+        } else {
+            Self::new_for_altair(att, state, total_active_balance, spec)
+        }
+    }
+
+    /// Initialise an attestation cover object for base/phase0 hard fork.
+    pub fn new_for_base(
+        att: &'a Attestation<T>,
+        state: &BeaconState<T>,
+        base_state: &BeaconStateBase<T>,
+        total_active_balance: u64,
+        spec: &ChainSpec,
+    ) -> Option<Self> {
+        let fresh_validators = earliest_attestation_validators(att, state, base_state);
         let committee = state
             .get_beacon_committee(att.data.slot, att.data.index)
             .ok()?;
@@ -27,10 +48,14 @@ impl<'a, T: EthSpec> AttMaxCover<'a, T> {
             .iter()
             .map(|i| *i as u64)
             .flat_map(|validator_index| {
-                let reward =
-                    get_base_reward(state, validator_index as usize, total_active_balance, spec)
-                        .ok()?
-                        / spec.proposer_reward_quotient;
+                let reward = base::get_base_reward(
+                    state,
+                    validator_index as usize,
+                    total_active_balance,
+                    spec,
+                )
+                .ok()?
+                .checked_div(spec.proposer_reward_quotient)?;
                 Some((validator_index, reward))
             })
             .collect();
@@ -39,6 +64,62 @@ impl<'a, T: EthSpec> AttMaxCover<'a, T> {
             fresh_validators_rewards,
         })
     }
+
+    /// Initialise an attestation cover object for Altair or later.
+    pub fn new_for_altair(
+        att: &'a Attestation<T>,
+        state: &BeaconState<T>,
+        total_active_balance: u64,
+        spec: &ChainSpec,
+    ) -> Option<Self> {
+        let committee = state
+            .get_beacon_committee(att.data.slot, att.data.index)
+            .ok()?;
+        let attesting_indices =
+            get_attesting_indices::<T>(committee.committee, &att.aggregation_bits).ok()?;
+
+        let participation_list = if att.data.target.epoch == state.current_epoch() {
+            state.current_epoch_participation().ok()?
+        } else if att.data.target.epoch == state.previous_epoch() {
+            state.previous_epoch_participation().ok()?
+        } else {
+            return None;
+        };
+
+        let inclusion_delay = state.slot().as_u64().checked_sub(att.data.slot.as_u64())?;
+        let att_participation_flags =
+            get_attestation_participation_flag_indices(state, &att.data, inclusion_delay, spec)
+                .ok()?;
+
+        let fresh_validators_rewards = attesting_indices
+            .iter()
+            .filter_map(|&index| {
+                let mut proposer_reward_numerator = 0;
+                let participation = participation_list.get(index)?;
+
+                let base_reward =
+                    altair::get_base_reward(state, index, total_active_balance, spec).ok()?;
+
+                for (flag_index, weight) in PARTICIPATION_FLAG_WEIGHTS.iter().enumerate() {
+                    if att_participation_flags.contains(&flag_index)
+                        && !participation.has_flag(flag_index).ok()?
+                    {
+                        proposer_reward_numerator += base_reward.checked_mul(*weight)?;
+                    }
+                }
+
+                let proposer_reward = proposer_reward_numerator
+                    .checked_div(WEIGHT_DENOMINATOR.checked_mul(spec.proposer_reward_quotient)?)?;
+
+                Some((index as u64, proposer_reward)).filter(|_| proposer_reward != 0)
+            })
+            .collect();
+
+        Some(Self {
+            att,
+            fresh_validators_rewards,
+        })
+    }
 }
 
 impl<'a, T: EthSpec> MaxCover for AttMaxCover<'a, T> {
@@ -58,6 +139,11 @@ impl<'a, T: EthSpec> MaxCover for AttMaxCover<'a, T> {
     /// confusing committees when updating covering sets, we update only those attestations
     /// whose slot and index match the attestation being included in the solution, by the logic
     /// that a slot and index uniquely identify a committee.
+    ///
+    /// We completely remove any validator covered by another attestation. This is close to optimal
+    /// because including two attestations on chain to satisfy different participation bits is
+    /// impossible without the validator double voting. I.e. it is only suboptimal in the presence
+    /// of slashable voting, which is rare.
     fn update_covering_set(
         &mut self,
         best_att: &Attestation<T>,
@@ -81,19 +167,20 @@ impl<'a, T: EthSpec> MaxCover for AttMaxCover<'a, T> {
 /// is judged against the state's `current_epoch_attestations` or `previous_epoch_attestations`
 /// depending on when it was created, and all those validators who have already attested are
 /// removed from the `aggregation_bits` before returning it.
-// TODO: This could be optimised with a map from validator index to whether that validator has
-// attested in each of the current and previous epochs. Currently quadratic in number of validators.
+///
+/// This isn't optimal, but with the Altair fork this code is obsolete and not worth upgrading.
 pub fn earliest_attestation_validators<T: EthSpec>(
     attestation: &Attestation<T>,
     state: &BeaconState<T>,
+    base_state: &BeaconStateBase<T>,
 ) -> BitList<T::MaxValidatorsPerCommittee> {
     // Bitfield of validators whose attestations are new/fresh.
     let mut new_validators = attestation.aggregation_bits.clone();
 
     let state_attestations = if attestation.data.target.epoch == state.current_epoch() {
-        &state.current_epoch_attestations
+        &base_state.current_epoch_attestations
     } else if attestation.data.target.epoch == state.previous_epoch() {
-        &state.previous_epoch_attestations
+        &base_state.previous_epoch_attestations
     } else {
         return BitList::with_capacity(0).unwrap();
     };

beacon_node/operation_pool/src/attester_slashing.rs

@@ -1,7 +1,7 @@
 use crate::max_cover::MaxCover;
 use state_processing::per_block_processing::get_slashable_indices_modular;
 use std::collections::{HashMap, HashSet};
-use types::{AttesterSlashing, BeaconState, ChainSpec, EthSpec};
+use types::{AttesterSlashing, BeaconState, EthSpec};
 
 #[derive(Debug, Clone)]
 pub struct AttesterSlashingMaxCover<'a, T: EthSpec> {
@@ -14,7 +14,6 @@ impl<'a, T: EthSpec> AttesterSlashingMaxCover<'a, T> {
         slashing: &'a AttesterSlashing<T>,
         proposer_slashing_indices: &HashSet<u64>,
         state: &BeaconState<T>,
-        spec: &ChainSpec,
     ) -> Option<Self> {
         let mut effective_balances: HashMap<u64, u64> = HashMap::new();
         let epoch = state.current_epoch();
@@ -22,21 +21,18 @@ impl<'a, T: EthSpec> AttesterSlashingMaxCover<'a, T> {
         let slashable_validators =
             get_slashable_indices_modular(state, slashing, |index, validator| {
                 validator.is_slashable_at(epoch) && !proposer_slashing_indices.contains(&index)
-            });
-
-        if let Ok(validators) = slashable_validators {
-            for vd in &validators {
-                let eff_balance = state.get_effective_balance(*vd as usize, spec).ok()?;
-                effective_balances.insert(*vd, eff_balance);
-            }
-
-            Some(Self {
-                slashing,
-                effective_balances,
             })
-        } else {
-            None
+            .ok()?;
+
+        for vd in slashable_validators {
+            let eff_balance = state.get_effective_balance(vd as usize).ok()?;
+            effective_balances.insert(vd, eff_balance);
         }
+
+        Some(Self {
+            slashing,
+            effective_balances,
+        })
     }
 }