diff --git a/beacon_node/beacon_chain/src/attestation_rewards.rs b/beacon_node/beacon_chain/src/attestation_rewards.rs
index d48a83130e..ce8530c2ce 100644
--- a/beacon_node/beacon_chain/src/attestation_rewards.rs
+++ b/beacon_node/beacon_chain/src/attestation_rewards.rs
@@ -30,7 +30,7 @@ use store::consts::altair::{
     TIMELY_TARGET_FLAG_INDEX,
 };
 use types::consts::altair::WEIGHT_DENOMINATOR;
-use types::{BeaconState, Epoch, EthSpec, RelativeEpoch};
+use types::{BeaconState, Epoch, EthSpec, FeatureName, RelativeEpoch};
 
 impl<T: BeaconChainTypes> BeaconChain<T> {
     pub fn compute_attestation_rewards(
@@ -51,13 +51,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .get_state(&state_root, Some(state_slot))?
             .ok_or(BeaconChainError::MissingBeaconState(state_root))?;
 
-        match state {
-            BeaconState::Base(_) => self.compute_attestation_rewards_base(state, validators),
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => self.compute_attestation_rewards_altair(state, validators),
+        if state.has_feature(FeatureName::Altair) {
+            self.compute_attestation_rewards_altair(state, validators)
+        } else {
+            self.compute_attestation_rewards_base(state, validators)
         }
     }
 
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index ab3064f6f1..14609ccb66 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -4838,23 +4838,19 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         // If required, start the process of loading an execution payload from the EL early. This
         // allows it to run concurrently with things like attestation packing.
-        let prepare_payload_handle = match &state {
-            BeaconState::Base(_) | BeaconState::Altair(_) => None,
-            BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => {
-                let prepare_payload_handle = get_execution_payload(
-                    self.clone(),
-                    &state,
-                    parent_root,
-                    proposer_index,
-                    builder_params,
-                    builder_boost_factor,
-                    block_production_version,
-                )?;
-                Some(prepare_payload_handle)
-            }
+        let prepare_payload_handle = if state.has_feature(FeatureName::Bellatrix) {
+            let prepare_payload_handle = get_execution_payload(
+                self.clone(),
+                &state,
+                parent_root,
+                proposer_index,
+                builder_params,
+                builder_boost_factor,
+                block_production_version,
+            )?;
+            Some(prepare_payload_handle)
+        } else {
+            None
         };
 
         let (mut proposer_slashings, mut attester_slashings, mut voluntary_exits) =
diff --git a/beacon_node/beacon_chain/src/execution_payload.rs b/beacon_node/beacon_chain/src/execution_payload.rs
index cbffe36342..61e5e21090 100644
--- a/beacon_node/beacon_chain/src/execution_payload.rs
+++ b/beacon_node/beacon_chain/src/execution_payload.rs
@@ -411,19 +411,16 @@ pub fn get_execution_payload<T: BeaconChainTypes>(
     let random = *state.get_randao_mix(current_epoch)?;
     let latest_execution_payload_header_block_hash =
         state.latest_execution_payload_header()?.block_hash();
-    let withdrawals = match state {
-        &BeaconState::Capella(_) | &BeaconState::Deneb(_) | &BeaconState::Electra(_) => {
-            Some(get_expected_withdrawals(state, spec)?.into())
-        }
-        &BeaconState::Bellatrix(_) => None,
-        // These shouldn't happen but they're here to make the pattern irrefutable
-        &BeaconState::Base(_) | &BeaconState::Altair(_) => None,
+    let withdrawals = if state.has_feature(FeatureName::Capella) {
+        Some(get_expected_withdrawals(state, spec)?.into())
+    } else {
+        None
     };
-    let parent_beacon_block_root = match state {
-        BeaconState::Deneb(_) | BeaconState::Electra(_) => Some(parent_block_root),
-        BeaconState::Bellatrix(_) | BeaconState::Capella(_) => None,
-        // These shouldn't happen but they're here to make the pattern irrefutable
-        BeaconState::Base(_) | BeaconState::Altair(_) => None,
+
+    let parent_beacon_block_root = if state.has_feature(FeatureName::Deneb) {
+        Some(parent_block_root)
+    } else {
+        None
     };
 
     // Spawn a task to obtain the execution payload from the EL via a series of async calls. The
diff --git a/consensus/fork_choice/src/fork_choice.rs b/consensus/fork_choice/src/fork_choice.rs
index 08d8ee3a2c..65fbeb4a40 100644
--- a/consensus/fork_choice/src/fork_choice.rs
+++ b/consensus/fork_choice/src/fork_choice.rs
@@ -747,27 +747,27 @@ where
             if let Some((parent_justified, parent_finalized)) = parent_checkpoints {
                 (parent_justified, parent_finalized)
             } else {
-                let justification_and_finalization_state =
-                    if block.fork_name_unchecked().has_feature(FeatureName::Altair) {
-                        // NOTE: Processing justification & finalization requires the progressive
-                        // balances cache, but we cannot initialize it here as we only have an
-                        // immutable reference. The state *should* have come straight from block
-                        // processing, which initialises the cache, but if we add other `on_block`
-                        // calls in future it could be worth passing a mutable reference.
-                        per_epoch_processing::altair::process_justification_and_finalization(state)?
-                    } else {
-                        let mut validator_statuses =
-                            per_epoch_processing::base::ValidatorStatuses::new(state, spec)
-                                .map_err(Error::ValidatorStatuses)?;
-                        validator_statuses
-                            .process_attestations(state)
+                let justification_and_finalization_state = if block.has_feature(FeatureName::Altair)
+                {
+                    // NOTE: Processing justification & finalization requires the progressive
+                    // balances cache, but we cannot initialize it here as we only have an
+                    // immutable reference. The state *should* have come straight from block
+                    // processing, which initialises the cache, but if we add other `on_block`
+                    // calls in future it could be worth passing a mutable reference.
+                    per_epoch_processing::altair::process_justification_and_finalization(state)?
+                } else {
+                    let mut validator_statuses =
+                        per_epoch_processing::base::ValidatorStatuses::new(state, spec)
                             .map_err(Error::ValidatorStatuses)?;
-                        per_epoch_processing::base::process_justification_and_finalization(
-                            state,
-                            &validator_statuses.total_balances,
-                            spec,
-                        )?
-                    };
+                    validator_statuses
+                        .process_attestations(state)
+                        .map_err(Error::ValidatorStatuses)?;
+                    per_epoch_processing::base::process_justification_and_finalization(
+                        state,
+                        &validator_statuses.total_balances,
+                        spec,
+                    )?
+                };
 
                 (
                     justification_and_finalization_state.current_justified_checkpoint(),
diff --git a/consensus/state_processing/src/common/get_attestation_participation.rs b/consensus/state_processing/src/common/get_attestation_participation.rs
index fc09dad1f4..12493c4a0e 100644
--- a/consensus/state_processing/src/common/get_attestation_participation.rs
+++ b/consensus/state_processing/src/common/get_attestation_participation.rs
@@ -7,7 +7,7 @@ use types::{
     },
     BeaconStateError as Error,
 };
-use types::{AttestationData, BeaconState, ChainSpec, EthSpec};
+use types::{AttestationData, BeaconState, ChainSpec, EthSpec, FeatureName};
 
 /// Get the participation flags for a valid attestation.
 ///
@@ -44,22 +44,14 @@ pub fn get_attestation_participation_flag_indices<E: EthSpec>(
     if is_matching_source && inclusion_delay <= E::slots_per_epoch().integer_sqrt() {
         participation_flag_indices.push(TIMELY_SOURCE_FLAG_INDEX);
     }
-    match state {
-        &BeaconState::Base(_)
-        | &BeaconState::Altair(_)
-        | &BeaconState::Bellatrix(_)
-        | &BeaconState::Capella(_) => {
-            if is_matching_target && inclusion_delay <= E::slots_per_epoch() {
-                participation_flag_indices.push(TIMELY_TARGET_FLAG_INDEX);
-            }
-        }
-        &BeaconState::Deneb(_) | &BeaconState::Electra(_) => {
-            if is_matching_target {
-                // [Modified in Deneb:EIP7045]
-                participation_flag_indices.push(TIMELY_TARGET_FLAG_INDEX);
-            }
-        }
+
+    if state.has_feature(FeatureName::Deneb) && is_matching_target {
+        // [Modified in Deneb:EIP7045]
+        participation_flag_indices.push(TIMELY_TARGET_FLAG_INDEX);
+    } else if is_matching_target && inclusion_delay <= E::slots_per_epoch() {
+        participation_flag_indices.push(TIMELY_TARGET_FLAG_INDEX);
     }
+
     if is_matching_head && inclusion_delay == spec.min_attestation_inclusion_delay {
         participation_flag_indices.push(TIMELY_HEAD_FLAG_INDEX);
     }
diff --git a/consensus/state_processing/src/common/slash_validator.rs b/consensus/state_processing/src/common/slash_validator.rs
index 520b58a8af..c2d10bbf18 100644
--- a/consensus/state_processing/src/common/slash_validator.rs
+++ b/consensus/state_processing/src/common/slash_validator.rs
@@ -55,15 +55,12 @@ pub fn slash_validator<E: EthSpec>(
     let whistleblower_index = opt_whistleblower_index.unwrap_or(proposer_index);
     let whistleblower_reward =
         validator_effective_balance.safe_div(spec.whistleblower_reward_quotient)?;
-    let proposer_reward = match state {
-        BeaconState::Base(_) => whistleblower_reward.safe_div(spec.proposer_reward_quotient)?,
-        BeaconState::Altair(_)
-        | BeaconState::Bellatrix(_)
-        | BeaconState::Capella(_)
-        | BeaconState::Deneb(_)
-        | BeaconState::Electra(_) => whistleblower_reward
+    let proposer_reward = if state.has_feature(FeatureName::Altair) {
+        whistleblower_reward
             .safe_mul(PROPOSER_WEIGHT)?
-            .safe_div(WEIGHT_DENOMINATOR)?,
+            .safe_div(WEIGHT_DENOMINATOR)?
+    } else {
+        whistleblower_reward.safe_div(spec.proposer_reward_quotient)?
     };
 
     // Ensure the whistleblower index is in the validator registry.
diff --git a/consensus/state_processing/src/common/update_progressive_balances_cache.rs b/consensus/state_processing/src/common/update_progressive_balances_cache.rs
index af843b3acb..b6ce5e7755 100644
--- a/consensus/state_processing/src/common/update_progressive_balances_cache.rs
+++ b/consensus/state_processing/src/common/update_progressive_balances_cache.rs
@@ -6,8 +6,8 @@ use crate::metrics::{
 use crate::{BlockProcessingError, EpochProcessingError};
 use lighthouse_metrics::set_gauge;
 use types::{
-    is_progressive_balances_enabled, BeaconState, BeaconStateError, ChainSpec, Epoch,
-    EpochTotalBalances, EthSpec, ParticipationFlags, ProgressiveBalancesCache, Validator,
+    BeaconState, BeaconStateError, ChainSpec, Epoch, EpochTotalBalances, EthSpec, FeatureName,
+    ParticipationFlags, ProgressiveBalancesCache, Validator,
 };
 
 /// Initializes the `ProgressiveBalancesCache` if it is unbuilt.
@@ -15,7 +15,7 @@ pub fn initialize_progressive_balances_cache<E: EthSpec>(
     state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<(), BeaconStateError> {
-    if !is_progressive_balances_enabled(state)
+    if !state.has_feature(FeatureName::Altair)
         || state.progressive_balances_cache().is_initialized()
     {
         return Ok(());
@@ -92,7 +92,7 @@ pub fn update_progressive_balances_on_attestation<E: EthSpec>(
     validator_effective_balance: u64,
     validator_slashed: bool,
 ) -> Result<(), BlockProcessingError> {
-    if is_progressive_balances_enabled(state) {
+    if state.has_feature(FeatureName::Altair) {
         state.progressive_balances_cache_mut().on_new_attestation(
             epoch,
             validator_slashed,
@@ -109,7 +109,7 @@ pub fn update_progressive_balances_on_slashing<E: EthSpec>(
     validator_index: usize,
     validator_effective_balance: u64,
 ) -> Result<(), BlockProcessingError> {
-    if is_progressive_balances_enabled(state) {
+    if state.has_feature(FeatureName::Altair) {
         let previous_epoch_participation = *state
             .previous_epoch_participation()?
             .get(validator_index)
@@ -135,7 +135,7 @@ pub fn update_progressive_balances_on_epoch_transition<E: EthSpec>(
     state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<(), EpochProcessingError> {
-    if is_progressive_balances_enabled(state) {
+    if state.has_feature(FeatureName::Altair) {
         state
             .progressive_balances_cache_mut()
             .on_epoch_transition(spec)?;
diff --git a/consensus/state_processing/src/per_block_processing.rs b/consensus/state_processing/src/per_block_processing.rs
index 2efa121882..058e0ff20d 100644
--- a/consensus/state_processing/src/per_block_processing.rs
+++ b/consensus/state_processing/src/per_block_processing.rs
@@ -188,7 +188,7 @@ pub fn per_block_processing<E: EthSpec, Payload: AbstractExecPayload<E>>(
         )?;
     }
 
-    if is_progressive_balances_enabled(state) {
+    if state.has_feature(FeatureName::Altair) {
         update_progressive_balances_metrics(state.progressive_balances_cache())?;
     }
 
@@ -453,15 +453,17 @@ pub fn process_execution_payload<E: EthSpec, Payload: AbstractExecPayload<E>>(
 /// repeatedly write code to treat these errors as false.
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#is_merge_transition_complete
 pub fn is_merge_transition_complete<E: EthSpec>(state: &BeaconState<E>) -> bool {
-    match state {
+    if state.has_feature(FeatureName::Capella) {
+        true
+    } else if state.has_feature(FeatureName::Bellatrix) {
         // We must check defaultness against the payload header with 0x0 roots, as that's what's meant
         // by `ExecutionPayloadHeader()` in the spec.
-        BeaconState::Bellatrix(_) => state
+        state
             .latest_execution_payload_header()
             .map(|header| !header.is_default_with_zero_roots())
-            .unwrap_or(false),
-        BeaconState::Electra(_) | BeaconState::Deneb(_) | BeaconState::Capella(_) => true,
-        BeaconState::Base(_) | BeaconState::Altair(_) => false,
+            .unwrap_or(false)
+    } else {
+        false
     }
 }
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#is_merge_transition_block
@@ -556,55 +558,52 @@ pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
     payload: Payload::Ref<'_>,
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
-    match state {
-        BeaconState::Bellatrix(_) => Ok(()),
-        BeaconState::Capella(_) | BeaconState::Deneb(_) | BeaconState::Electra(_) => {
-            let expected_withdrawals = get_expected_withdrawals(state, spec)?;
-            let expected_root = expected_withdrawals.tree_hash_root();
-            let withdrawals_root = payload.withdrawals_root()?;
+    if state.has_feature(FeatureName::Capella) {
+        let expected_withdrawals = get_expected_withdrawals(state, spec)?;
+        let expected_root = expected_withdrawals.tree_hash_root();
+        let withdrawals_root = payload.withdrawals_root()?;
 
-            if expected_root != withdrawals_root {
-                return Err(BlockProcessingError::WithdrawalsRootMismatch {
-                    expected: expected_root,
-                    found: withdrawals_root,
-                });
-            }
+        if expected_root != withdrawals_root {
+            return Err(BlockProcessingError::WithdrawalsRootMismatch {
+                expected: expected_root,
+                found: withdrawals_root,
+            });
+        }
 
-            for withdrawal in expected_withdrawals.iter() {
-                decrease_balance(
-                    state,
-                    withdrawal.validator_index as usize,
-                    withdrawal.amount,
-                )?;
-            }
+        for withdrawal in expected_withdrawals.iter() {
+            decrease_balance(
+                state,
+                withdrawal.validator_index as usize,
+                withdrawal.amount,
+            )?;
+        }
 
-            // Update the next withdrawal index if this block contained withdrawals
-            if let Some(latest_withdrawal) = expected_withdrawals.last() {
-                *state.next_withdrawal_index_mut()? = latest_withdrawal.index.safe_add(1)?;
+        // Update the next withdrawal index if this block contained withdrawals
+        if let Some(latest_withdrawal) = expected_withdrawals.last() {
+            *state.next_withdrawal_index_mut()? = latest_withdrawal.index.safe_add(1)?;
 
-                // Update the next validator index to start the next withdrawal sweep
-                if expected_withdrawals.len() == E::max_withdrawals_per_payload() {
-                    // Next sweep starts after the latest withdrawal's validator index
-                    let next_validator_index = latest_withdrawal
-                        .validator_index
-                        .safe_add(1)?
-                        .safe_rem(state.validators().len() as u64)?;
-                    *state.next_withdrawal_validator_index_mut()? = next_validator_index;
-                }
-            }
-
-            // Advance sweep by the max length of the sweep if there was not a full set of withdrawals
-            if expected_withdrawals.len() != E::max_withdrawals_per_payload() {
-                let next_validator_index = state
-                    .next_withdrawal_validator_index()?
-                    .safe_add(spec.max_validators_per_withdrawals_sweep)?
+            // Update the next validator index to start the next withdrawal sweep
+            if expected_withdrawals.len() == E::max_withdrawals_per_payload() {
+                // Next sweep starts after the latest withdrawal's validator index
+                let next_validator_index = latest_withdrawal
+                    .validator_index
+                    .safe_add(1)?
                     .safe_rem(state.validators().len() as u64)?;
                 *state.next_withdrawal_validator_index_mut()? = next_validator_index;
             }
-
-            Ok(())
         }
-        // these shouldn't even be encountered but they're here for completeness
-        BeaconState::Base(_) | BeaconState::Altair(_) => Ok(()),
+
+        // Advance sweep by the max length of the sweep if there was not a full set of withdrawals
+        if expected_withdrawals.len() != E::max_withdrawals_per_payload() {
+            let next_validator_index = state
+                .next_withdrawal_validator_index()?
+                .safe_add(spec.max_validators_per_withdrawals_sweep)?
+                .safe_rem(state.validators().len() as u64)?;
+            *state.next_withdrawal_validator_index_mut()? = next_validator_index;
+        }
+
+        Ok(())
+    } else {
+        Ok(())
     }
 }
diff --git a/consensus/state_processing/src/per_block_processing/process_operations.rs b/consensus/state_processing/src/per_block_processing/process_operations.rs
index 3aefcf8a9c..d608ea7ae2 100644
--- a/consensus/state_processing/src/per_block_processing/process_operations.rs
+++ b/consensus/state_processing/src/per_block_processing/process_operations.rs
@@ -262,29 +262,22 @@ pub fn process_attestations<E: EthSpec, Payload: AbstractExecPayload<E>>(
     ctxt: &mut ConsensusContext<E>,
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
-    match block_body {
-        BeaconBlockBodyRef::Base(_) => {
-            base::process_attestations(
-                state,
-                block_body.attestations(),
-                verify_signatures,
-                ctxt,
-                spec,
-            )?;
-        }
-        BeaconBlockBodyRef::Altair(_)
-        | BeaconBlockBodyRef::Bellatrix(_)
-        | BeaconBlockBodyRef::Capella(_)
-        | BeaconBlockBodyRef::Deneb(_)
-        | BeaconBlockBodyRef::Electra(_) => {
-            altair_deneb::process_attestations(
-                state,
-                block_body.attestations(),
-                verify_signatures,
-                ctxt,
-                spec,
-            )?;
-        }
+    if block_body.has_feature(FeatureName::Altair) {
+        altair_deneb::process_attestations(
+            state,
+            block_body.attestations(),
+            verify_signatures,
+            ctxt,
+            spec,
+        )?;
+    } else {
+        base::process_attestations(
+            state,
+            block_body.attestations(),
+            verify_signatures,
+            ctxt,
+            spec,
+        )?;
     }
     Ok(())
 }
diff --git a/consensus/state_processing/src/per_block_processing/signature_sets.rs b/consensus/state_processing/src/per_block_processing/signature_sets.rs
index 9468893f76..9a25809fb9 100644
--- a/consensus/state_processing/src/per_block_processing/signature_sets.rs
+++ b/consensus/state_processing/src/per_block_processing/signature_sets.rs
@@ -8,7 +8,7 @@ use std::borrow::Cow;
 use tree_hash::TreeHash;
 use types::{
     AbstractExecPayload, AggregateSignature, AttesterSlashing, BeaconBlockRef, BeaconState,
-    BeaconStateError, ChainSpec, DepositData, Domain, Epoch, EthSpec, Fork, Hash256,
+    BeaconStateError, ChainSpec, DepositData, Domain, Epoch, EthSpec, FeatureName, Fork, Hash256,
     InconsistentFork, IndexedAttestation, ProposerSlashing, PublicKey, PublicKeyBytes, Signature,
     SignedAggregateAndProof, SignedBeaconBlock, SignedBeaconBlockHeader,
     SignedBlsToExecutionChange, SignedContributionAndProof, SignedRoot, SignedVoluntaryExit,
@@ -387,22 +387,20 @@ where
     let exit = &signed_exit.message;
     let proposer_index = exit.validator_index as usize;
 
-    let domain = match state {
-        BeaconState::Base(_)
-        | BeaconState::Altair(_)
-        | BeaconState::Bellatrix(_)
-        | BeaconState::Capella(_) => spec.get_domain(
+    let domain = if state.has_feature(FeatureName::Deneb) {
+        // EIP-7044
+        spec.compute_domain(
+            Domain::VoluntaryExit,
+            spec.capella_fork_version,
+            state.genesis_validators_root(),
+        )
+    } else {
+        spec.get_domain(
             exit.epoch,
             Domain::VoluntaryExit,
             &state.fork(),
             state.genesis_validators_root(),
-        ),
-        // EIP-7044
-        BeaconState::Deneb(_) | BeaconState::Electra(_) => spec.compute_domain(
-            Domain::VoluntaryExit,
-            spec.capella_fork_version,
-            state.genesis_validators_root(),
-        ),
+        )
     };
 
     let message = exit.signing_root(domain);
diff --git a/consensus/state_processing/src/per_block_processing/verify_attestation.rs b/consensus/state_processing/src/per_block_processing/verify_attestation.rs
index c904ba55f0..a4f2ba1050 100644
--- a/consensus/state_processing/src/per_block_processing/verify_attestation.rs
+++ b/consensus/state_processing/src/per_block_processing/verify_attestation.rs
@@ -32,21 +32,17 @@ pub fn verify_attestation_for_block_inclusion<'ctxt, E: EthSpec>(
             attestation: data.slot,
         }
     );
-    match state {
-        BeaconState::Base(_)
-        | BeaconState::Altair(_)
-        | BeaconState::Bellatrix(_)
-        | BeaconState::Capella(_) => {
-            verify!(
-                state.slot() <= data.slot.safe_add(E::slots_per_epoch())?,
-                Invalid::IncludedTooLate {
-                    state: state.slot(),
-                    attestation: data.slot,
-                }
-            );
-        }
+    if state.has_feature(FeatureName::Deneb) {
         // [Modified in Deneb:EIP7045]
-        BeaconState::Deneb(_) | BeaconState::Electra(_) => {}
+        {}
+    } else {
+        verify!(
+            state.slot() <= data.slot.safe_add(E::slots_per_epoch())?,
+            Invalid::IncludedTooLate {
+                state: state.slot(),
+                attestation: data.slot,
+            }
+        );
     }
 
     verify_attestation_for_state(state, attestation, ctxt, verify_signatures, spec)
diff --git a/consensus/state_processing/src/per_epoch_processing.rs b/consensus/state_processing/src/per_epoch_processing.rs
index 55e8853f3f..32ab54a532 100644
--- a/consensus/state_processing/src/per_epoch_processing.rs
+++ b/consensus/state_processing/src/per_epoch_processing.rs
@@ -5,7 +5,7 @@ pub use epoch_processing_summary::{EpochProcessingSummary, ParticipationEpochSum
 use errors::EpochProcessingError as Error;
 pub use justification_and_finalization_state::JustificationAndFinalizationState;
 use safe_arith::SafeArith;
-use types::{BeaconState, ChainSpec, EthSpec};
+use types::{BeaconState, ChainSpec, EthSpec, FeatureName};
 
 pub use registry_updates::{process_registry_updates, process_registry_updates_slow};
 pub use slashings::{process_slashings, process_slashings_slow};
@@ -41,13 +41,10 @@ pub fn process_epoch<E: EthSpec>(
         .fork_name(spec)
         .map_err(Error::InconsistentStateFork)?;
 
-    match state {
-        BeaconState::Base(_) => base::process_epoch(state, spec),
-        BeaconState::Altair(_)
-        | BeaconState::Bellatrix(_)
-        | BeaconState::Capella(_)
-        | BeaconState::Deneb(_)
-        | BeaconState::Electra(_) => altair::process_epoch(state, spec),
+    if state.has_feature(FeatureName::Altair) {
+        altair::process_epoch(state, spec)
+    } else {
+        base::process_epoch(state, spec)
     }
 }
 
diff --git a/consensus/types/src/beacon_block.rs b/consensus/types/src/beacon_block.rs
index b37fa342a2..fd5aac75a0 100644
--- a/consensus/types/src/beacon_block.rs
+++ b/consensus/types/src/beacon_block.rs
@@ -235,6 +235,10 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockRef<'a, E, Payl
         }
     }
 
+    pub fn has_feature(self, feature: FeatureName) -> bool {
+        self.fork_name_unchecked().has_feature(feature)
+    }
+
     /// Convenience accessor for the `body` as a `BeaconBlockBodyRef`.
     pub fn body(&self) -> BeaconBlockBodyRef<'a, E, Payload> {
         map_beacon_block_ref_into_beacon_block_body_ref!(&'a _, *self, |block, cons| cons(
diff --git a/consensus/types/src/beacon_block_body.rs b/consensus/types/src/beacon_block_body.rs
index 55cc490db6..3cdb22d6dd 100644
--- a/consensus/types/src/beacon_block_body.rs
+++ b/consensus/types/src/beacon_block_body.rs
@@ -263,6 +263,10 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
         self.blob_kzg_commitments()
             .map_or(false, |blobs| !blobs.is_empty())
     }
+
+    pub fn has_feature(self, feature: FeatureName) -> bool {
+        self.fork_name().has_feature(feature)
+    }
 }
 
 impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E, Payload> {
diff --git a/consensus/types/src/beacon_state.rs b/consensus/types/src/beacon_state.rs
index abf91f5483..90820f7d8d 100644
--- a/consensus/types/src/beacon_state.rs
+++ b/consensus/types/src/beacon_state.rs
@@ -1579,16 +1579,14 @@ impl<E: EthSpec> BeaconState<E> {
     ///
     /// Uses the current epoch committee cache, and will error if it isn't initialized.
     pub fn get_activation_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
-        Ok(match self {
-            BeaconState::Base(_)
-            | BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_) => self.get_validator_churn_limit(spec)?,
-            BeaconState::Deneb(_) | BeaconState::Electra(_) => std::cmp::min(
+        if self.has_feature(FeatureName::Deneb) {
+            Ok(std::cmp::min(
                 spec.max_per_epoch_activation_churn_limit,
                 self.get_validator_churn_limit(spec)?,
-            ),
-        })
+            ))
+        } else {
+            Ok(self.get_validator_churn_limit(spec)?)
+        }
     }
 
     /// Returns the `slot`, `index`, `committee_position` and `committee_len` for which a validator must produce an
diff --git a/consensus/types/src/beacon_state/progressive_balances_cache.rs b/consensus/types/src/beacon_state/progressive_balances_cache.rs
index fd5e51313f..c54b933ac3 100644
--- a/consensus/types/src/beacon_state/progressive_balances_cache.rs
+++ b/consensus/types/src/beacon_state/progressive_balances_cache.rs
@@ -4,7 +4,7 @@ use crate::{
         NUM_FLAG_INDICES, TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX,
         TIMELY_TARGET_FLAG_INDEX,
     },
-    BeaconState, BeaconStateError, ChainSpec, Epoch, EthSpec, ParticipationFlags,
+    BeaconStateError, ChainSpec, Epoch, ParticipationFlags,
 };
 use arbitrary::Arbitrary;
 use safe_arith::SafeArith;
@@ -282,15 +282,3 @@ impl ProgressiveBalancesCache {
             .ok_or(BeaconStateError::ProgressiveBalancesCacheNotInitialized)
     }
 }
-
-/// `ProgressiveBalancesCache` is only enabled from `Altair` as it uses Altair-specific logic.
-pub fn is_progressive_balances_enabled<E: EthSpec>(state: &BeaconState<E>) -> bool {
-    match state {
-        BeaconState::Base(_) => false,
-        BeaconState::Altair(_)
-        | BeaconState::Bellatrix(_)
-        | BeaconState::Capella(_)
-        | BeaconState::Deneb(_)
-        | BeaconState::Electra(_) => true,
-    }
-}
diff --git a/testing/ef_tests/src/cases/epoch_processing.rs b/testing/ef_tests/src/cases/epoch_processing.rs
index c4c592e4cf..d5cd690ce7 100644
--- a/testing/ef_tests/src/cases/epoch_processing.rs
+++ b/testing/ef_tests/src/cases/epoch_processing.rs
@@ -19,7 +19,7 @@ use state_processing::per_epoch_processing::{
 };
 use state_processing::EpochProcessingError;
 use std::marker::PhantomData;
-use types::BeaconState;
+use types::{BeaconState, FeatureName};
 
 #[derive(Debug, Clone, Default, Deserialize)]
 pub struct Metadata {
@@ -91,47 +91,35 @@ type_name!(ParticipationFlagUpdates, "participation_flag_updates");
 
 impl<E: EthSpec> EpochTransition<E> for JustificationAndFinalization {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => {
-                let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
-                validator_statuses.process_attestations(state)?;
-                let justification_and_finalization_state =
-                    base::process_justification_and_finalization(
-                        state,
-                        &validator_statuses.total_balances,
-                        spec,
-                    )?;
-                justification_and_finalization_state.apply_changes_to_state(state);
-                Ok(())
-            }
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => {
-                initialize_progressive_balances_cache(state, spec)?;
-                let justification_and_finalization_state =
-                    altair::process_justification_and_finalization(state)?;
-                justification_and_finalization_state.apply_changes_to_state(state);
-                Ok(())
-            }
+        if state.has_feature(FeatureName::Altair) {
+            initialize_progressive_balances_cache(state, spec)?;
+            let justification_and_finalization_state =
+                altair::process_justification_and_finalization(state)?;
+            justification_and_finalization_state.apply_changes_to_state(state);
+            Ok(())
+        } else {
+            let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
+            validator_statuses.process_attestations(state)?;
+            let justification_and_finalization_state =
+                base::process_justification_and_finalization(
+                    state,
+                    &validator_statuses.total_balances,
+                    spec,
+                )?;
+            justification_and_finalization_state.apply_changes_to_state(state);
+            Ok(())
         }
     }
 }
 
 impl<E: EthSpec> EpochTransition<E> for RewardsAndPenalties {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => {
-                let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
-                validator_statuses.process_attestations(state)?;
-                base::process_rewards_and_penalties(state, &validator_statuses, spec)
-            }
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => altair::process_rewards_and_penalties_slow(state, spec),
+        if state.has_feature(FeatureName::Altair) {
+            altair::process_rewards_and_penalties_slow(state, spec)
+        } else {
+            let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
+            validator_statuses.process_attestations(state)?;
+            base::process_rewards_and_penalties(state, &validator_statuses, spec)
         }
     }
 }
@@ -150,24 +138,18 @@ impl<E: EthSpec> EpochTransition<E> for RegistryUpdates {
 
 impl<E: EthSpec> EpochTransition<E> for Slashings {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => {
-                let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
-                validator_statuses.process_attestations(state)?;
-                process_slashings(
-                    state,
-                    validator_statuses.total_balances.current_epoch(),
-                    spec,
-                )?;
-            }
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => {
-                process_slashings_slow(state, spec)?;
-            }
-        };
+        if state.has_feature(FeatureName::Altair) {
+            process_slashings_slow(state, spec)?;
+        } else {
+            let mut validator_statuses = base::ValidatorStatuses::new(state, spec)?;
+            validator_statuses.process_attestations(state)?;
+            process_slashings(
+                state,
+                validator_statuses.total_balances.current_epoch(),
+                spec,
+            )?;
+        }
+
         Ok(())
     }
 }
@@ -202,22 +184,20 @@ impl<E: EthSpec> EpochTransition<E> for RandaoMixesReset {
 
 impl<E: EthSpec> EpochTransition<E> for HistoricalRootsUpdate {
     fn run(state: &mut BeaconState<E>, _spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) | BeaconState::Altair(_) | BeaconState::Bellatrix(_) => {
-                process_historical_roots_update(state)
-            }
-            _ => Ok(()),
+        if state.has_feature(FeatureName::Capella) {
+            Ok(())
+        } else {
+            process_historical_roots_update(state)
         }
     }
 }
 
 impl<E: EthSpec> EpochTransition<E> for HistoricalSummariesUpdate {
     fn run(state: &mut BeaconState<E>, _spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Capella(_) | BeaconState::Deneb(_) | BeaconState::Electra(_) => {
-                process_historical_summaries_update(state)
-            }
-            _ => Ok(()),
+        if state.has_feature(FeatureName::Capella) {
+            process_historical_summaries_update(state)
+        } else {
+            Ok(())
         }
     }
 }
@@ -234,39 +214,30 @@ impl<E: EthSpec> EpochTransition<E> for ParticipationRecordUpdates {
 
 impl<E: EthSpec> EpochTransition<E> for SyncCommitteeUpdates {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => altair::process_sync_committee_updates(state, spec),
+        if state.has_feature(FeatureName::Altair) {
+            altair::process_sync_committee_updates(state, spec)
+        } else {
+            Ok(())
         }
     }
 }
 
 impl<E: EthSpec> EpochTransition<E> for InactivityUpdates {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => altair::process_inactivity_updates_slow(state, spec),
+        if state.has_feature(FeatureName::Altair) {
+            altair::process_inactivity_updates_slow(state, spec)
+        } else {
+            Ok(())
         }
     }
 }
 
 impl<E: EthSpec> EpochTransition<E> for ParticipationFlagUpdates {
     fn run(state: &mut BeaconState<E>, _: &ChainSpec) -> Result<(), EpochProcessingError> {
-        match state {
-            BeaconState::Base(_) => Ok(()),
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => altair::process_participation_flag_updates(state),
+        if state.has_feature(FeatureName::Altair) {
+            altair::process_participation_flag_updates(state)
+        } else {
+            Ok(())
         }
     }
 }
@@ -304,23 +275,18 @@ impl<E: EthSpec, T: EpochTransition<E>> Case for EpochProcessing<E, T> {
     }
 
     fn is_enabled_for_fork(fork_name: ForkName) -> bool {
-        match fork_name {
+        // No phase0 tests for Altair and later.
+        if fork_name.has_feature(FeatureName::Capella) {
+            T::name() != "participation_record_updates" && T::name() != "historical_roots_update"
+        } else if fork_name.has_feature(FeatureName::Altair) {
+            T::name() != "participation_record_updates"
+                && T::name() != "historical_summaries_update"
+        } else {
             // No Altair tests for genesis fork.
-            ForkName::Base => {
-                T::name() != "sync_committee_updates"
-                    && T::name() != "inactivity_updates"
-                    && T::name() != "participation_flag_updates"
-                    && T::name() != "historical_summaries_update"
-            }
-            // No phase0 tests for Altair and later.
-            ForkName::Altair | ForkName::Bellatrix => {
-                T::name() != "participation_record_updates"
-                    && T::name() != "historical_summaries_update"
-            }
-            ForkName::Capella | ForkName::Deneb | ForkName::Electra => {
-                T::name() != "participation_record_updates"
-                    && T::name() != "historical_roots_update"
-            }
+            T::name() != "sync_committee_updates"
+                && T::name() != "inactivity_updates"
+                && T::name() != "participation_flag_updates"
+                && T::name() != "historical_summaries_update"
         }
     }
 
diff --git a/testing/ef_tests/src/cases/operations.rs b/testing/ef_tests/src/cases/operations.rs
index 158f2334dc..8a782d973a 100644
--- a/testing/ef_tests/src/cases/operations.rs
+++ b/testing/ef_tests/src/cases/operations.rs
@@ -22,7 +22,7 @@ use std::fmt::Debug;
 use types::{
     Attestation, AttesterSlashing, BeaconBlock, BeaconBlockBody, BeaconBlockBodyBellatrix,
     BeaconBlockBodyCapella, BeaconBlockBodyDeneb, BeaconState, BlindedPayload, Deposit,
-    ExecutionPayload, FullPayload, ProposerSlashing, SignedBlsToExecutionChange,
+    ExecutionPayload, FeatureName, FullPayload, ProposerSlashing, SignedBlsToExecutionChange,
     SignedVoluntaryExit, SyncAggregate,
 };
 
@@ -90,29 +90,24 @@ impl<E: EthSpec> Operation<E> for Attestation<E> {
     ) -> Result<(), BlockProcessingError> {
         initialize_epoch_cache(state, spec)?;
         let mut ctxt = ConsensusContext::new(state.slot());
-        match state {
-            BeaconState::Base(_) => base::process_attestations(
+        if state.has_feature(FeatureName::Altair) {
+            initialize_progressive_balances_cache(state, spec)?;
+            altair_deneb::process_attestation(
+                state,
+                self,
+                0,
+                &mut ctxt,
+                VerifySignatures::True,
+                spec,
+            )
+        } else {
+            base::process_attestations(
                 state,
                 &[self.clone()],
                 VerifySignatures::True,
                 &mut ctxt,
                 spec,
-            ),
-            BeaconState::Altair(_)
-            | BeaconState::Bellatrix(_)
-            | BeaconState::Capella(_)
-            | BeaconState::Deneb(_)
-            | BeaconState::Electra(_) => {
-                initialize_progressive_balances_cache(state, spec)?;
-                altair_deneb::process_attestation(
-                    state,
-                    self,
-                    0,
-                    &mut ctxt,
-                    VerifySignatures::True,
-                    spec,
-                )
-            }
+            )
         }
     }
 }