Make modified helpers in electra fork aware

consensus/state_processing/src/per_epoch_processing/registry_updates.rs

@@ -19,19 +19,20 @@ pub fn process_registry_updates<E: EthSpec>(
         validator.is_active_at(current_epoch)
             && validator.effective_balance <= spec.ejection_balance
     };
+    let fork_name = state.fork_name_unchecked();
     let indices_to_update: Vec<_> = state
         .validators()
         .iter()
         .enumerate()
         .filter(|(_, validator)| {
-            validator.is_eligible_for_activation_queue(spec) || is_ejectable(validator)
+            validator.is_eligible_for_activation_queue(&fork_name, spec) || is_ejectable(validator)
         })
         .map(|(idx, _)| idx)
         .collect();
 
     for index in indices_to_update {
         let validator = state.get_validator_mut(index)?;
-        if validator.is_eligible_for_activation_queue(spec) {
+        if validator.is_eligible_for_activation_queue(&fork_name, spec) {
             validator.activation_eligibility_epoch = current_epoch.safe_add(1)?;
         }
         if is_ejectable(validator) {

consensus/state_processing/src/per_epoch_processing/single_pass.rs

@@ -466,7 +466,7 @@ fn process_single_registry_update(
 ) -> Result<(), Error> {
     let current_epoch = state_ctxt.current_epoch;
 
-    if validator.is_eligible_for_activation_queue(spec) {
+    if validator.is_eligible_for_activation_queue(&state_ctxt.fork_name, spec) {
         validator.make_mut()?.activation_eligibility_epoch = current_epoch.safe_add(1)?;
     }
 

consensus/types/src/validator.rs

@@ -1,5 +1,5 @@
 use crate::{
-    test_utils::TestRandom, Address, BeaconState, ChainSpec, Epoch, EthSpec, Hash256,
+    test_utils::TestRandom, Address, BeaconState, ChainSpec, Epoch, EthSpec, ForkName, Hash256,
     PublicKeyBytes,
 };
 use serde::{Deserialize, Serialize};
@@ -57,8 +57,34 @@ impl Validator {
 
     /// Returns `true` if the validator is eligible to join the activation queue.
     ///
-    /// Modified in electra
-    pub fn is_eligible_for_activation_queue(&self, spec: &ChainSpec) -> bool {
+    /// Calls the appropriate function given the fork_name.
+    pub fn is_eligible_for_activation_queue(
+        &self,
+        current_fork: &ForkName,
+        spec: &ChainSpec,
+    ) -> bool {
+        match current_fork {
+            ForkName::Base
+            | ForkName::Altair
+            | ForkName::Bellatrix
+            | ForkName::Capella
+            | ForkName::Deneb => self.is_eligible_for_activation_queue_base(spec),
+            ForkName::Electra => self.is_eligible_for_activation_queue_electra(spec),
+        }
+    }
+
+    /// Returns `true` if the validator is eligible to join the activation queue.
+    ///
+    /// Spec v0.12.1
+    pub fn is_eligible_for_activation_queue_base(&self, spec: &ChainSpec) -> bool {
+        self.activation_eligibility_epoch == spec.far_future_epoch
+            && self.effective_balance == spec.max_effective_balance
+    }
+
+    /// Returns `true` if the validator is eligible to join the activation queue.
+    ///
+    /// Modified in electra as part of EIP 7251.
+    pub fn is_eligible_for_activation_queue_electra(&self, spec: &ChainSpec) -> bool {
         self.activation_eligibility_epoch == spec.far_future_epoch
             && self.effective_balance >= spec.min_activation_balance
     }