add electra fork enabled fn to ForkName impl

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -1341,7 +1341,10 @@ pub fn verify_committee_index<E: EthSpec>(
     attestation: AttestationRef<E>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
-    if spec.fork_name_at_slot::<E>(attestation.data().slot) >= ForkName::Electra {
+    if spec
+        .fork_name_at_slot::<E>(attestation.data().slot)
+        .electra_enabled()
+    {
         // Check to ensure that the attestation is for a single committee.
         let num_committee_bits = get_committee_indices::<E>(
             attestation

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1994,7 +1994,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             };
         drop(cache_timer);
 
-        if self.spec.fork_name_at_slot::<T::EthSpec>(request_slot) >= ForkName::Electra {
+        if self
+            .spec
+            .fork_name_at_slot::<T::EthSpec>(request_slot)
+            .electra_enabled()
+        {
             let mut committee_bits = BitVector::default();
             if committee_len > 0 {
                 committee_bits.set(request_index as usize, true)?;

beacon_node/beacon_chain/src/early_attester_cache.rs

@@ -123,7 +123,7 @@ impl<E: EthSpec> EarlyAttesterCache<E> {
             item.committee_lengths
                 .get_committee_length::<E>(request_slot, request_index, spec)?;
 
-        let attestation = if spec.fork_name_at_slot::<E>(request_slot) >= ForkName::Electra {
+        let attestation = if spec.fork_name_at_slot::<E>(request_slot).electra_enabled() {
             let mut committee_bits = BitVector::default();
             if committee_len > 0 {
                 committee_bits

beacon_node/beacon_chain/src/test_utils.rs

@@ -1033,7 +1033,7 @@ where
             *state.get_block_root(target_slot)?
         };
 
-        if self.spec.fork_name_at_slot::<E>(slot) >= ForkName::Electra {
+        if self.spec.fork_name_at_slot::<E>(slot).electra_enabled() {
             let mut committee_bits = BitVector::default();
             committee_bits.set(index as usize, true)?;
             Ok(Attestation::Electra(AttestationElectra {
@@ -1376,7 +1376,7 @@ where
 
                         let fork_name = self.spec.fork_name_at_slot::<E>(slot);
 
-                        let aggregate = if fork_name >= ForkName::Electra {
+                        let aggregate = if fork_name.electra_enabled() {
                             self.chain
                                 .get_aggregated_attestation_electra(
                                     slot,
@@ -1541,7 +1541,7 @@ where
 
         let fork_name = self.spec.fork_name_at_slot::<E>(Slot::new(0));
 
-        let mut attestation_1 = if fork_name >= ForkName::Electra {
+        let mut attestation_1 = if fork_name.electra_enabled() {
             IndexedAttestation::Electra(IndexedAttestationElectra {
                 attesting_indices: VariableList::new(validator_indices).unwrap(),
                 data: AttestationData {
@@ -1623,7 +1623,7 @@ where
             }
         }
 
-        if fork_name >= ForkName::Electra {
+        if fork_name.electra_enabled() {
             AttesterSlashing::Electra(AttesterSlashingElectra {
                 attestation_1: attestation_1.as_electra().unwrap().clone(),
                 attestation_2: attestation_2.as_electra().unwrap().clone(),
@@ -1657,7 +1657,7 @@ where
             },
         };
 
-        let (mut attestation_1, mut attestation_2) = if fork_name >= ForkName::Electra {
+        let (mut attestation_1, mut attestation_2) = if fork_name.electra_enabled() {
             let attestation_1 = IndexedAttestationElectra {
                 attesting_indices: VariableList::new(validator_indices_1).unwrap(),
                 data: data.clone(),
@@ -1735,7 +1735,7 @@ where
             }
         }
 
-        if fork_name >= ForkName::Electra {
+        if fork_name.electra_enabled() {
             AttesterSlashing::Electra(AttesterSlashingElectra {
                 attestation_1: attestation_1.as_electra().unwrap().clone(),
                 attestation_2: attestation_2.as_electra().unwrap().clone(),

beacon_node/beacon_chain/tests/block_verification.rs

@@ -668,7 +668,7 @@ async fn invalid_signature_attester_slashing() {
         let mut snapshots = chain_segment.clone();
         let fork_name = harness.chain.spec.fork_name_at_slot::<E>(Slot::new(0));
 
-        let attester_slashing = if fork_name >= ForkName::Electra {
+        let attester_slashing = if fork_name.electra_enabled() {
             let indexed_attestation = IndexedAttestationElectra {
                 attesting_indices: vec![0].into(),
                 data: AttestationData {

beacon_node/beacon_chain/tests/store_tests.rs

@@ -1025,7 +1025,7 @@ async fn multiple_attestations_per_block() {
         let slot = snapshot.beacon_block.slot();
         let fork_name = harness.chain.spec.fork_name_at_slot::<E>(slot);
 
-        if fork_name >= ForkName::Electra {
+        if fork_name.electra_enabled() {
             assert_eq!(
                 snapshot
                     .beacon_block

beacon_node/client/src/notifier.rs

@@ -551,7 +551,7 @@ async fn electra_readiness_logging<T: BeaconChainTypes>(
         .snapshot
         .beacon_state
         .fork_name_unchecked()
-        >= ForkName::Electra;
+        .electra_enabled();
 
     let has_execution_layer = beacon_chain.execution_layer.is_some();
 

beacon_node/operation_pool/src/lib.rs

@@ -286,7 +286,7 @@ impl<E: EthSpec> OperationPool<E> {
         // TODO(electra): Work out how to do this more elegantly. This is a bit of a hack.
         let mut all_attestations = self.attestations.write();
 
-        if fork_name >= ForkName::Electra {
+        if fork_name.electra_enabled() {
             all_attestations.aggregate_across_committees(prev_epoch_key);
             all_attestations.aggregate_across_committees(curr_epoch_key);
         }

consensus/types/src/attestation.rs

@@ -1,5 +1,4 @@
 use crate::slot_data::SlotData;
-use crate::ForkName;
 use crate::{test_utils::TestRandom, Hash256, Slot};
 use derivative::Derivative;
 use safe_arith::ArithError;
@@ -95,7 +94,7 @@ impl<E: EthSpec> Attestation<E> {
         data: AttestationData,
         spec: &ChainSpec,
     ) -> Result<Self, Error> {
-        if spec.fork_name_at_slot::<E>(data.slot) >= ForkName::Electra {
+        if spec.fork_name_at_slot::<E>(data.slot).electra_enabled() {
             let mut committee_bits: BitVector<E::MaxCommitteesPerSlot> = BitVector::default();
             committee_bits
                 .set(committee_index, true)

consensus/types/src/chain_spec.rs

@@ -376,7 +376,7 @@ impl ChainSpec {
         state: &BeaconState<E>,
     ) -> u64 {
         let fork_name = state.fork_name_unchecked();
-        if fork_name >= ForkName::Electra {
+        if fork_name.electra_enabled() {
             self.min_slashing_penalty_quotient_electra
         } else if fork_name >= ForkName::Bellatrix {
             self.min_slashing_penalty_quotient_bellatrix

consensus/types/src/fork_name.rs

@@ -119,6 +119,10 @@ impl ForkName {
             ForkName::Electra => None,
         }
     }
+
+    pub fn electra_enabled(self) -> bool {
+        self >= ForkName::Electra
+    }
 }
 
 /// Map a fork name into a fork-versioned superstruct type like `BeaconBlock`.

consensus/types/src/validator.rs

@@ -63,7 +63,7 @@ impl Validator {
         spec: &ChainSpec,
         current_fork: ForkName,
     ) -> bool {
-        if current_fork >= ForkName::Electra {
+        if current_fork.electra_enabled() {
             self.is_eligible_for_activation_queue_electra(spec)
         } else {
             self.is_eligible_for_activation_queue_base(spec)
@@ -162,7 +162,7 @@ impl Validator {
         spec: &ChainSpec,
         current_fork: ForkName,
     ) -> bool {
-        if current_fork >= ForkName::Electra {
+        if current_fork.electra_enabled() {
             self.is_fully_withdrawable_at_electra(balance, epoch, spec)
         } else {
             self.is_fully_withdrawable_at_capella(balance, epoch, spec)
@@ -202,7 +202,7 @@ impl Validator {
         spec: &ChainSpec,
         current_fork: ForkName,
     ) -> bool {
-        if current_fork >= ForkName::Electra {
+        if current_fork.electra_enabled() {
             self.is_partially_withdrawable_validator_electra(balance, spec)
         } else {
             self.is_partially_withdrawable_validator_capella(balance, spec)

testing/ef_tests/src/cases/fork_choice.rs

@@ -180,7 +180,7 @@ impl<E: EthSpec> LoadCase for ForkChoiceTest<E> {
                     })
                 }
                 Step::Attestation { attestation } => {
-                    if fork_name >= ForkName::Electra {
+                    if fork_name.electra_enabled() {
                         ssz_decode_file(&path.join(format!("{}.ssz_snappy", attestation))).map(
                             |attestation| Step::Attestation {
                                 attestation: Attestation::Electra(attestation),
@@ -195,7 +195,7 @@ impl<E: EthSpec> LoadCase for ForkChoiceTest<E> {
                     }
                 }
                 Step::AttesterSlashing { attester_slashing } => {
-                    if fork_name >= ForkName::Electra {
+                    if fork_name.electra_enabled() {
                         ssz_decode_file(&path.join(format!("{}.ssz_snappy", attester_slashing)))
                             .map(|attester_slashing| Step::AttesterSlashing {
                                 attester_slashing: AttesterSlashing::Electra(attester_slashing),