diff --git a/Cargo.lock b/Cargo.lock
index eb8dfdb5e32..8dee921887d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3583,6 +3583,7 @@ name = "fork_choice"
 version = "0.1.0"
 dependencies = [
  "beacon_chain",
+ "bls",
  "ethereum_ssz",
  "ethereum_ssz_derive",
  "fixed_bytes",
@@ -7019,7 +7020,9 @@ dependencies = [
  "safe_arith",
  "serde",
  "serde_yaml",
+ "smallvec",
  "superstruct",
+ "typenum",
  "types",
 ]
 
diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index c7009fc6dc3..d53e588d54b 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -83,8 +83,8 @@ use execution_layer::{
 };
 use fixed_bytes::FixedBytesExtended;
 use fork_choice::{
-    AttestationFromBlock, ExecutionStatus, ForkChoice, ForkchoiceUpdateParameters,
-    InvalidationOperation, PayloadVerificationStatus, ResetPayloadStatuses,
+    ExecutionStatus, ForkChoice, ForkchoiceUpdateParameters, InvalidationOperation,
+    PayloadVerificationStatus, ResetPayloadStatuses,
 };
 use futures::channel::mpsc::Sender;
 use itertools::Itertools;
@@ -1451,7 +1451,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .proto_array()
             .heads_descended_from_finalization::<T::EthSpec>(fork_choice.finalized_checkpoint())
             .iter()
-            .map(|node| (node.root, node.slot))
+            .map(|node| (node.root(), node.slot()))
             .collect()
     }
 
@@ -2280,7 +2280,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .on_attestation(
                 self.slot()?,
                 verified.indexed_attestation().to_ref(),
-                AttestationFromBlock::False,
+                false,
+                &self.spec,
             )
             .map_err(Into::into)
     }
@@ -4773,7 +4774,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         // The slot of our potential re-org block is always 1 greater than the head block because we
         // only attempt single-slot re-orgs.
-        let head_slot = info.head_node.slot;
+        let head_slot = info.head_node.slot();
         let re_org_block_slot = head_slot + 1;
         let fork_choice_slot = info.current_slot;
 
@@ -4808,9 +4809,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                 .fork_name_at_slot::<T::EthSpec>(re_org_block_slot)
                 .fulu_enabled()
             {
-                info.head_node.current_epoch_shuffling_id
+                info.head_node.current_epoch_shuffling_id()
             } else {
-                info.head_node.next_epoch_shuffling_id
+                info.head_node.next_epoch_shuffling_id()
             }
             .shuffling_decision_block;
             let proposer_index = self
@@ -4839,10 +4840,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // If the current slot is already equal to the proposal slot (or we are in the tail end of
         // the prior slot), then check the actual weight of the head against the head re-org threshold
         // and the actual weight of the parent against the parent re-org threshold.
+        // Per spec `is_head_weak`: uses get_attestation_score(head, PENDING) which is
+        // the total weight. Per spec `is_parent_strong`: uses
+        // get_attestation_score(parent, parent_payload_status) where parent_payload_status
+        // is determined by the head block's relationship to its parent.
+        let head_weight = info.head_node.weight();
+        let parent_weight = if let (Ok(head_payload_status), Ok(parent_v29)) = (
+            info.head_node.parent_payload_status(),
+            info.parent_node.as_v29(),
+        ) {
+            // Post-GLOAS: use the payload-filtered weight matching how the head
+            // extends from its parent.
+            match head_payload_status {
+                proto_array::PayloadStatus::Full => parent_v29.full_payload_weight,
+                proto_array::PayloadStatus::Empty => parent_v29.empty_payload_weight,
+                proto_array::PayloadStatus::Pending => info.parent_node.weight(),
+            }
+        } else {
+            // Pre-GLOAS or fork boundary: use total weight.
+            info.parent_node.weight()
+        };
+
         let (head_weak, parent_strong) = if fork_choice_slot == re_org_block_slot {
             (
-                info.head_node.weight < info.re_org_head_weight_threshold,
-                info.parent_node.weight > info.re_org_parent_weight_threshold,
+                head_weight < info.re_org_head_weight_threshold,
+                parent_weight > info.re_org_parent_weight_threshold,
             )
         } else {
             (true, true)
@@ -4850,7 +4872,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         if !head_weak {
             return Err(Box::new(
                 DoNotReOrg::HeadNotWeak {
-                    head_weight: info.head_node.weight,
+                    head_weight,
                     re_org_head_weight_threshold: info.re_org_head_weight_threshold,
                 }
                 .into(),
@@ -4859,7 +4881,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         if !parent_strong {
             return Err(Box::new(
                 DoNotReOrg::ParentNotStrong {
-                    parent_weight: info.parent_node.weight,
+                    parent_weight,
                     re_org_parent_weight_threshold: info.re_org_parent_weight_threshold,
                 }
                 .into(),
@@ -4877,9 +4899,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             return Err(Box::new(DoNotReOrg::HeadNotLate.into()));
         }
 
-        let parent_head_hash = info.parent_node.execution_status.block_hash();
+        let parent_head_hash = info
+            .parent_node
+            .execution_status()
+            .ok()
+            .and_then(|execution_status| execution_status.block_hash());
         let forkchoice_update_params = ForkchoiceUpdateParameters {
-            head_root: info.parent_node.root,
+            head_root: info.parent_node.root(),
             head_hash: parent_head_hash,
             justified_hash: canonical_forkchoice_params.justified_hash,
             finalized_hash: canonical_forkchoice_params.finalized_hash,
@@ -4887,7 +4913,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         debug!(
             canonical_head = ?head_block_root,
-            ?info.parent_node.root,
+            parent_root = ?info.parent_node.root(),
             slot = %fork_choice_slot,
             "Fork choice update overridden"
         );
diff --git a/beacon_node/beacon_chain/src/block_production/mod.rs b/beacon_node/beacon_chain/src/block_production/mod.rs
index b33323f5271..60cc3e919a3 100644
--- a/beacon_node/beacon_chain/src/block_production/mod.rs
+++ b/beacon_node/beacon_chain/src/block_production/mod.rs
@@ -227,7 +227,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             })
             .ok()?;
         drop(proposer_head_timer);
-        let re_org_parent_block = proposer_head.parent_node.root;
+        let re_org_parent_block = proposer_head.parent_node.root();
 
         let (state_root, state) = self
             .store
@@ -244,7 +244,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         info!(
             weak_head = ?canonical_head,
             parent = ?re_org_parent_block,
-            head_weight = proposer_head.head_node.weight,
+            head_weight = proposer_head.head_node.weight(),
             threshold_weight = proposer_head.re_org_head_weight_threshold,
             "Attempting re-org due to weak head"
         );
diff --git a/beacon_node/beacon_chain/src/block_verification.rs b/beacon_node/beacon_chain/src/block_verification.rs
index 802b090f6a8..a452d528a12 100644
--- a/beacon_node/beacon_chain/src/block_verification.rs
+++ b/beacon_node/beacon_chain/src/block_verification.rs
@@ -71,7 +71,7 @@ use bls::{PublicKey, PublicKeyBytes};
 use educe::Educe;
 use eth2::types::{BlockGossip, EventKind};
 use execution_layer::PayloadStatus;
-pub use fork_choice::{AttestationFromBlock, PayloadVerificationStatus};
+pub use fork_choice::PayloadVerificationStatus;
 use metrics::TryExt;
 use parking_lot::RwLockReadGuard;
 use proto_array::Block as ProtoBlock;
@@ -1666,11 +1666,7 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
                 .get_indexed_attestation(&state, attestation)
                 .map_err(|e| BlockError::PerBlockProcessingError(e.into_with_index(i)))?;
 
-            match fork_choice.on_attestation(
-                current_slot,
-                indexed_attestation,
-                AttestationFromBlock::True,
-            ) {
+            match fork_choice.on_attestation(current_slot, indexed_attestation, true, &chain.spec) {
                 Ok(()) => Ok(()),
                 // Ignore invalid attestations whilst importing attestations from a block. The
                 // block might be very old and therefore the attestations useless to fork choice.
@@ -1678,6 +1674,31 @@ impl<T: BeaconChainTypes> ExecutionPendingBlock<T> {
                 Err(e) => Err(BlockError::BeaconChainError(Box::new(e.into()))),
             }?;
         }
+
+        // Register each payload attestation in the block with fork choice.
+        if let Ok(payload_attestations) = block.message().body().payload_attestations() {
+            for (i, payload_attestation) in payload_attestations.iter().enumerate() {
+                let indexed_payload_attestation = consensus_context
+                    .get_indexed_payload_attestation(&state, payload_attestation, &chain.spec)
+                    .map_err(|e| BlockError::PerBlockProcessingError(e.into_with_index(i)))?;
+
+                let ptc = state
+                    .get_ptc(indexed_payload_attestation.data.slot, &chain.spec)
+                    .map_err(|e| BlockError::BeaconChainError(Box::new(e.into())))?;
+
+                match fork_choice.on_payload_attestation(
+                    current_slot,
+                    indexed_payload_attestation,
+                    true,
+                    &ptc.0,
+                ) {
+                    Ok(()) => Ok(()),
+                    // Ignore invalid payload attestations whilst importing from a block.
+                    Err(ForkChoiceError::InvalidAttestation(_)) => Ok(()),
+                    Err(e) => Err(BlockError::BeaconChainError(Box::new(e.into()))),
+                }?;
+            }
+        }
         drop(fork_choice);
 
         Ok(Self {
@@ -1940,13 +1961,13 @@ fn load_parent<T: BeaconChainTypes, B: AsBlock<T::EthSpec>>(
             {
                 if block.as_block().is_parent_block_full(parent_bid_block_hash) {
                     // TODO(gloas): loading the envelope here is not very efficient
-                    // TODO(gloas): check parent payload existence prior to this point?
-                    let envelope = chain.store.get_payload_envelope(&root)?.ok_or_else(|| {
-                        BeaconChainError::DBInconsistent(format!(
-                            "Missing envelope for parent block {root:?}",
-                        ))
-                    })?;
-                    (StatePayloadStatus::Full, envelope.message.state_root)
+                    if let Some(envelope) = chain.store.get_payload_envelope(&root)? {
+                        (StatePayloadStatus::Full, envelope.message.state_root)
+                    } else {
+                        // The envelope hasn't been stored yet (e.g. genesis block, or payload
+                        // not yet delivered). Fall back to the pending/empty state.
+                        (StatePayloadStatus::Pending, parent_block.state_root())
+                    }
                 } else {
                     (StatePayloadStatus::Pending, parent_block.state_root())
                 }
diff --git a/beacon_node/beacon_chain/src/invariants.rs b/beacon_node/beacon_chain/src/invariants.rs
index 7bcec7b0b41..b365f37a0aa 100644
--- a/beacon_node/beacon_chain/src/invariants.rs
+++ b/beacon_node/beacon_chain/src/invariants.rs
@@ -23,9 +23,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     // Only check blocks that are descendants of the finalized checkpoint.
                     // Pruned non-canonical fork blocks may linger in the proto-array but
                     // are legitimately absent from the database.
-                    fc.is_finalized_checkpoint_or_descendant(node.root)
+                    fc.is_finalized_checkpoint_or_descendant(node.root())
                 })
-                .map(|node| (node.root, node.slot))
+                .map(|node| (node.root(), node.slot()))
                 .collect()
         };
 
diff --git a/beacon_node/beacon_chain/src/persisted_fork_choice.rs b/beacon_node/beacon_chain/src/persisted_fork_choice.rs
index d8fcc0901bf..5551e1d7c94 100644
--- a/beacon_node/beacon_chain/src/persisted_fork_choice.rs
+++ b/beacon_node/beacon_chain/src/persisted_fork_choice.rs
@@ -9,10 +9,10 @@ use superstruct::superstruct;
 use types::Hash256;
 
 // If adding a new version you should update this type alias and fix the breakages.
-pub type PersistedForkChoice = PersistedForkChoiceV28;
+pub type PersistedForkChoice = PersistedForkChoiceV29;
 
 #[superstruct(
-    variants(V17, V28),
+    variants(V17, V28, V29),
     variant_attributes(derive(Encode, Decode)),
     no_enum
 )]
@@ -20,10 +20,12 @@ pub struct PersistedForkChoice {
     #[superstruct(only(V17))]
     pub fork_choice_v17: fork_choice::PersistedForkChoiceV17,
     #[superstruct(only(V28))]
-    pub fork_choice: fork_choice::PersistedForkChoiceV28,
+    pub fork_choice_v28: fork_choice::PersistedForkChoiceV28,
+    #[superstruct(only(V29))]
+    pub fork_choice: fork_choice::PersistedForkChoiceV29,
     #[superstruct(only(V17))]
     pub fork_choice_store_v17: PersistedForkChoiceStoreV17,
-    #[superstruct(only(V28))]
+    #[superstruct(only(V28, V29))]
     pub fork_choice_store: PersistedForkChoiceStoreV28,
 }
 
@@ -47,7 +49,7 @@ macro_rules! impl_store_item {
 
 impl_store_item!(PersistedForkChoiceV17);
 
-impl PersistedForkChoiceV28 {
+impl PersistedForkChoiceV29 {
     pub fn from_bytes(bytes: &[u8], store_config: &StoreConfig) -> Result<Self, Error> {
         let decompressed_bytes = store_config
             .decompress_bytes(bytes)
@@ -78,3 +80,12 @@ impl PersistedForkChoiceV28 {
         ))
     }
 }
+
+impl From<PersistedForkChoiceV28> for PersistedForkChoiceV29 {
+    fn from(v28: PersistedForkChoiceV28) -> Self {
+        Self {
+            fork_choice: v28.fork_choice_v28.into(),
+            fork_choice_store: v28.fork_choice_store,
+        }
+    }
+}
diff --git a/beacon_node/beacon_chain/src/schema_change/migration_schema_v23.rs b/beacon_node/beacon_chain/src/schema_change/migration_schema_v23.rs
index e238e1efb6c..a6671c55be5 100644
--- a/beacon_node/beacon_chain/src/schema_change/migration_schema_v23.rs
+++ b/beacon_node/beacon_chain/src/schema_change/migration_schema_v23.rs
@@ -110,22 +110,21 @@ pub fn downgrade_from_v23<T: BeaconChainTypes>(
     // Doesn't matter what policy we use for invalid payloads, as our head calculation just
     // considers descent from finalization.
     let reset_payload_statuses = ResetPayloadStatuses::OnlyWithInvalidPayload;
-    let fork_choice = ForkChoice::from_persisted(
-        persisted_fork_choice.fork_choice_v17.try_into()?,
-        reset_payload_statuses,
-        fc_store,
-        &db.spec,
-    )
-    .map_err(|e| {
-        Error::MigrationError(format!("Error loading fork choice from persisted: {e:?}"))
-    })?;
+    let persisted_fc_v28: fork_choice::PersistedForkChoiceV28 =
+        persisted_fork_choice.fork_choice_v17.try_into()?;
+    let persisted_fc_v29: fork_choice::PersistedForkChoiceV29 = persisted_fc_v28.into();
+    let fork_choice =
+        ForkChoice::from_persisted(persisted_fc_v29, reset_payload_statuses, fc_store, &db.spec)
+            .map_err(|e| {
+                Error::MigrationError(format!("Error loading fork choice from persisted: {e:?}"))
+            })?;
 
     let heads = fork_choice
         .proto_array()
         .heads_descended_from_finalization::<T::EthSpec>(fork_choice.finalized_checkpoint());
 
-    let head_roots = heads.iter().map(|node| node.root).collect();
-    let head_slots = heads.iter().map(|node| node.slot).collect();
+    let head_roots = heads.iter().map(|node| node.root()).collect();
+    let head_slots = heads.iter().map(|node| node.slot()).collect();
 
     let persisted_beacon_chain_v22 = PersistedBeaconChainV22 {
         _canonical_head_block_root: DUMMY_CANONICAL_HEAD_BLOCK_ROOT,
diff --git a/beacon_node/beacon_chain/src/schema_change/migration_schema_v28.rs b/beacon_node/beacon_chain/src/schema_change/migration_schema_v28.rs
index 5885eaabc00..86b96080d43 100644
--- a/beacon_node/beacon_chain/src/schema_change/migration_schema_v28.rs
+++ b/beacon_node/beacon_chain/src/schema_change/migration_schema_v28.rs
@@ -1,7 +1,7 @@
 use crate::{
     BeaconChain, BeaconChainTypes, BeaconForkChoiceStore, PersistedForkChoiceStoreV17,
     beacon_chain::FORK_CHOICE_DB_KEY,
-    persisted_fork_choice::{PersistedForkChoiceV17, PersistedForkChoiceV28},
+    persisted_fork_choice::PersistedForkChoiceV17,
     summaries_dag::{DAGStateSummary, StateSummariesDAG},
 };
 use fork_choice::{ForkChoice, ForkChoiceStore, ResetPayloadStatuses};
@@ -88,8 +88,11 @@ pub fn upgrade_to_v28<T: BeaconChainTypes>(
     // Construct top-level ForkChoice struct using the patched fork choice store, and the converted
     // proto array.
     let reset_payload_statuses = ResetPayloadStatuses::OnlyWithInvalidPayload;
+    let persisted_fc_v28: fork_choice::PersistedForkChoiceV28 =
+        persisted_fork_choice_v17.fork_choice_v17.try_into()?;
+    let persisted_fc_v29: fork_choice::PersistedForkChoiceV29 = persisted_fc_v28.into();
     let fork_choice = ForkChoice::from_persisted(
-        persisted_fork_choice_v17.fork_choice_v17.try_into()?,
+        persisted_fc_v29,
         reset_payload_statuses,
         fc_store,
         db.get_chain_spec(),
@@ -118,26 +121,22 @@ pub fn downgrade_from_v28<T: BeaconChainTypes>(
         return Ok(vec![]);
     };
 
-    // Recreate V28 persisted fork choice, then convert each field back to its V17 version.
-    let persisted_fork_choice = PersistedForkChoiceV28 {
-        fork_choice: fork_choice.to_persisted(),
-        fork_choice_store: fork_choice.fc_store().to_persisted(),
-    };
-
+    let persisted_v29 = fork_choice.to_persisted();
+    let fc_store_v28 = fork_choice.fc_store().to_persisted();
     let justified_balances = fork_choice.fc_store().justified_balances();
 
+    // Convert V29 proto_array back to legacy V28 for downgrade.
+    let persisted_fork_choice_v28 = fork_choice::PersistedForkChoiceV28 {
+        proto_array_v28: persisted_v29.proto_array.into(),
+        queued_attestations: persisted_v29.queued_attestations,
+    };
+
     // 1. Create `proto_array::PersistedForkChoiceV17`.
-    let fork_choice_v17: fork_choice::PersistedForkChoiceV17 = (
-        persisted_fork_choice.fork_choice,
-        justified_balances.clone(),
-    )
-        .into();
+    let fork_choice_v17: fork_choice::PersistedForkChoiceV17 =
+        (persisted_fork_choice_v28, justified_balances.clone()).into();
 
-    let fork_choice_store_v17: PersistedForkChoiceStoreV17 = (
-        persisted_fork_choice.fork_choice_store,
-        justified_balances.clone(),
-    )
-        .into();
+    let fork_choice_store_v17: PersistedForkChoiceStoreV17 =
+        (fc_store_v28, justified_balances.clone()).into();
 
     let persisted_fork_choice_v17 = PersistedForkChoiceV17 {
         fork_choice_v17,
diff --git a/beacon_node/beacon_chain/tests/payload_invalidation.rs b/beacon_node/beacon_chain/tests/payload_invalidation.rs
index 3ed8f59838d..7adffd3824a 100644
--- a/beacon_node/beacon_chain/tests/payload_invalidation.rs
+++ b/beacon_node/beacon_chain/tests/payload_invalidation.rs
@@ -1428,7 +1428,7 @@ async fn weights_after_resetting_optimistic_status() {
         .fork_choice_read_lock()
         .proto_array()
         .iter_nodes(&head.head_block_root())
-        .map(|node| (node.root, node.weight))
+        .map(|node| (node.root(), node.weight()))
         .collect::<HashMap<_, _>>();
 
     rig.invalidate_manually(roots[1]).await;
@@ -1448,7 +1448,7 @@ async fn weights_after_resetting_optimistic_status() {
         .fork_choice_read_lock()
         .proto_array()
         .iter_nodes(&head.head_block_root())
-        .map(|node| (node.root, node.weight))
+        .map(|node| (node.root(), node.weight()))
         .collect::<HashMap<_, _>>();
 
     assert_eq!(original_weights, new_weights);
diff --git a/beacon_node/beacon_chain/tests/tests.rs b/beacon_node/beacon_chain/tests/tests.rs
index b052ba66f1a..10c0b429a95 100644
--- a/beacon_node/beacon_chain/tests/tests.rs
+++ b/beacon_node/beacon_chain/tests/tests.rs
@@ -590,7 +590,10 @@ async fn unaggregated_attestations_added_to_fork_choice_some_none() {
 
         if slot <= num_blocks_produced && slot != 0 {
             assert_eq!(
-                latest_message.unwrap().1,
+                latest_message
+                    .expect("latest message should be present")
+                    .slot
+                    .epoch(MinimalEthSpec::slots_per_epoch()),
                 slot.epoch(MinimalEthSpec::slots_per_epoch()),
                 "Latest message epoch for {} should be equal to epoch {}.",
                 validator,
@@ -700,10 +703,12 @@ async fn unaggregated_attestations_added_to_fork_choice_all_updated() {
     let validator_slots: Vec<(&usize, Slot)> = validators.iter().zip(slots).collect();
 
     for (validator, slot) in validator_slots {
-        let latest_message = fork_choice.latest_message(*validator);
+        let latest_message = fork_choice
+            .latest_message(*validator)
+            .expect("latest message should be present");
 
         assert_eq!(
-            latest_message.unwrap().1,
+            latest_message.slot.epoch(MinimalEthSpec::slots_per_epoch()),
             slot.epoch(MinimalEthSpec::slots_per_epoch()),
             "Latest message slot should be equal to attester duty."
         );
@@ -714,8 +719,7 @@ async fn unaggregated_attestations_added_to_fork_choice_all_updated() {
                 .expect("Should get block root at slot");
 
             assert_eq!(
-                latest_message.unwrap().0,
-                *block_root,
+                latest_message.root, *block_root,
                 "Latest message block root should be equal to block at slot."
             );
         }
diff --git a/beacon_node/http_api/src/lib.rs b/beacon_node/http_api/src/lib.rs
index 29e2d39aee1..19d73be89ae 100644
--- a/beacon_node/http_api/src/lib.rs
+++ b/beacon_node/http_api/src/lib.rs
@@ -2089,52 +2089,62 @@ pub fn serve<T: BeaconChainTypes>(
                         .nodes
                         .iter()
                         .map(|node| {
-                            let execution_status = if node.execution_status.is_execution_enabled() {
-                                Some(node.execution_status.to_string())
+                            let execution_status = if node
+                                .execution_status()
+                                .is_ok_and(|status| status.is_execution_enabled())
+                            {
+                                node.execution_status()
+                                    .ok()
+                                    .map(|status| status.to_string())
                             } else {
                                 None
                             };
 
+                            let execution_status_string = node
+                                .execution_status()
+                                .map_or_else(|_| "irrelevant".to_string(), |s| s.to_string());
+
                             ForkChoiceNode {
-                                slot: node.slot,
-                                block_root: node.root,
+                                slot: node.slot(),
+                                block_root: node.root(),
                                 parent_root: node
-                                    .parent
+                                    .parent()
                                     .and_then(|index| proto_array.nodes.get(index))
-                                    .map(|parent| parent.root),
-                                justified_epoch: node.justified_checkpoint.epoch,
-                                finalized_epoch: node.finalized_checkpoint.epoch,
-                                weight: node.weight,
+                                    .map(|parent| parent.root()),
+                                justified_epoch: node.justified_checkpoint().epoch,
+                                finalized_epoch: node.finalized_checkpoint().epoch,
+                                weight: node.weight(),
                                 validity: execution_status,
                                 execution_block_hash: node
-                                    .execution_status
-                                    .block_hash()
+                                    .execution_status()
+                                    .ok()
+                                    .and_then(|status| status.block_hash())
                                     .map(|block_hash| block_hash.into_root()),
                                 extra_data: ForkChoiceExtraData {
-                                    target_root: node.target_root,
-                                    justified_root: node.justified_checkpoint.root,
-                                    finalized_root: node.finalized_checkpoint.root,
+                                    target_root: node.target_root(),
+                                    justified_root: node.justified_checkpoint().root,
+                                    finalized_root: node.finalized_checkpoint().root,
                                     unrealized_justified_root: node
-                                        .unrealized_justified_checkpoint
+                                        .unrealized_justified_checkpoint()
                                         .map(|checkpoint| checkpoint.root),
                                     unrealized_finalized_root: node
-                                        .unrealized_finalized_checkpoint
+                                        .unrealized_finalized_checkpoint()
                                         .map(|checkpoint| checkpoint.root),
                                     unrealized_justified_epoch: node
-                                        .unrealized_justified_checkpoint
+                                        .unrealized_justified_checkpoint()
                                         .map(|checkpoint| checkpoint.epoch),
                                     unrealized_finalized_epoch: node
-                                        .unrealized_finalized_checkpoint
+                                        .unrealized_finalized_checkpoint()
                                         .map(|checkpoint| checkpoint.epoch),
-                                    execution_status: node.execution_status.to_string(),
+                                    execution_status: execution_status_string,
                                     best_child: node
-                                        .best_child
+                                        .best_child()
                                         .and_then(|index| proto_array.nodes.get(index))
-                                        .map(|child| child.root),
+                                        .map(|child| child.root()),
                                     best_descendant: node
-                                        .best_descendant
+                                        .best_descendant()
                                         .and_then(|index| proto_array.nodes.get(index))
-                                        .map(|descendant| descendant.root),
+                                        .map(|descendant| descendant.root()),
                                 },
                             }
                         })
diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs
index c9086dd8767..bfec7130f60 100644
--- a/beacon_node/http_api/tests/tests.rs
+++ b/beacon_node/http_api/tests/tests.rs
@@ -33,7 +33,7 @@ use lighthouse_network::{Enr, PeerId, types::SyncState};
 use network::NetworkReceivers;
 use network_utils::enr_ext::EnrExt;
 use operation_pool::attestation_storage::CheckpointKey;
-use proto_array::ExecutionStatus;
+use proto_array::{ExecutionStatus, core::ProtoNode};
 use reqwest::{RequestBuilder, Response, StatusCode};
 use sensitive_url::SensitiveUrl;
 use slot_clock::SlotClock;
@@ -3130,51 +3130,61 @@ impl ApiTester {
             .nodes
             .iter()
             .map(|node| {
-                let execution_status = if node.execution_status.is_execution_enabled() {
-                    Some(node.execution_status.to_string())
+                let execution_status = if node
+                    .execution_status()
+                    .is_ok_and(|status| status.is_execution_enabled())
+                {
+                    node.execution_status()
+                        .ok()
+                        .map(|status| status.to_string())
                 } else {
                     None
                 };
                 ForkChoiceNode {
-                    slot: node.slot,
-                    block_root: node.root,
+                    slot: node.slot(),
+                    block_root: node.root(),
                     parent_root: node
-                        .parent
+                        .parent()
                         .and_then(|index| expected_proto_array.nodes.get(index))
-                        .map(|parent| parent.root),
-                    justified_epoch: node.justified_checkpoint.epoch,
-                    finalized_epoch: node.finalized_checkpoint.epoch,
-                    weight: node.weight,
+                        .map(|parent| parent.root()),
+                    justified_epoch: node.justified_checkpoint().epoch,
+                    finalized_epoch: node.finalized_checkpoint().epoch,
+                    weight: node.weight(),
                     validity: execution_status,
                     execution_block_hash: node
-                        .execution_status
-                        .block_hash()
+                        .execution_status()
+                        .ok()
+                        .and_then(|status| status.block_hash())
                         .map(|block_hash| block_hash.into_root()),
                     extra_data: ForkChoiceExtraData {
-                        target_root: node.target_root,
-                        justified_root: node.justified_checkpoint.root,
-                        finalized_root: node.finalized_checkpoint.root,
+                        target_root: node.target_root(),
+                        justified_root: node.justified_checkpoint().root,
+                        finalized_root: node.finalized_checkpoint().root,
                         unrealized_justified_root: node
-                            .unrealized_justified_checkpoint
+                            .unrealized_justified_checkpoint()
                             .map(|checkpoint| checkpoint.root),
                         unrealized_finalized_root: node
-                            .unrealized_finalized_checkpoint
+                            .unrealized_finalized_checkpoint()
                             .map(|checkpoint| checkpoint.root),
                         unrealized_justified_epoch: node
-                            .unrealized_justified_checkpoint
+                            .unrealized_justified_checkpoint()
                             .map(|checkpoint| checkpoint.epoch),
                         unrealized_finalized_epoch: node
-                            .unrealized_finalized_checkpoint
+                            .unrealized_finalized_checkpoint()
                             .map(|checkpoint| checkpoint.epoch),
-                        execution_status: node.execution_status.to_string(),
+                        execution_status: node
+                            .execution_status()
+                            .ok()
+                            .map(|status| status.to_string())
+                            .unwrap_or_else(|| "n/a".to_string()),
                         best_child: node
-                            .best_child
+                            .best_child()
                             .and_then(|index| expected_proto_array.nodes.get(index))
-                            .map(|child| child.root),
+                            .map(|child| child.root()),
                         best_descendant: node
-                            .best_descendant
+                            .best_descendant()
                             .and_then(|index| expected_proto_array.nodes.get(index))
-                            .map(|descendant| descendant.root),
+                            .map(|descendant| descendant.root()),
                     },
                 }
             })
@@ -7180,6 +7190,7 @@ impl ApiTester {
             .core_proto_array_mut()
             .nodes
             .last_mut()
+            && let ProtoNode::V17(head_node) = head_node
         {
             head_node.execution_status = ExecutionStatus::Optimistic(ExecutionBlockHash::zero())
         }
diff --git a/consensus/fork_choice/Cargo.toml b/consensus/fork_choice/Cargo.toml
index a07aa38aa5b..df47a5c9d1f 100644
--- a/consensus/fork_choice/Cargo.toml
+++ b/consensus/fork_choice/Cargo.toml
@@ -19,5 +19,6 @@ types = { workspace = true }
 
 [dev-dependencies]
 beacon_chain = { workspace = true }
+bls = { workspace = true }
 store = { workspace = true }
 tokio = { workspace = true }
diff --git a/consensus/fork_choice/src/fork_choice.rs b/consensus/fork_choice/src/fork_choice.rs
index 9744b9fa084..5dc081d6ce4 100644
--- a/consensus/fork_choice/src/fork_choice.rs
+++ b/consensus/fork_choice/src/fork_choice.rs
@@ -3,7 +3,7 @@ use crate::{ForkChoiceStore, InvalidationOperation};
 use fixed_bytes::FixedBytesExtended;
 use logging::crit;
 use proto_array::{
-    Block as ProtoBlock, DisallowedReOrgOffsets, ExecutionStatus, JustifiedBalances,
+    Block as ProtoBlock, DisallowedReOrgOffsets, ExecutionStatus, JustifiedBalances, LatestMessage,
     ProposerHeadError, ProposerHeadInfo, ProtoArrayForkChoice, ReOrgThreshold,
 };
 use ssz::{Decode, Encode};
@@ -20,7 +20,8 @@ use tracing::{debug, instrument, warn};
 use types::{
     AbstractExecPayload, AttestationShufflingId, AttesterSlashingRef, BeaconBlockRef, BeaconState,
     BeaconStateError, ChainSpec, Checkpoint, Epoch, EthSpec, ExecPayload, ExecutionBlockHash,
-    Hash256, IndexedAttestationRef, RelativeEpoch, SignedBeaconBlock, Slot,
+    Hash256, IndexedAttestationRef, IndexedPayloadAttestation, RelativeEpoch, SignedBeaconBlock,
+    Slot,
 };
 
 #[derive(Debug)]
@@ -138,6 +139,10 @@ pub enum InvalidBlock {
         finalized_root: Hash256,
         block_ancestor: Option<Hash256>,
     },
+    MissingExecutionPayloadBid {
+        block_slot: Slot,
+        block_root: Hash256,
+    },
 }
 
 #[derive(Debug)]
@@ -170,6 +175,21 @@ pub enum InvalidAttestation {
     /// The attestation is attesting to a state that is later than itself. (Viz., attesting to the
     /// future).
     AttestsToFutureBlock { block: Slot, attestation: Slot },
+    /// Post-GLOAS: attestation index must be 0 or 1.
+    InvalidAttestationIndex { index: u64 },
+    /// A same-slot attestation has a non-zero index, which is invalid post-GLOAS.
+    InvalidSameSlotAttestationIndex { slot: Slot },
+    /// Post-GLOAS: attestation with index == 1 (payload_present) requires the block's
+    /// payload to have been received (`root in store.payload_states`).
+    PayloadNotReceived { beacon_block_root: Hash256 },
+    /// A payload attestation votes payload_present for a block in the current slot, which is
+    /// invalid because the payload cannot be known yet.
+    PayloadPresentDuringSameSlot { slot: Slot },
+    /// A gossip payload attestation must be for the current slot.
+    PayloadAttestationNotCurrentSlot {
+        attestation_slot: Slot,
+        current_slot: Slot,
+    },
 }
 
 impl<T> From<String> for Error<T> {
@@ -241,6 +261,8 @@ pub struct QueuedAttestation {
     attesting_indices: Vec<u64>,
     block_root: Hash256,
     target_epoch: Epoch,
+    /// Per GLOAS spec: `payload_present = attestation.data.index == 1`.
+    payload_present: bool,
 }
 
 impl<'a, E: EthSpec> From<IndexedAttestationRef<'a, E>> for QueuedAttestation {
@@ -250,10 +272,24 @@ impl<'a, E: EthSpec> From<IndexedAttestationRef<'a, E>> for QueuedAttestation {
             attesting_indices: a.attesting_indices_to_vec(),
             block_root: a.data().beacon_block_root,
             target_epoch: a.data().target.epoch,
+            payload_present: a.data().index == 1,
         }
     }
 }
 
+/// Used for queuing payload attestations (PTC votes) from the current slot.
+/// Payload attestations have different dequeue timing than regular attestations:
+/// gossiped payload attestations need an extra slot of delay (slot + 1 < current_slot).
+#[derive(Clone, PartialEq, Encode, Decode)]
+pub struct QueuedPayloadAttestation {
+    slot: Slot,
+    /// Resolved PTC committee positions (not validator indices).
+    ptc_indices: Vec<usize>,
+    block_root: Hash256,
+    payload_present: bool,
+    blob_data_available: bool,
+}
+
 /// Returns all values in `self.queued_attestations` that have a slot that is earlier than the
 /// current slot. Also removes those values from `self.queued_attestations`.
 fn dequeue_attestations(
@@ -275,16 +311,23 @@ fn dequeue_attestations(
     std::mem::replace(queued_attestations, remaining)
 }
 
-/// Denotes whether an attestation we are processing was received from a block or from gossip.
-/// Equivalent to the `is_from_block` `bool` in:
-///
-/// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
-#[derive(Clone, Copy)]
-pub enum AttestationFromBlock {
-    True,
-    False,
+/// Returns all values in `queued` that have `slot + 1 < current_slot`.
+/// Payload attestations need an extra slot of delay compared to regular attestations.
+fn dequeue_payload_attestations(
+    current_slot: Slot,
+    queued: &mut Vec<QueuedPayloadAttestation>,
+) -> Vec<QueuedPayloadAttestation> {
+    let remaining = queued.split_off(
+        queued
+            .iter()
+            .position(|a| a.slot.saturating_add(1_u64) >= current_slot)
+            .unwrap_or(queued.len()),
+    );
+
+    std::mem::replace(queued, remaining)
 }
 
+/// Denotes whether an attestation we are processing was received from a block or from gossip.
 /// Parameters which are cached between calls to `ForkChoice::get_head`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ForkchoiceUpdateParameters {
@@ -319,6 +362,9 @@ pub struct ForkChoice<T, E> {
     proto_array: ProtoArrayForkChoice,
     /// Attestations that arrived at the current slot and must be queued for later processing.
     queued_attestations: Vec<QueuedAttestation>,
+    /// Payload attestations (PTC votes) that must be queued for later processing.
+    /// These have different dequeue timing than regular attestations.
+    queued_payload_attestations: Vec<QueuedPayloadAttestation>,
     /// Stores a cache of the values required to be sent to the execution layer.
     forkchoice_update_parameters: ForkchoiceUpdateParameters,
     _phantom: PhantomData<E>,
@@ -333,6 +379,7 @@ where
         self.fc_store == other.fc_store
             && self.proto_array == other.proto_array
             && self.queued_attestations == other.queued_attestations
+            && self.queued_payload_attestations == other.queued_payload_attestations
     }
 }
 
@@ -367,21 +414,34 @@ where
             AttestationShufflingId::new(anchor_block_root, anchor_state, RelativeEpoch::Next)
                 .map_err(Error::BeaconStateError)?;
 
-        let execution_status = anchor_block.message().execution_payload().map_or_else(
-            // If the block doesn't have an execution payload then it can't have
-            // execution enabled.
-            |_| ExecutionStatus::irrelevant(),
-            |execution_payload| {
+        let (execution_status, execution_payload_parent_hash, execution_payload_block_hash) =
+            if let Ok(execution_payload) = anchor_block.message().execution_payload() {
+                // Pre-Gloas forks: hashes come from the execution payload.
                 if execution_payload.is_default_with_empty_roots() {
-                    // A default payload does not have execution enabled.
-                    ExecutionStatus::irrelevant()
+                    (ExecutionStatus::irrelevant(), None, None)
                 } else {
-                    // Assume that this payload is valid, since the anchor should be a trusted block and
-                    // state.
-                    ExecutionStatus::Valid(execution_payload.block_hash())
+                    // Assume that this payload is valid, since the anchor should be a
+                    // trusted block and state.
+                    (
+                        ExecutionStatus::Valid(execution_payload.block_hash()),
+                        Some(execution_payload.parent_hash()),
+                        Some(execution_payload.block_hash()),
+                    )
                 }
-            },
-        );
+            } else if let Ok(signed_bid) =
+                anchor_block.message().body().signed_execution_payload_bid()
+            {
+                // Gloas: execution status is irrelevant post-Gloas; payload validation
+                // is decoupled from beacon blocks.
+                (
+                    ExecutionStatus::irrelevant(),
+                    Some(signed_bid.message.parent_block_hash),
+                    Some(signed_bid.message.block_hash),
+                )
+            } else {
+                // Pre-merge: no execution payload at all.
+                (ExecutionStatus::irrelevant(), None, None)
+            };
 
         // If the current slot is not provided, use the value that was last provided to the store.
         let current_slot = current_slot.unwrap_or_else(|| fc_store.get_current_slot());
@@ -395,12 +455,16 @@ where
             current_epoch_shuffling_id,
             next_epoch_shuffling_id,
             execution_status,
+            execution_payload_parent_hash,
+            execution_payload_block_hash,
+            spec,
         )?;
 
         let mut fork_choice = Self {
             fc_store,
             proto_array,
             queued_attestations: vec![],
+            queued_payload_attestations: vec![],
             // This will be updated during the next call to `Self::get_head`.
             forkchoice_update_parameters: ForkchoiceUpdateParameters {
                 head_hash: None,
@@ -882,6 +946,24 @@ where
             ExecutionStatus::irrelevant()
         };
 
+        let (execution_payload_parent_hash, execution_payload_block_hash) =
+            if let Ok(signed_bid) = block.body().signed_execution_payload_bid() {
+                (
+                    Some(signed_bid.message.parent_block_hash),
+                    Some(signed_bid.message.block_hash),
+                )
+            } else {
+                if spec.fork_name_at_slot::<E>(block.slot()).gloas_enabled() {
+                    return Err(Error::InvalidBlock(
+                        InvalidBlock::MissingExecutionPayloadBid {
+                            block_slot: block.slot(),
+                            block_root,
+                        },
+                    ));
+                }
+                (None, None)
+            };
+
         // This does not apply a vote to the block, it just makes fork choice aware of the block so
         // it can still be identified as the head even if it doesn't have any votes.
         self.proto_array.process_block::<E>(
@@ -908,15 +990,25 @@ where
                 execution_status,
                 unrealized_justified_checkpoint: Some(unrealized_justified_checkpoint),
                 unrealized_finalized_checkpoint: Some(unrealized_finalized_checkpoint),
+                execution_payload_parent_hash,
+                execution_payload_block_hash,
+                proposer_index: Some(block.proposer_index()),
             },
             current_slot,
             self.justified_checkpoint(),
             self.finalized_checkpoint(),
+            spec,
         )?;
 
         Ok(())
     }
 
+    pub fn on_execution_payload(&mut self, block_root: Hash256) -> Result<(), Error<T::Error>> {
+        self.proto_array
+            .on_execution_payload(block_root)
+            .map_err(Error::FailedToProcessValidExecutionPayload)
+    }
+
     /// Update checkpoints in store if necessary
     fn update_checkpoints(
         &mut self,
@@ -979,7 +1071,8 @@ where
     fn validate_on_attestation(
         &self,
         indexed_attestation: IndexedAttestationRef<E>,
-        is_from_block: AttestationFromBlock,
+        is_from_block: bool,
+        spec: &ChainSpec,
     ) -> Result<(), InvalidAttestation> {
         // There is no point in processing an attestation with an empty bitfield. Reject
         // it immediately.
@@ -992,7 +1085,7 @@ where
 
         let target = indexed_attestation.data().target;
 
-        if matches!(is_from_block, AttestationFromBlock::False) {
+        if !is_from_block {
             self.validate_target_epoch_against_current_time(target.epoch)?;
         }
 
@@ -1052,6 +1145,84 @@ where
             });
         }
 
+        if spec
+            .fork_name_at_slot::<E>(indexed_attestation.data().slot)
+            .gloas_enabled()
+        {
+            let index = indexed_attestation.data().index;
+
+            // Post-GLOAS: attestation index must be 0 or 1.
+            if index > 1 {
+                return Err(InvalidAttestation::InvalidAttestationIndex { index });
+            }
+
+            // Same-slot attestations must have index == 0.
+            if indexed_attestation.data().slot == block.slot && index != 0 {
+                return Err(InvalidAttestation::InvalidSameSlotAttestationIndex {
+                    slot: block.slot,
+                });
+            }
+
+            // index == 1 (payload_present) requires the block's payload to have been received.
+            if index == 1
+                && !self
+                    .proto_array
+                    .is_payload_received(&indexed_attestation.data().beacon_block_root)
+            {
+                return Err(InvalidAttestation::PayloadNotReceived {
+                    beacon_block_root: indexed_attestation.data().beacon_block_root,
+                });
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Validates a payload attestation for application to fork choice.
+    fn validate_on_payload_attestation(
+        &self,
+        indexed_payload_attestation: &IndexedPayloadAttestation<E>,
+        is_from_block: bool,
+    ) -> Result<(), InvalidAttestation> {
+        if indexed_payload_attestation.attesting_indices.is_empty() {
+            return Err(InvalidAttestation::EmptyAggregationBitfield);
+        }
+
+        let block = self
+            .proto_array
+            .get_block(&indexed_payload_attestation.data.beacon_block_root)
+            .ok_or(InvalidAttestation::UnknownHeadBlock {
+                beacon_block_root: indexed_payload_attestation.data.beacon_block_root,
+            })?;
+
+        if block.slot > indexed_payload_attestation.data.slot {
+            return Err(InvalidAttestation::AttestsToFutureBlock {
+                block: block.slot,
+                attestation: indexed_payload_attestation.data.slot,
+            });
+        }
+
+        // Gossip payload attestations must be for the current slot.
+        // https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/fork-choice.md
+        if !is_from_block
+            && indexed_payload_attestation.data.slot != self.fc_store.get_current_slot()
+        {
+            return Err(InvalidAttestation::PayloadAttestationNotCurrentSlot {
+                attestation_slot: indexed_payload_attestation.data.slot,
+                current_slot: self.fc_store.get_current_slot(),
+            });
+        }
+
+        // A payload attestation voting payload_present for a block in the current slot is
+        // invalid: the payload cannot be known yet. This only applies to gossip attestations;
+        // payload attestations from blocks have already been validated by the block producer.
+        if !is_from_block
+            && self.fc_store.get_current_slot() == block.slot
+            && indexed_payload_attestation.data.payload_present
+        {
+            return Err(InvalidAttestation::PayloadPresentDuringSameSlot { slot: block.slot });
+        }
+
         Ok(())
     }
 
@@ -1076,7 +1247,8 @@ where
         &mut self,
         system_time_current_slot: Slot,
         attestation: IndexedAttestationRef<E>,
-        is_from_block: AttestationFromBlock,
+        is_from_block: bool,
+        spec: &ChainSpec,
     ) -> Result<(), Error<T::Error>> {
         let _timer = metrics::start_timer(&metrics::FORK_CHOICE_ON_ATTESTATION_TIMES);
 
@@ -1099,14 +1271,18 @@ where
             return Ok(());
         }
 
-        self.validate_on_attestation(attestation, is_from_block)?;
+        self.validate_on_attestation(attestation, is_from_block, spec)?;
+
+        // Per GLOAS spec: `payload_present = attestation.data.index == 1`.
+        let payload_present = attestation.data().index == 1;
 
         if attestation.data().slot < self.fc_store.get_current_slot() {
             for validator_index in attestation.attesting_indices_iter() {
                 self.proto_array.process_attestation(
                     *validator_index as usize,
                     attestation.data().beacon_block_root,
-                    attestation.data().target.epoch,
+                    attestation.data().slot,
+                    payload_present,
                 )?;
             }
         } else {
@@ -1123,6 +1299,64 @@ where
         Ok(())
     }
 
+    /// Register a payload attestation with the fork choice DAG.
+    ///
+    /// `ptc` is the PTC committee for the attestation's slot: a list of validator indices
+    /// ordered by committee position. Each attesting validator index is resolved to its
+    /// position within `ptc` (its `ptc_index`) before being applied to the proto-array.
+    pub fn on_payload_attestation(
+        &mut self,
+        system_time_current_slot: Slot,
+        attestation: &IndexedPayloadAttestation<E>,
+        is_from_block: bool,
+        ptc: &[usize],
+    ) -> Result<(), Error<T::Error>> {
+        self.update_time(system_time_current_slot)?;
+
+        if attestation.data.beacon_block_root == Hash256::zero() {
+            return Ok(());
+        }
+
+        self.validate_on_payload_attestation(attestation, is_from_block)?;
+
+        // Resolve validator indices to PTC committee positions.
+        let ptc_indices: Vec<usize> = attestation
+            .attesting_indices_iter()
+            .filter_map(|vi| ptc.iter().position(|&p| p == *vi as usize))
+            .collect();
+
+        let processing_slot = self.fc_store.get_current_slot();
+        // Payload attestations from blocks can be applied in the next slot (S+1 for data.slot=S),
+        // while gossiped payload attestations are delayed one extra slot.
+        let should_process_now = if is_from_block {
+            attestation.data.slot < processing_slot
+        } else {
+            attestation.data.slot.saturating_add(1_u64) < processing_slot
+        };
+
+        if should_process_now {
+            for &ptc_index in &ptc_indices {
+                self.proto_array.process_payload_attestation(
+                    attestation.data.beacon_block_root,
+                    ptc_index,
+                    attestation.data.payload_present,
+                    attestation.data.blob_data_available,
+                )?;
+            }
+        } else {
+            self.queued_payload_attestations
+                .push(QueuedPayloadAttestation {
+                    slot: attestation.data.slot,
+                    ptc_indices,
+                    block_root: attestation.data.beacon_block_root,
+                    payload_present: attestation.data.payload_present,
+                    blob_data_available: attestation.data.blob_data_available,
+                });
+        }
+
+        Ok(())
+    }
+
     /// Apply an attester slashing to fork choice.
     ///
     /// We assume that the attester slashing provided to this function has already been verified.
@@ -1152,6 +1386,7 @@ where
 
         // Process any attestations that might now be eligible.
         self.process_attestation_queue()?;
+        self.process_payload_attestation_queue()?;
 
         Ok(self.fc_store.get_current_slot())
     }
@@ -1229,7 +1464,28 @@ where
                 self.proto_array.process_attestation(
                     *validator_index as usize,
                     attestation.block_root,
-                    attestation.target_epoch,
+                    attestation.slot,
+                    attestation.payload_present,
+                )?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Processes and removes from the queue any queued payload attestations which may now be
+    /// eligible for processing. Payload attestations use `slot + 1 < current_slot` timing.
+    fn process_payload_attestation_queue(&mut self) -> Result<(), Error<T::Error>> {
+        let current_slot = self.fc_store.get_current_slot();
+        for attestation in
+            dequeue_payload_attestations(current_slot, &mut self.queued_payload_attestations)
+        {
+            for &ptc_index in &attestation.ptc_indices {
+                self.proto_array.process_payload_attestation(
+                    attestation.block_root,
+                    ptc_index,
+                    attestation.payload_present,
+                    attestation.blob_data_available,
                 )?;
             }
         }
@@ -1359,13 +1615,15 @@ where
 
     /// Returns the latest message for a given validator, if any.
     ///
-    /// Returns `(block_root, block_slot)`.
+    /// Returns `block_root, block_slot, payload_present`.
     ///
     /// ## Notes
     ///
     /// It may be prudent to call `Self::update_time` before calling this function,
     /// since some attestations might be queued and awaiting processing.
-    pub fn latest_message(&self, validator_index: usize) -> Option<(Hash256, Epoch)> {
+    ///
+    /// This function is only used in tests.
+    pub fn latest_message(&self, validator_index: usize) -> Option<LatestMessage> {
         self.proto_array.latest_message(validator_index)
     }
 
@@ -1390,6 +1648,11 @@ where
         &self.queued_attestations
     }
 
+    /// Returns a reference to the currently queued payload attestations.
+    pub fn queued_payload_attestations(&self) -> &[QueuedPayloadAttestation] {
+        &self.queued_payload_attestations
+    }
+
     /// Returns the store's `proposer_boost_root`.
     pub fn proposer_boost_root(&self) -> Hash256 {
         self.fc_store.proposer_boost_root()
@@ -1474,6 +1737,7 @@ where
             fc_store,
             proto_array,
             queued_attestations: persisted.queued_attestations,
+            queued_payload_attestations: persisted.queued_payload_attestations,
             // Will be updated in the following call to `Self::get_head`.
             forkchoice_update_parameters: ForkchoiceUpdateParameters {
                 head_hash: None,
@@ -1512,10 +1776,9 @@ where
     /// be instantiated again later.
     pub fn to_persisted(&self) -> PersistedForkChoice {
         PersistedForkChoice {
-            proto_array: self
-                .proto_array()
-                .as_ssz_container(self.justified_checkpoint(), self.finalized_checkpoint()),
+            proto_array: self.proto_array().as_ssz_container(),
             queued_attestations: self.queued_attestations().to_vec(),
+            queued_payload_attestations: self.queued_payload_attestations.clone(),
         }
     }
 
@@ -1529,7 +1792,7 @@ where
 ///
 /// This is used when persisting the state of the fork choice to disk.
 #[superstruct(
-    variants(V17, V28),
+    variants(V17, V28, V29),
     variant_attributes(derive(Encode, Decode, Clone)),
     no_enum
 )]
@@ -1537,11 +1800,15 @@ pub struct PersistedForkChoice {
     #[superstruct(only(V17))]
     pub proto_array_bytes: Vec<u8>,
     #[superstruct(only(V28))]
-    pub proto_array: proto_array::core::SszContainerV28,
+    pub proto_array_v28: proto_array::core::SszContainerV28,
+    #[superstruct(only(V29))]
+    pub proto_array: proto_array::core::SszContainerV29,
     pub queued_attestations: Vec<QueuedAttestation>,
+    #[superstruct(only(V29))]
+    pub queued_payload_attestations: Vec<QueuedPayloadAttestation>,
 }
 
-pub type PersistedForkChoice = PersistedForkChoiceV28;
+pub type PersistedForkChoice = PersistedForkChoiceV29;
 
 impl TryFrom<PersistedForkChoiceV17> for PersistedForkChoiceV28 {
     type Error = ssz::DecodeError;
@@ -1549,18 +1816,29 @@ impl TryFrom<PersistedForkChoiceV17> for PersistedForkChoiceV28 {
     fn try_from(v17: PersistedForkChoiceV17) -> Result<Self, Self::Error> {
         let container_v17 =
             proto_array::core::SszContainerV17::from_ssz_bytes(&v17.proto_array_bytes)?;
-        let container_v28 = container_v17.into();
+        let container_v28: proto_array::core::SszContainerV28 = container_v17.into();
 
         Ok(Self {
-            proto_array: container_v28,
+            proto_array_v28: container_v28,
             queued_attestations: v17.queued_attestations,
         })
     }
 }
 
+impl From<PersistedForkChoiceV28> for PersistedForkChoiceV29 {
+    fn from(v28: PersistedForkChoiceV28) -> Self {
+        Self {
+            proto_array: v28.proto_array_v28.into(),
+            queued_attestations: v28.queued_attestations,
+            queued_payload_attestations: vec![],
+        }
+    }
+}
+
 impl From<(PersistedForkChoiceV28, JustifiedBalances)> for PersistedForkChoiceV17 {
     fn from((v28, balances): (PersistedForkChoiceV28, JustifiedBalances)) -> Self {
-        let container_v17 = proto_array::core::SszContainerV17::from((v28.proto_array, balances));
+        let container_v17 =
+            proto_array::core::SszContainerV17::from((v28.proto_array_v28, balances));
         let proto_array_bytes = container_v17.as_ssz_bytes();
 
         Self {
@@ -1605,6 +1883,7 @@ mod tests {
                 attesting_indices: vec![],
                 block_root: Hash256::zero(),
                 target_epoch: Epoch::new(0),
+                payload_present: false,
             })
             .collect()
     }
diff --git a/consensus/fork_choice/src/lib.rs b/consensus/fork_choice/src/lib.rs
index afe06dee1bc..824fc2dff05 100644
--- a/consensus/fork_choice/src/lib.rs
+++ b/consensus/fork_choice/src/lib.rs
@@ -3,9 +3,10 @@ mod fork_choice_store;
 mod metrics;
 
 pub use crate::fork_choice::{
-    AttestationFromBlock, Error, ForkChoice, ForkChoiceView, ForkchoiceUpdateParameters,
-    InvalidAttestation, InvalidBlock, PayloadVerificationStatus, PersistedForkChoice,
-    PersistedForkChoiceV17, PersistedForkChoiceV28, QueuedAttestation, ResetPayloadStatuses,
+    Error, ForkChoice, ForkChoiceView, ForkchoiceUpdateParameters, InvalidAttestation,
+    InvalidBlock, PayloadVerificationStatus, PersistedForkChoice, PersistedForkChoiceV17,
+    PersistedForkChoiceV28, PersistedForkChoiceV29, QueuedAttestation, QueuedPayloadAttestation,
+    ResetPayloadStatuses,
 };
 pub use fork_choice_store::ForkChoiceStore;
 pub use proto_array::{
diff --git a/consensus/fork_choice/tests/tests.rs b/consensus/fork_choice/tests/tests.rs
index d3a84ee85be..44da1af148e 100644
--- a/consensus/fork_choice/tests/tests.rs
+++ b/consensus/fork_choice/tests/tests.rs
@@ -7,9 +7,11 @@ use beacon_chain::{
     BeaconChain, BeaconChainError, BeaconForkChoiceStore, ChainConfig, ForkChoiceError,
     StateSkipConfig, WhenSlotSkipped,
 };
+use bls::AggregateSignature;
 use fixed_bytes::FixedBytesExtended;
 use fork_choice::{
-    ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus, QueuedAttestation,
+    ForkChoiceStore, InvalidAttestation, InvalidBlock, PayloadVerificationStatus,
+    QueuedAttestation, QueuedPayloadAttestation,
 };
 use state_processing::state_advance::complete_state_advance;
 use std::fmt;
@@ -19,8 +21,8 @@ use store::MemoryStore;
 use types::SingleAttestation;
 use types::{
     BeaconBlockRef, BeaconState, ChainSpec, Checkpoint, Epoch, EthSpec, ForkName, Hash256,
-    IndexedAttestation, MainnetEthSpec, RelativeEpoch, SignedBeaconBlock, Slot, SubnetId,
-    test_utils::generate_deterministic_keypair,
+    IndexedAttestation, IndexedPayloadAttestation, MainnetEthSpec, PayloadAttestationData,
+    RelativeEpoch, SignedBeaconBlock, Slot, SubnetId, test_utils::generate_deterministic_keypair,
 };
 
 pub type E = MainnetEthSpec;
@@ -71,6 +73,22 @@ impl ForkChoiceTest {
         Self { harness }
     }
 
+    /// Creates a new tester with the GLOAS fork active at epoch 1.
+    /// Genesis is a standard Fulu block (epoch 0), so block production works normally.
+    /// Tests that need GLOAS semantics should advance the chain into epoch 1 first.
+    pub fn new_with_gloas() -> Self {
+        let mut spec = ForkName::latest_stable().make_genesis_spec(ChainSpec::default());
+        spec.gloas_fork_epoch = Some(Epoch::new(1));
+        let harness = BeaconChainHarness::builder(MainnetEthSpec)
+            .spec(spec.into())
+            .deterministic_keypairs(VALIDATOR_COUNT)
+            .fresh_ephemeral_store()
+            .mock_execution_layer()
+            .build();
+
+        Self { harness }
+    }
+
     /// Get a value from the `ForkChoice` instantiation.
     fn get<T, U>(&self, func: T) -> U
     where
@@ -154,6 +172,28 @@ impl ForkChoiceTest {
         self
     }
 
+    /// Inspect the queued payload attestations in fork choice.
+    #[allow(dead_code)]
+    pub fn inspect_queued_payload_attestations<F>(self, mut func: F) -> Self
+    where
+        F: FnMut(&[QueuedPayloadAttestation]),
+    {
+        self.harness
+            .chain
+            .canonical_head
+            .fork_choice_write_lock()
+            .update_time(self.harness.chain.slot().unwrap())
+            .unwrap();
+        func(
+            self.harness
+                .chain
+                .canonical_head
+                .fork_choice_read_lock()
+                .queued_payload_attestations(),
+        );
+        self
+    }
+
     /// Skip a slot, without producing a block.
     pub fn skip_slot(self) -> Self {
         self.harness.advance_slot();
@@ -923,6 +963,138 @@ async fn invalid_attestation_future_block() {
         .await;
 }
 
+/// Payload attestations (index == 1) are invalid when they refer to a block in the same slot.
+/// This check only applies when GLOAS is active.
+///
+/// TODO(gloas): un-ignore once the test harness supports Gloas block production.
+/// The validation logic is gated on `spec.fork_name_at_slot().gloas_enabled()` in
+/// `validate_on_attestation`, which requires a block to exist at a GLOAS-enabled slot.
+/// Currently the mock execution layer cannot produce Gloas blocks (no
+/// `signed_execution_payload_bid` support).
+#[ignore]
+#[tokio::test]
+async fn invalid_attestation_payload_during_same_slot() {
+    ForkChoiceTest::new_with_gloas()
+        .apply_blocks_without_new_attestations(1)
+        .await
+        .apply_attestation_to_chain(
+            MutationDelay::NoDelay,
+            |attestation, chain| {
+                let block_slot = chain
+                    .get_blinded_block(&attestation.data().beacon_block_root)
+                    .expect("should read attested block")
+                    .expect("attested block should exist")
+                    .slot();
+
+                attestation.data_mut().slot = block_slot;
+                attestation.data_mut().target.epoch = block_slot.epoch(E::slots_per_epoch());
+                attestation.data_mut().index = 1;
+            },
+            |result| {
+                assert_invalid_attestation!(
+                    result,
+                    InvalidAttestation::InvalidSameSlotAttestationIndex { slot }
+                    if slot == Slot::new(1)
+                )
+            },
+        )
+        .await;
+}
+
+/// A payload attestation for block A at slot S should be accepted when processed at slot S+1.
+#[tokio::test]
+async fn payload_attestation_for_previous_slot_is_accepted_at_next_slot() {
+    let test = ForkChoiceTest::new()
+        .apply_blocks_without_new_attestations(1)
+        .await;
+
+    let chain = &test.harness.chain;
+    let block_a = chain
+        .block_at_slot(Slot::new(1), WhenSlotSkipped::Prev)
+        .expect("lookup should succeed")
+        .expect("block A should exist");
+    let block_a_root = block_a.canonical_root();
+    let current_slot = block_a.slot().saturating_add(1_u64);
+
+    let payload_attestation = IndexedPayloadAttestation::<E> {
+        attesting_indices: vec![0_u64].try_into().expect("valid attesting indices"),
+        data: PayloadAttestationData {
+            beacon_block_root: block_a_root,
+            slot: Slot::new(1),
+            payload_present: true,
+            blob_data_available: true,
+        },
+        signature: AggregateSignature::empty(),
+    };
+
+    // PTC mapping: validator 0 is at ptc position 0.
+    let ptc = &[0_usize];
+
+    let result = chain
+        .canonical_head
+        .fork_choice_write_lock()
+        .on_payload_attestation(current_slot, &payload_attestation, true, ptc);
+
+    assert!(
+        result.is_ok(),
+        "payload attestation at slot S should be accepted at S+1, got: {:?}",
+        result
+    );
+
+    let latest_message = chain
+        .canonical_head
+        .fork_choice_read_lock()
+        .latest_message(0)
+        .expect("latest message should exist");
+    assert_eq!(latest_message.slot, current_slot);
+    assert!(latest_message.payload_present);
+}
+
+/// Gossip payload attestations must be for the current slot. A payload attestation for slot S
+/// received at slot S+1 should be rejected per the spec.
+#[tokio::test]
+async fn non_block_payload_attestation_for_previous_slot_is_rejected() {
+    let test = ForkChoiceTest::new()
+        .apply_blocks_without_new_attestations(1)
+        .await;
+
+    let chain = &test.harness.chain;
+    let block_a = chain
+        .block_at_slot(Slot::new(1), WhenSlotSkipped::Prev)
+        .expect("lookup should succeed")
+        .expect("block A should exist");
+    let block_a_root = block_a.canonical_root();
+    let s_plus_1 = block_a.slot().saturating_add(1_u64);
+
+    let payload_attestation = IndexedPayloadAttestation::<E> {
+        attesting_indices: vec![0_u64].try_into().expect("valid attesting indices"),
+        data: PayloadAttestationData {
+            beacon_block_root: block_a_root,
+            slot: Slot::new(1),
+            payload_present: true,
+            blob_data_available: true,
+        },
+        signature: AggregateSignature::empty(),
+    };
+
+    let ptc = &[0_usize];
+
+    let result = chain
+        .canonical_head
+        .fork_choice_write_lock()
+        .on_payload_attestation(s_plus_1, &payload_attestation, false, ptc);
+    assert!(
+        matches!(
+            result,
+            Err(ForkChoiceError::InvalidAttestation(
+                InvalidAttestation::PayloadAttestationNotCurrentSlot { .. }
+            ))
+        ),
+        "gossip payload attestation for previous slot should be rejected, got: {:?}",
+        result
+    );
+}
+
 /// Specification v0.12.1:
 ///
 /// assert target.root == get_ancestor(store, attestation.data.beacon_block_root, target_slot)
diff --git a/consensus/proto_array/Cargo.toml b/consensus/proto_array/Cargo.toml
index 782610e0d35..f9c35bb5850 100644
--- a/consensus/proto_array/Cargo.toml
+++ b/consensus/proto_array/Cargo.toml
@@ -15,5 +15,7 @@ fixed_bytes = { workspace = true }
 safe_arith = { workspace = true }
 serde = { workspace = true }
 serde_yaml = { workspace = true }
+smallvec = { workspace = true }
 superstruct = { workspace = true }
+typenum = { workspace = true }
 types = { workspace = true }
diff --git a/consensus/proto_array/src/bin.rs b/consensus/proto_array/src/bin.rs
index e1d307affb4..c5df3f17e4a 100644
--- a/consensus/proto_array/src/bin.rs
+++ b/consensus/proto_array/src/bin.rs
@@ -18,6 +18,14 @@ fn main() {
         "execution_status_03.yaml",
         get_execution_status_test_definition_03(),
     );
+    write_test_def_to_yaml(
+        "gloas_chain_following.yaml",
+        get_gloas_chain_following_test_definition(),
+    );
+    write_test_def_to_yaml(
+        "gloas_payload_probe.yaml",
+        get_gloas_payload_probe_test_definition(),
+    );
 }
 
 fn write_test_def_to_yaml(filename: &str, def: ForkChoiceTestDefinition) {
diff --git a/consensus/proto_array/src/error.rs b/consensus/proto_array/src/error.rs
index 35cb4007b78..04e747f5f6f 100644
--- a/consensus/proto_array/src/error.rs
+++ b/consensus/proto_array/src/error.rs
@@ -54,6 +54,12 @@ pub enum Error {
     },
     InvalidEpochOffset(u64),
     Arith(ArithError),
+    InvalidNodeVariant {
+        block_root: Hash256,
+    },
+    BrokenBlock {
+        block_root: Hash256,
+    },
 }
 
 impl From<ArithError> for Error {
diff --git a/consensus/proto_array/src/fork_choice_test_definition.rs b/consensus/proto_array/src/fork_choice_test_definition.rs
index e9deb6759fc..a89073a7b86 100644
--- a/consensus/proto_array/src/fork_choice_test_definition.rs
+++ b/consensus/proto_array/src/fork_choice_test_definition.rs
@@ -1,20 +1,23 @@
 mod execution_status;
 mod ffg_updates;
+mod gloas_payload;
 mod no_votes;
 mod votes;
 
-use crate::proto_array_fork_choice::{Block, ExecutionStatus, ProtoArrayForkChoice};
+use crate::proto_array_fork_choice::{Block, ExecutionStatus, PayloadStatus, ProtoArrayForkChoice};
 use crate::{InvalidationOperation, JustifiedBalances};
 use fixed_bytes::FixedBytesExtended;
 use serde::{Deserialize, Serialize};
+use ssz::BitVector;
 use std::collections::BTreeSet;
 use types::{
-    AttestationShufflingId, Checkpoint, Epoch, EthSpec, ExecutionBlockHash, Hash256,
+    AttestationShufflingId, ChainSpec, Checkpoint, Epoch, EthSpec, ExecutionBlockHash, Hash256,
     MainnetEthSpec, Slot,
 };
 
 pub use execution_status::*;
 pub use ffg_updates::*;
+pub use gloas_payload::*;
 pub use no_votes::*;
 pub use votes::*;
 
@@ -25,6 +28,7 @@ pub enum Operation {
         finalized_checkpoint: Checkpoint,
         justified_state_balances: Vec<u64>,
         expected_head: Hash256,
+        current_slot: Slot,
     },
     ProposerBoostFindHead {
         justified_checkpoint: Checkpoint,
@@ -44,11 +48,23 @@ pub enum Operation {
         parent_root: Hash256,
         justified_checkpoint: Checkpoint,
         finalized_checkpoint: Checkpoint,
+        #[serde(default)]
+        execution_payload_parent_hash: Option<ExecutionBlockHash>,
+        #[serde(default)]
+        execution_payload_block_hash: Option<ExecutionBlockHash>,
     },
     ProcessAttestation {
         validator_index: usize,
         block_root: Hash256,
-        target_epoch: Epoch,
+        attestation_slot: Slot,
+    },
+    ProcessPayloadAttestation {
+        validator_index: usize,
+        block_root: Hash256,
+        attestation_slot: Slot,
+        payload_present: bool,
+        #[serde(default)]
+        blob_data_available: bool,
     },
     Prune {
         finalized_root: Hash256,
@@ -63,6 +79,34 @@ pub enum Operation {
         block_root: Hash256,
         weight: u64,
     },
+    AssertPayloadWeights {
+        block_root: Hash256,
+        expected_full_weight: u64,
+        expected_empty_weight: u64,
+    },
+    AssertParentPayloadStatus {
+        block_root: Hash256,
+        expected_status: PayloadStatus,
+    },
+    AssertHeadPayloadStatus {
+        head_root: Hash256,
+        expected_status: PayloadStatus,
+        current_slot: Slot,
+    },
+    SetPayloadTiebreak {
+        block_root: Hash256,
+        is_timely: bool,
+        is_data_available: bool,
+    },
+    /// Simulate receiving and validating an execution payload for `block_root`.
+    /// Sets `payload_received = true` on the V29 node via the live validation path.
+    ProcessExecutionPayload {
+        block_root: Hash256,
+    },
+    AssertPayloadReceived {
+        block_root: Hash256,
+        expected: bool,
+    },
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -71,12 +115,23 @@ pub struct ForkChoiceTestDefinition {
     pub justified_checkpoint: Checkpoint,
     pub finalized_checkpoint: Checkpoint,
     pub operations: Vec<Operation>,
+    #[serde(default)]
+    pub execution_payload_parent_hash: Option<ExecutionBlockHash>,
+    #[serde(default)]
+    pub execution_payload_block_hash: Option<ExecutionBlockHash>,
+    #[serde(skip)]
+    pub spec: Option<ChainSpec>,
 }
 
 impl ForkChoiceTestDefinition {
     pub fn run(self) {
-        let mut spec = MainnetEthSpec::default_spec();
-        spec.proposer_score_boost = Some(50);
+        let spec = self.spec.unwrap_or_else(|| {
+            let mut spec = MainnetEthSpec::default_spec();
+            spec.proposer_score_boost = Some(50);
+            // Legacy test definitions target pre-Gloas behaviour unless explicitly overridden.
+            spec.gloas_fork_epoch = None;
+            spec
+        });
 
         let junk_shuffling_id =
             AttestationShufflingId::from_components(Epoch::new(0), Hash256::zero());
@@ -89,6 +144,9 @@ impl ForkChoiceTestDefinition {
             junk_shuffling_id.clone(),
             junk_shuffling_id,
             ExecutionStatus::Optimistic(ExecutionBlockHash::zero()),
+            self.execution_payload_parent_hash,
+            self.execution_payload_block_hash,
+            &spec,
         )
         .expect("should create fork choice struct");
         let equivocating_indices = BTreeSet::new();
@@ -100,6 +158,7 @@ impl ForkChoiceTestDefinition {
                     finalized_checkpoint,
                     justified_state_balances,
                     expected_head,
+                    current_slot,
                 } => {
                     let justified_balances =
                         JustifiedBalances::from_effective_balances(justified_state_balances)
@@ -111,7 +170,7 @@ impl ForkChoiceTestDefinition {
                             &justified_balances,
                             Hash256::zero(),
                             &equivocating_indices,
-                            Slot::new(0),
+                            current_slot,
                             &spec,
                         )
                         .unwrap_or_else(|e| {
@@ -188,6 +247,8 @@ impl ForkChoiceTestDefinition {
                     parent_root,
                     justified_checkpoint,
                     finalized_checkpoint,
+                    execution_payload_parent_hash,
+                    execution_payload_block_hash,
                 } => {
                     let block = Block {
                         slot,
@@ -211,6 +272,9 @@ impl ForkChoiceTestDefinition {
                         ),
                         unrealized_justified_checkpoint: None,
                         unrealized_finalized_checkpoint: None,
+                        execution_payload_parent_hash,
+                        execution_payload_block_hash,
+                        proposer_index: None,
                     };
                     fork_choice
                         .process_block::<MainnetEthSpec>(
@@ -218,6 +282,7 @@ impl ForkChoiceTestDefinition {
                             slot,
                             self.justified_checkpoint,
                             self.finalized_checkpoint,
+                            &spec,
                         )
                         .unwrap_or_else(|e| {
                             panic!(
@@ -230,10 +295,10 @@ impl ForkChoiceTestDefinition {
                 Operation::ProcessAttestation {
                     validator_index,
                     block_root,
-                    target_epoch,
+                    attestation_slot,
                 } => {
                     fork_choice
-                        .process_attestation(validator_index, block_root, target_epoch)
+                        .process_attestation(validator_index, block_root, attestation_slot, false)
                         .unwrap_or_else(|_| {
                             panic!(
                                 "process_attestation op at index {} returned error",
@@ -242,6 +307,28 @@ impl ForkChoiceTestDefinition {
                         });
                     check_bytes_round_trip(&fork_choice);
                 }
+                Operation::ProcessPayloadAttestation {
+                    validator_index,
+                    block_root,
+                    attestation_slot: _,
+                    payload_present,
+                    blob_data_available,
+                } => {
+                    fork_choice
+                        .process_payload_attestation(
+                            block_root,
+                            validator_index,
+                            payload_present,
+                            blob_data_available,
+                        )
+                        .unwrap_or_else(|_| {
+                            panic!(
+                                "process_payload_attestation op at index {} returned error",
+                                op_index
+                            )
+                        });
+                    check_bytes_round_trip(&fork_choice);
+                }
                 Operation::Prune {
                     finalized_root,
                     prune_threshold,
@@ -287,8 +374,172 @@ impl ForkChoiceTestDefinition {
                 Operation::AssertWeight { block_root, weight } => assert_eq!(
                     fork_choice.get_weight(&block_root).unwrap(),
                     weight,
-                    "block weight"
+                    "block weight at op index {}",
+                    op_index
                 ),
+                Operation::AssertPayloadWeights {
+                    block_root,
+                    expected_full_weight,
+                    expected_empty_weight,
+                } => {
+                    let block_index = fork_choice
+                        .proto_array
+                        .indices
+                        .get(&block_root)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "AssertPayloadWeights: block root not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let node = fork_choice
+                        .proto_array
+                        .nodes
+                        .get(*block_index)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "AssertPayloadWeights: node not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let v29 = node.as_v29().unwrap_or_else(|_| {
+                        panic!(
+                            "AssertPayloadWeights: node is not V29 at op index {}",
+                            op_index
+                        )
+                    });
+                    assert_eq!(
+                        v29.full_payload_weight, expected_full_weight,
+                        "full_payload_weight mismatch at op index {}",
+                        op_index
+                    );
+                    assert_eq!(
+                        v29.empty_payload_weight, expected_empty_weight,
+                        "empty_payload_weight mismatch at op index {}",
+                        op_index
+                    );
+                }
+                Operation::AssertParentPayloadStatus {
+                    block_root,
+                    expected_status,
+                } => {
+                    let block_index = fork_choice
+                        .proto_array
+                        .indices
+                        .get(&block_root)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "AssertParentPayloadStatus: block root not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let node = fork_choice
+                        .proto_array
+                        .nodes
+                        .get(*block_index)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "AssertParentPayloadStatus: node not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let v29 = node.as_v29().unwrap_or_else(|_| {
+                        panic!(
+                            "AssertParentPayloadStatus: node is not V29 at op index {}",
+                            op_index
+                        )
+                    });
+                    assert_eq!(
+                        v29.parent_payload_status, expected_status,
+                        "parent_payload_status mismatch at op index {}",
+                        op_index
+                    );
+                }
+                Operation::AssertHeadPayloadStatus {
+                    head_root,
+                    expected_status,
+                    current_slot,
+                } => {
+                    let actual = fork_choice
+                        .head_payload_status::<MainnetEthSpec>(&head_root, current_slot)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "AssertHeadPayloadStatus: head root not found at op index {}",
+                                op_index
+                            )
+                        });
+                    assert_eq!(
+                        actual, expected_status,
+                        "head_payload_status mismatch at op index {}",
+                        op_index
+                    );
+                }
+                Operation::SetPayloadTiebreak {
+                    block_root,
+                    is_timely,
+                    is_data_available,
+                } => {
+                    let block_index = fork_choice
+                        .proto_array
+                        .indices
+                        .get(&block_root)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "SetPayloadTiebreak: block root not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let node = fork_choice
+                        .proto_array
+                        .nodes
+                        .get_mut(*block_index)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "SetPayloadTiebreak: node not found at op index {}",
+                                op_index
+                            )
+                        });
+                    let node_v29 = node.as_v29_mut().unwrap_or_else(|_| {
+                        panic!(
+                            "SetPayloadTiebreak: node is not V29 at op index {}",
+                            op_index
+                        )
+                    });
+                    // Set all bits (exceeds any threshold) or clear all bits.
+                    let fill = if is_timely { 0xFF } else { 0x00 };
+                    node_v29.payload_timeliness_votes =
+                        BitVector::from_bytes(smallvec::smallvec![fill; 64])
+                            .expect("valid 512-bit bitvector");
+                    let fill = if is_data_available { 0xFF } else { 0x00 };
+                    node_v29.payload_data_availability_votes =
+                        BitVector::from_bytes(smallvec::smallvec![fill; 64])
+                            .expect("valid 512-bit bitvector");
+                    // Per spec, is_payload_timely/is_payload_data_available require
+                    // the payload to be in payload_states (payload_received).
+                    node_v29.payload_received = is_timely || is_data_available;
+                }
+                Operation::ProcessExecutionPayload { block_root } => {
+                    fork_choice
+                        .on_execution_payload(block_root)
+                        .unwrap_or_else(|e| {
+                            panic!(
+                                "on_execution_payload op at index {} returned error: {}",
+                                op_index, e
+                            )
+                        });
+                    check_bytes_round_trip(&fork_choice);
+                }
+                Operation::AssertPayloadReceived {
+                    block_root,
+                    expected,
+                } => {
+                    let actual = fork_choice.is_payload_received(&block_root);
+                    assert_eq!(
+                        actual, expected,
+                        "payload_received mismatch at op index {}",
+                        op_index
+                    );
+                }
             }
         }
     }
@@ -314,8 +565,7 @@ fn get_checkpoint(i: u64) -> Checkpoint {
 }
 
 fn check_bytes_round_trip(original: &ProtoArrayForkChoice) {
-    // The checkpoint are ignored `ProtoArrayForkChoice::from_bytes` so any value is ok
-    let bytes = original.as_bytes(Checkpoint::default(), Checkpoint::default());
+    let bytes = original.as_bytes();
     let decoded = ProtoArrayForkChoice::from_bytes(&bytes, original.balances.clone())
         .expect("fork choice should decode from bytes");
     assert!(
diff --git a/consensus/proto_array/src/fork_choice_test_definition/execution_status.rs b/consensus/proto_array/src/fork_choice_test_definition/execution_status.rs
index aa26a843069..59e80dbe66b 100644
--- a/consensus/proto_array/src/fork_choice_test_definition/execution_status.rs
+++ b/consensus/proto_array/src/fork_choice_test_definition/execution_status.rs
@@ -16,6 +16,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 2.
@@ -35,6 +36,8 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is 2
@@ -53,6 +56,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 1 that comes off the genesis block (this is a fork compared
@@ -73,6 +77,8 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -91,6 +97,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to block 1
@@ -101,7 +108,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(1),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is now 1, because 1 has a vote.
@@ -120,6 +127,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -143,7 +151,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(2),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is 2 since 1 and 2 both have a vote
@@ -162,6 +170,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -196,6 +205,8 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -216,6 +227,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -245,7 +257,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(3),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Ensure that the head is still 2
@@ -266,6 +278,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -315,6 +328,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Invalidation of 3 should have removed upstream weight.
@@ -347,7 +361,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(1),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Ensure that the head has switched back to 1
@@ -368,6 +382,7 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances,
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -399,6 +414,9 @@ pub fn get_execution_status_test_definition_01() -> ForkChoiceTestDefinition {
             root: get_root(0),
         },
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
@@ -418,6 +436,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 2.
@@ -437,6 +456,8 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is 2
@@ -455,6 +476,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 1 that comes off the genesis block (this is a fork compared
@@ -475,6 +497,8 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -493,6 +517,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to block 1
@@ -503,7 +528,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(1),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is now 1, because 1 has a vote.
@@ -522,6 +547,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -545,7 +571,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(2),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is 2 since 1 and 2 both have a vote
@@ -564,6 +590,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -598,6 +625,8 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -618,6 +647,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -647,7 +677,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(3),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Move validator #1 vote from 2 to 3
@@ -660,7 +690,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(3),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Ensure that the head is now 3.
@@ -681,6 +711,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(3),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -730,6 +761,7 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances,
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Invalidation of 3 should have removed upstream weight.
@@ -763,6 +795,9 @@ pub fn get_execution_status_test_definition_02() -> ForkChoiceTestDefinition {
             root: get_root(0),
         },
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
@@ -782,6 +817,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 2.
@@ -801,6 +837,8 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is 2
@@ -819,6 +857,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 1 that comes off the genesis block (this is a fork compared
@@ -839,6 +878,8 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -857,6 +898,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to block 1
@@ -867,7 +909,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(1),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is now 1, because 1 has a vote.
@@ -886,6 +928,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -909,7 +952,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(1),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is 1.
@@ -928,6 +971,7 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     ops.push(Operation::AssertWeight {
@@ -962,6 +1006,8 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is now 3, applying a proposer boost to 3 as well.
@@ -1065,6 +1111,9 @@ pub fn get_execution_status_test_definition_03() -> ForkChoiceTestDefinition {
             root: get_root(0),
         },
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
diff --git a/consensus/proto_array/src/fork_choice_test_definition/ffg_updates.rs b/consensus/proto_array/src/fork_choice_test_definition/ffg_updates.rs
index 3b31616145d..34a4372e274 100644
--- a/consensus/proto_array/src/fork_choice_test_definition/ffg_updates.rs
+++ b/consensus/proto_array/src/fork_choice_test_definition/ffg_updates.rs
@@ -10,6 +10,7 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Build the following tree (stick? lol).
@@ -27,6 +28,8 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(0),
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(2),
@@ -34,6 +37,8 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(1),
         justified_checkpoint: get_checkpoint(1),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(3),
@@ -41,6 +46,8 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(2),
         justified_checkpoint: get_checkpoint(2),
         finalized_checkpoint: get_checkpoint(1),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that with justified epoch 0 we find 3
@@ -57,6 +64,7 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(3),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that with justified epoch 1 we find 3
@@ -77,6 +85,7 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(3),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that with justified epoch 2 we find 3
@@ -93,6 +102,7 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(1),
         justified_state_balances: balances,
         expected_head: get_root(3),
+        current_slot: Slot::new(0),
     });
 
     // END OF TESTS
@@ -101,6 +111,9 @@ pub fn get_ffg_case_01_test_definition() -> ForkChoiceTestDefinition {
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
@@ -114,6 +127,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Build the following tree.
@@ -137,6 +151,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(0),
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(2),
@@ -147,6 +163,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(1),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(3),
@@ -157,6 +175,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(1),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(4),
@@ -167,6 +187,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(1),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(5),
@@ -177,6 +199,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(3),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     //  Right branch
@@ -186,6 +210,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(0),
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(2),
@@ -193,6 +219,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(2),
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(3),
@@ -200,6 +228,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         parent_root: get_root(4),
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(4),
@@ -210,6 +240,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(2),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(5),
@@ -220,6 +252,8 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(4),
         },
         finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that if we start at 0 we find 10 (just: 0, fin: 0).
@@ -240,6 +274,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above, but with justified epoch 2.
     ops.push(Operation::FindHead {
@@ -250,6 +285,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above, but with justified epoch 3.
     //
@@ -264,6 +300,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to 1.
@@ -282,7 +319,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(1),
-        target_epoch: Epoch::new(0),
+        attestation_slot: Slot::new(0),
     });
 
     // Ensure that if we start at 0 we find 9 (just: 0, fin: 0).
@@ -303,6 +340,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
     // Save as above but justified epoch 2.
     ops.push(Operation::FindHead {
@@ -313,6 +351,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
     // Save as above but justified epoch 3.
     //
@@ -327,6 +366,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to 2.
@@ -345,7 +385,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(2),
-        target_epoch: Epoch::new(0),
+        attestation_slot: Slot::new(0),
     });
 
     // Ensure that if we start at 0 we find 10 (just: 0, fin: 0).
@@ -366,6 +406,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 2.
     ops.push(Operation::FindHead {
@@ -376,6 +417,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 3.
     //
@@ -390,6 +432,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that if we start at 1 we find 9 (just: 0, fin: 0).
@@ -413,6 +456,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 2.
     ops.push(Operation::FindHead {
@@ -423,6 +467,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 3.
     //
@@ -437,6 +482,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that if we start at 2 we find 10 (just: 0, fin: 0).
@@ -457,6 +503,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 2.
     ops.push(Operation::FindHead {
@@ -467,6 +514,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
     // Same as above but justified epoch 3.
     //
@@ -481,6 +529,7 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         finalized_checkpoint: get_checkpoint(0),
         justified_state_balances: balances,
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
 
     // END OF TESTS
@@ -489,6 +538,9 @@ pub fn get_ffg_case_02_test_definition() -> ForkChoiceTestDefinition {
         justified_checkpoint: get_checkpoint(0),
         finalized_checkpoint: get_checkpoint(0),
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
diff --git a/consensus/proto_array/src/fork_choice_test_definition/gloas_payload.rs b/consensus/proto_array/src/fork_choice_test_definition/gloas_payload.rs
new file mode 100644
index 00000000000..8354b22e474
--- /dev/null
+++ b/consensus/proto_array/src/fork_choice_test_definition/gloas_payload.rs
@@ -0,0 +1,762 @@
+use super::*;
+
+fn gloas_spec() -> ChainSpec {
+    let mut spec = MainnetEthSpec::default_spec();
+    spec.proposer_score_boost = Some(50);
+    spec.gloas_fork_epoch = Some(Epoch::new(0));
+    spec
+}
+
+pub fn get_gloas_chain_following_test_definition() -> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Build two branches off genesis where one child extends parent's payload chain (Full)
+    // and the other does not (Empty).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(2),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(99)),
+        execution_payload_block_hash: Some(get_hash(2)),
+    });
+
+    // Extend both branches to verify that head selection follows the selected chain.
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(3),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(3)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(4),
+        parent_root: get_root(2),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(100)),
+        execution_payload_block_hash: Some(get_hash(4)),
+    });
+
+    // Mark root_1 as having received its execution payload so that
+    // its FULL virtual node exists in the GLOAS fork choice tree.
+    ops.push(Operation::ProcessExecutionPayload {
+        block_root: get_root(1),
+    });
+
+    ops.push(Operation::AssertParentPayloadStatus {
+        block_root: get_root(1),
+        expected_status: PayloadStatus::Full,
+    });
+    ops.push(Operation::AssertParentPayloadStatus {
+        block_root: get_root(2),
+        expected_status: PayloadStatus::Empty,
+    });
+
+    // With equal full/empty parent weights, tiebreak decides which chain to follow.
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: true,
+        is_data_available: true,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(3),
+        current_slot: Slot::new(0),
+    });
+
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: false,
+        is_data_available: false,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(4),
+        current_slot: Slot::new(0),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+pub fn get_gloas_payload_probe_test_definition() -> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+
+    // One Full and one Empty vote for the same head block: tie probes via runtime tiebreak,
+    // which defaults to Empty unless timely+data-available evidence is set.
+    ops.push(Operation::ProcessPayloadAttestation {
+        validator_index: 0,
+        block_root: get_root(1),
+        attestation_slot: Slot::new(2),
+        payload_present: true,
+        blob_data_available: false,
+    });
+    ops.push(Operation::ProcessPayloadAttestation {
+        validator_index: 1,
+        block_root: get_root(1),
+        attestation_slot: Slot::new(2),
+        payload_present: false,
+        blob_data_available: false,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(1),
+        current_slot: Slot::new(0),
+    });
+    // PTC votes write to bitfields only, not to full/empty weight.
+    // Weight is 0 because no CL attestations target this block.
+    ops.push(Operation::AssertPayloadWeights {
+        block_root: get_root(1),
+        expected_full_weight: 0,
+        expected_empty_weight: 0,
+    });
+    // With MainnetEthSpec PTC_SIZE=512, 1 bit set out of 256 threshold → not timely → Empty.
+    ops.push(Operation::AssertHeadPayloadStatus {
+        head_root: get_root(1),
+        expected_status: PayloadStatus::Empty,
+        current_slot: Slot::new(0),
+    });
+
+    // Flip validator 0 to Empty; both bits now clear.
+    ops.push(Operation::ProcessPayloadAttestation {
+        validator_index: 0,
+        block_root: get_root(1),
+        attestation_slot: Slot::new(3),
+        payload_present: false,
+        blob_data_available: false,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(1),
+        current_slot: Slot::new(0),
+    });
+    ops.push(Operation::AssertPayloadWeights {
+        block_root: get_root(1),
+        expected_full_weight: 0,
+        expected_empty_weight: 0,
+    });
+    ops.push(Operation::AssertHeadPayloadStatus {
+        head_root: get_root(1),
+        expected_status: PayloadStatus::Empty,
+        current_slot: Slot::new(0),
+    });
+
+    // Same-slot attestation to a new head candidate should be Pending (no payload bucket change).
+    // Root 5 is an Empty child of root_1 (parent_hash doesn't match root_1's block_hash),
+    // so it's reachable through root_1's Empty direction (root_1 has no payload_received).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(3),
+        root: get_root(5),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(101)),
+        execution_payload_block_hash: Some(get_hash(5)),
+    });
+    ops.push(Operation::ProcessPayloadAttestation {
+        validator_index: 2,
+        block_root: get_root(5),
+        attestation_slot: Slot::new(3),
+        payload_present: true,
+        blob_data_available: false,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1, 1],
+        expected_head: get_root(5),
+        current_slot: Slot::new(0),
+    });
+    ops.push(Operation::AssertPayloadWeights {
+        block_root: get_root(5),
+        expected_full_weight: 0,
+        expected_empty_weight: 0,
+    });
+    ops.push(Operation::AssertHeadPayloadStatus {
+        head_root: get_root(5),
+        expected_status: PayloadStatus::Empty,
+        current_slot: Slot::new(0),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+/// Test that CL attestation weight can flip the head between Full/Empty branches,
+/// overriding the tiebreaker.
+pub fn get_gloas_find_head_vote_transition_test_definition() -> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Competing branches with distinct payload ancestry (Full vs Empty from genesis).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(2),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(99)),
+        execution_payload_block_hash: Some(get_hash(2)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(3),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(3)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(4),
+        parent_root: get_root(2),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(100)),
+        execution_payload_block_hash: Some(get_hash(4)),
+    });
+
+    // Mark root_1 as having received its execution payload so that
+    // its FULL virtual node exists in the GLOAS fork choice tree.
+    ops.push(Operation::ProcessExecutionPayload {
+        block_root: get_root(1),
+    });
+
+    // Equal branch weights: tiebreak FULL picks branch rooted at 3.
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: true,
+        is_data_available: true,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(3),
+        current_slot: Slot::new(0),
+    });
+
+    // CL attestation to Empty branch (root 4) from validator 0 → head flips to 4.
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 0,
+        block_root: get_root(4),
+        attestation_slot: Slot::new(3),
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(4),
+        current_slot: Slot::new(0),
+    });
+
+    // CL attestation back to Full branch (root 3) → head returns to 3.
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 0,
+        block_root: get_root(3),
+        attestation_slot: Slot::new(4),
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(3),
+        current_slot: Slot::new(0),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+/// CL attestation weight overrides payload preference tiebreaker.
+pub fn get_gloas_weight_priority_over_payload_preference_test_definition()
+-> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Build two branches where one child extends payload (Full) and the other doesn't (Empty).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(2),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(99)),
+        execution_payload_block_hash: Some(get_hash(2)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(3),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(3)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(4),
+        parent_root: get_root(2),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(100)),
+        execution_payload_block_hash: Some(get_hash(4)),
+    });
+
+    // Mark root_1 as having received its execution payload so that
+    // its FULL virtual node exists in the GLOAS fork choice tree.
+    ops.push(Operation::ProcessExecutionPayload {
+        block_root: get_root(1),
+    });
+
+    // Parent prefers Full on equal branch weights (tiebreaker).
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: true,
+        is_data_available: true,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1],
+        expected_head: get_root(3),
+        current_slot: Slot::new(0),
+    });
+
+    // Two CL attestations to the Empty branch make it strictly heavier,
+    // overriding the Full tiebreaker.
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 0,
+        block_root: get_root(4),
+        attestation_slot: Slot::new(3),
+    });
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 1,
+        block_root: get_root(4),
+        attestation_slot: Slot::new(3),
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(4),
+        current_slot: Slot::new(0),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+pub fn get_gloas_parent_empty_when_child_points_to_grandparent_test_definition()
+-> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Build a three-block chain A -> B -> C (CL parent links).
+    // A: EL parent = genesis hash(0), EL hash = hash(1).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+
+    // B: EL parent = hash(1), EL hash = hash(2).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(2),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(2)),
+    });
+
+    // C: CL parent is B, but EL parent points to A (hash 1), not B (hash 2).
+    // This models B's payload not arriving in time, so C records parent status as Empty.
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(3),
+        root: get_root(3),
+        parent_root: get_root(2),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(3)),
+    });
+
+    ops.push(Operation::AssertParentPayloadStatus {
+        block_root: get_root(3),
+        expected_status: PayloadStatus::Empty,
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+/// Test interleaving of blocks, regular attestations, and tiebreaker.
+///
+/// genesis → block 1 (Full) → block 3
+///         → block 2 (Empty) → block 4
+///
+/// With equal CL weight, tiebreaker determines which branch wins.
+/// An extra CL attestation can override the tiebreaker.
+pub fn get_gloas_interleaved_attestations_test_definition() -> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Step 1: Two competing blocks at slot 1.
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(2),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(99)),
+        execution_payload_block_hash: Some(get_hash(2)),
+    });
+
+    // Step 2: Regular attestations arrive, one per branch (equal CL weight).
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 0,
+        block_root: get_root(1),
+        attestation_slot: Slot::new(1),
+    });
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 1,
+        block_root: get_root(2),
+        attestation_slot: Slot::new(1),
+    });
+
+    // Step 3: Child blocks at slot 2.
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(3),
+        parent_root: get_root(1),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(1)),
+        execution_payload_block_hash: Some(get_hash(3)),
+    });
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(2),
+        root: get_root(4),
+        parent_root: get_root(2),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(100)),
+        execution_payload_block_hash: Some(get_hash(4)),
+    });
+
+    // Mark root_1 as having received its execution payload so that
+    // its FULL virtual node exists in the GLOAS fork choice tree.
+    ops.push(Operation::ProcessExecutionPayload {
+        block_root: get_root(1),
+    });
+
+    // Step 4: Set tiebreaker to Empty on genesis → Empty branch wins.
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: false,
+        is_data_available: false,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(4),
+        current_slot: Slot::new(1),
+    });
+
+    // Step 5: Flip tiebreaker to Full → Full branch wins.
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: true,
+        is_data_available: true,
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(3),
+        current_slot: Slot::new(100),
+    });
+
+    // Step 6: Add extra CL weight to Empty branch → overrides Full tiebreaker.
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 2,
+        block_root: get_root(4),
+        attestation_slot: Slot::new(3),
+    });
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1, 1],
+        expected_head: get_root(4),
+        current_slot: Slot::new(100),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+/// Test interleaving of blocks, payload validation, and attestations.
+///
+/// Scenario:
+///   - Genesis block (slot 0)
+///   - Block 1 (slot 1) extends genesis, Full chain
+///   - Block 2 (slot 1) extends genesis, Empty chain
+///   - Before payload arrives: payload_received is false for block 1
+///   - Process execution payload for block 1 → payload_received becomes true
+///   - Payload attestations arrive voting block 1's payload as timely + available
+///   - Head should follow block 1 because the PTC votes now count (payload_received = true)
+pub fn get_gloas_payload_received_interleaving_test_definition() -> ForkChoiceTestDefinition {
+    let mut ops = vec![];
+
+    // Block 1 at slot 1: extends genesis Full chain.
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(1),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(0)),
+        execution_payload_block_hash: Some(get_hash(1)),
+    });
+
+    // Block 2 at slot 1: extends genesis Empty chain (parent_hash doesn't match genesis EL hash).
+    ops.push(Operation::ProcessBlock {
+        slot: Slot::new(1),
+        root: get_root(2),
+        parent_root: get_root(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        execution_payload_parent_hash: Some(get_hash(99)),
+        execution_payload_block_hash: Some(get_hash(100)),
+    });
+
+    // Both children have parent_payload_status set correctly.
+    ops.push(Operation::AssertParentPayloadStatus {
+        block_root: get_root(1),
+        expected_status: PayloadStatus::Full,
+    });
+    ops.push(Operation::AssertParentPayloadStatus {
+        block_root: get_root(2),
+        expected_status: PayloadStatus::Empty,
+    });
+
+    // Per spec `get_forkchoice_store`: genesis starts with payload_received=true
+    // (anchor block is in `payload_states`).
+    ops.push(Operation::AssertPayloadReceived {
+        block_root: get_root(0),
+        expected: true,
+    });
+
+    // Give one vote to each child so they have equal weight.
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 0,
+        block_root: get_root(1),
+        attestation_slot: Slot::new(1),
+    });
+    ops.push(Operation::ProcessAttestation {
+        validator_index: 1,
+        block_root: get_root(2),
+        attestation_slot: Slot::new(1),
+    });
+
+    // Equal weight, payload_received=true on genesis → tiebreaker uses
+    // payload_received (not previous slot, equal payload weights) → prefers Full.
+    // Block 1 (Full) wins because it matches the Full preference.
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(1),
+        current_slot: Slot::new(100),
+    });
+
+    // ProcessExecutionPayload on genesis is a no-op (already received at init).
+    ops.push(Operation::ProcessExecutionPayload {
+        block_root: get_root(0),
+    });
+
+    ops.push(Operation::AssertPayloadReceived {
+        block_root: get_root(0),
+        expected: true,
+    });
+
+    // Set PTC votes on genesis as timely + data available (simulates PTC voting).
+    // This doesn't change the preference since genesis is not the previous slot
+    // (slot 0 + 1 != current_slot 100).
+    ops.push(Operation::SetPayloadTiebreak {
+        block_root: get_root(0),
+        is_timely: true,
+        is_data_available: true,
+    });
+
+    // Still prefers Full via payload_received tiebreaker → Block 1 (Full) wins.
+    ops.push(Operation::FindHead {
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        justified_state_balances: vec![1, 1],
+        expected_head: get_root(1),
+        current_slot: Slot::new(100),
+    });
+
+    ForkChoiceTestDefinition {
+        finalized_block_slot: Slot::new(0),
+        justified_checkpoint: get_checkpoint(0),
+        finalized_checkpoint: get_checkpoint(0),
+        operations: ops,
+        execution_payload_parent_hash: Some(get_hash(42)),
+        execution_payload_block_hash: Some(get_hash(0)),
+        spec: Some(gloas_spec()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn chain_following() {
+        let test = get_gloas_chain_following_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn payload_probe() {
+        let test = get_gloas_payload_probe_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn find_head_vote_transition() {
+        let test = get_gloas_find_head_vote_transition_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn weight_priority_over_payload_preference() {
+        let test = get_gloas_weight_priority_over_payload_preference_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn parent_empty_when_child_points_to_grandparent() {
+        let test = get_gloas_parent_empty_when_child_points_to_grandparent_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn interleaved_attestations() {
+        let test = get_gloas_interleaved_attestations_test_definition();
+        test.run();
+    }
+
+    #[test]
+    fn payload_received_interleaving() {
+        let test = get_gloas_payload_received_interleaving_test_definition();
+        test.run();
+    }
+}
diff --git a/consensus/proto_array/src/fork_choice_test_definition/no_votes.rs b/consensus/proto_array/src/fork_choice_test_definition/no_votes.rs
index d20eaacb99a..71d4c035aef 100644
--- a/consensus/proto_array/src/fork_choice_test_definition/no_votes.rs
+++ b/consensus/proto_array/src/fork_choice_test_definition/no_votes.rs
@@ -18,6 +18,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: Hash256::zero(),
+            current_slot: Slot::new(0),
         },
         // Add block 2
         //
@@ -36,6 +37,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure the head is 2
         //
@@ -53,6 +56,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(2),
+            current_slot: Slot::new(0),
         },
         // Add block 1
         //
@@ -71,6 +75,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure the head is still 2
         //
@@ -88,6 +94,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(2),
+            current_slot: Slot::new(0),
         },
         // Add block 3
         //
@@ -108,6 +115,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure 2 is still the head
         //
@@ -127,6 +136,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(2),
+            current_slot: Slot::new(0),
         },
         // Add block 4
         //
@@ -147,6 +157,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure the head is 4.
         //
@@ -166,6 +178,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(4),
+            current_slot: Slot::new(0),
         },
         // Add block 5 with a justified epoch of 2
         //
@@ -185,6 +198,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure the head is now 5 whilst the justified epoch is 0.
         //
@@ -206,6 +221,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(5),
+            current_slot: Slot::new(0),
         },
         // Ensure there is no error when starting from a block that has the
         // wrong justified epoch.
@@ -232,6 +248,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(5),
+            current_slot: Slot::new(0),
         },
         // Set the justified epoch to 2 and the start block to 5 and ensure 5 is the head.
         //
@@ -250,6 +267,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances.clone(),
             expected_head: get_root(5),
+            current_slot: Slot::new(0),
         },
         // Add block 6
         //
@@ -271,6 +289,8 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
                 epoch: Epoch::new(1),
                 root: Hash256::zero(),
             },
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: None,
         },
         // Ensure 6 is the head
         //
@@ -291,6 +311,7 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             },
             justified_state_balances: balances,
             expected_head: get_root(6),
+            current_slot: Slot::new(0),
         },
     ];
 
@@ -305,6 +326,9 @@ pub fn get_no_votes_test_definition() -> ForkChoiceTestDefinition {
             root: Hash256::zero(),
         },
         operations,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
diff --git a/consensus/proto_array/src/fork_choice_test_definition/votes.rs b/consensus/proto_array/src/fork_choice_test_definition/votes.rs
index 01994fff9b2..3ba21db48a4 100644
--- a/consensus/proto_array/src/fork_choice_test_definition/votes.rs
+++ b/consensus/proto_array/src/fork_choice_test_definition/votes.rs
@@ -16,6 +16,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(0),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 2.
@@ -35,6 +36,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is 2
@@ -53,6 +56,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a block with a hash of 1 that comes off the genesis block (this is a fork compared
@@ -73,6 +77,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -91,6 +97,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to block 1
@@ -101,7 +108,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(1),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is now 1, because 1 has a vote.
@@ -120,6 +127,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(1),
+        current_slot: Slot::new(0),
     });
 
     // Add a vote to block 2
@@ -130,7 +138,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(2),
-        target_epoch: Epoch::new(2),
+        attestation_slot: Slot::new(2),
     });
 
     // Ensure that the head is 2 since 1 and 2 both have a vote
@@ -149,6 +157,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Add block 3.
@@ -170,6 +179,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is still 2
@@ -190,6 +201,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Move validator #0 vote from 1 to 3
@@ -202,7 +214,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(3),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Ensure that the head is still 2
@@ -223,6 +235,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(2),
+        current_slot: Slot::new(0),
     });
 
     // Move validator #1 vote from 2 to 1 (this is an equivocation, but fork choice doesn't
@@ -236,7 +249,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(1),
-        target_epoch: Epoch::new(3),
+        attestation_slot: Slot::new(3),
     });
 
     // Ensure that the head is now 3
@@ -257,6 +270,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(3),
+        current_slot: Slot::new(0),
     });
 
     // Add block 4.
@@ -280,6 +294,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that the head is now 4
@@ -302,6 +318,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(4),
+        current_slot: Slot::new(0),
     });
 
     // Add block 5, which has a justified epoch of 2.
@@ -327,6 +344,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(1),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that 5 is filtered out and the head stays at 4.
@@ -351,6 +370,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(4),
+        current_slot: Slot::new(0),
     });
 
     // Add block 6, which has a justified epoch of 0.
@@ -376,6 +396,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(1),
             root: get_root(0),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Move both votes to 5.
@@ -392,12 +414,12 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(5),
-        target_epoch: Epoch::new(4),
+        attestation_slot: Slot::new(4),
     });
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(5),
-        target_epoch: Epoch::new(4),
+        attestation_slot: Slot::new(4),
     });
 
     // Add blocks 7, 8 and 9. Adding these blocks helps test the `best_descendant`
@@ -430,6 +452,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(5),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(0),
@@ -443,6 +467,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(5),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
     ops.push(Operation::ProcessBlock {
         slot: Slot::new(0),
@@ -456,6 +482,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(5),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure that 6 is the head, even though 5 has all the votes. This is testing to ensure
@@ -487,6 +515,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(6),
+        current_slot: Slot::new(0),
     });
 
     // Change fork-choice justified epoch to 1, and the start block to 5 and ensure that 9 is
@@ -520,6 +549,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Change fork-choice justified epoch to 1, and the start block to 5 and ensure that 9 is
@@ -545,12 +575,12 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 0,
         block_root: get_root(9),
-        target_epoch: Epoch::new(5),
+        attestation_slot: Slot::new(5),
     });
     ops.push(Operation::ProcessAttestation {
         validator_index: 1,
         block_root: get_root(9),
-        target_epoch: Epoch::new(5),
+        attestation_slot: Slot::new(5),
     });
 
     // Add block 10
@@ -582,6 +612,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(5),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Double-check the head is still 9 (no diagram this time)
@@ -596,6 +628,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Introduce 2 more validators into the system
@@ -621,12 +654,12 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
     ops.push(Operation::ProcessAttestation {
         validator_index: 2,
         block_root: get_root(10),
-        target_epoch: Epoch::new(5),
+        attestation_slot: Slot::new(5),
     });
     ops.push(Operation::ProcessAttestation {
         validator_index: 3,
         block_root: get_root(10),
-        target_epoch: Epoch::new(5),
+        attestation_slot: Slot::new(5),
     });
 
     // Check the head is now 10.
@@ -657,6 +690,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
 
     // Set the balances of the last two validators to zero
@@ -682,6 +716,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Set the balances of the last two validators back to 1
@@ -707,6 +742,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(10),
+        current_slot: Slot::new(0),
     });
 
     // Remove the last two validators
@@ -733,6 +769,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that pruning below the prune threshold does not prune.
@@ -754,6 +791,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Ensure that pruning above the prune threshold does prune.
@@ -792,6 +830,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances.clone(),
         expected_head: get_root(9),
+        current_slot: Slot::new(0),
     });
 
     // Add block 11
@@ -817,6 +856,8 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             epoch: Epoch::new(2),
             root: get_root(5),
         },
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
     });
 
     // Ensure the head is now 11
@@ -841,6 +882,7 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
         },
         justified_state_balances: balances,
         expected_head: get_root(11),
+        current_slot: Slot::new(0),
     });
 
     ForkChoiceTestDefinition {
@@ -854,6 +896,9 @@ pub fn get_votes_test_definition() -> ForkChoiceTestDefinition {
             root: get_root(0),
         },
         operations: ops,
+        execution_payload_parent_hash: None,
+        execution_payload_block_hash: None,
+        spec: None,
     }
 }
 
diff --git a/consensus/proto_array/src/lib.rs b/consensus/proto_array/src/lib.rs
index 964e836d91d..42c65e6ffe6 100644
--- a/consensus/proto_array/src/lib.rs
+++ b/consensus/proto_array/src/lib.rs
@@ -8,13 +8,15 @@ mod ssz_container;
 pub use crate::justified_balances::JustifiedBalances;
 pub use crate::proto_array::{InvalidationOperation, calculate_committee_fraction};
 pub use crate::proto_array_fork_choice::{
-    Block, DisallowedReOrgOffsets, DoNotReOrg, ExecutionStatus, ProposerHeadError,
-    ProposerHeadInfo, ProtoArrayForkChoice, ReOrgThreshold,
+    Block, DisallowedReOrgOffsets, DoNotReOrg, ExecutionStatus, LatestMessage, PayloadStatus,
+    ProposerHeadError, ProposerHeadInfo, ProtoArrayForkChoice, ReOrgThreshold,
 };
 pub use error::Error;
 
 pub mod core {
     pub use super::proto_array::{ProposerBoost, ProtoArray, ProtoNode};
     pub use super::proto_array_fork_choice::VoteTracker;
-    pub use super::ssz_container::{SszContainer, SszContainerV17, SszContainerV28};
+    pub use super::ssz_container::{
+        SszContainer, SszContainerV17, SszContainerV28, SszContainerV29,
+    };
 }
diff --git a/consensus/proto_array/src/proto_array.rs b/consensus/proto_array/src/proto_array.rs
index 5bfcdae463d..ac5f5be525d 100644
--- a/consensus/proto_array/src/proto_array.rs
+++ b/consensus/proto_array/src/proto_array.rs
@@ -1,12 +1,14 @@
 use crate::error::InvalidBestNodeInfo;
-use crate::{Block, ExecutionStatus, JustifiedBalances, error::Error};
+use crate::{Block, ExecutionStatus, JustifiedBalances, PayloadStatus, error::Error};
 use fixed_bytes::FixedBytesExtended;
 use serde::{Deserialize, Serialize};
+use ssz::BitVector;
 use ssz::Encode;
 use ssz::four_byte_option_impl;
 use ssz_derive::{Decode, Encode};
 use std::collections::{HashMap, HashSet};
 use superstruct::superstruct;
+use typenum::U512;
 use types::{
     AttestationShufflingId, ChainSpec, Checkpoint, Epoch, EthSpec, ExecutionBlockHash, Hash256,
     Slot,
@@ -68,47 +70,87 @@ impl InvalidationOperation {
     }
 }
 
-pub type ProtoNode = ProtoNodeV17;
-
 #[superstruct(
-    variants(V17),
-    variant_attributes(derive(Clone, PartialEq, Debug, Encode, Decode, Serialize, Deserialize)),
-    no_enum
+    variants(V17, V29),
+    variant_attributes(derive(Clone, PartialEq, Debug, Encode, Decode, Serialize, Deserialize))
 )]
+#[derive(PartialEq, Debug, Encode, Decode, Serialize, Deserialize, Clone)]
+#[ssz(enum_behaviour = "union")]
 pub struct ProtoNode {
     /// The `slot` is not necessary for `ProtoArray`, it just exists so external components can
     /// easily query the block slot. This is useful for upstream fork choice logic.
+    #[superstruct(getter(copy))]
     pub slot: Slot,
     /// The `state_root` is not necessary for `ProtoArray` either, it also just exists for upstream
     /// components (namely attestation verification).
+    #[superstruct(getter(copy))]
     pub state_root: Hash256,
     /// The root that would be used for the `attestation.data.target.root` if a LMD vote was cast
     /// for this block.
     ///
     /// The `target_root` is not necessary for `ProtoArray` either, it also just exists for upstream
     /// components (namely fork choice attestation verification).
+    #[superstruct(getter(copy))]
     pub target_root: Hash256,
     pub current_epoch_shuffling_id: AttestationShufflingId,
     pub next_epoch_shuffling_id: AttestationShufflingId,
+    #[superstruct(getter(copy))]
     pub root: Hash256,
+    #[superstruct(getter(copy))]
     #[ssz(with = "four_byte_option_usize")]
     pub parent: Option<usize>,
-    #[superstruct(only(V17))]
+    #[superstruct(only(V17, V29), partial_getter(copy))]
     pub justified_checkpoint: Checkpoint,
-    #[superstruct(only(V17))]
+    #[superstruct(only(V17, V29), partial_getter(copy))]
     pub finalized_checkpoint: Checkpoint,
+    #[superstruct(getter(copy))]
     pub weight: u64,
+    #[superstruct(getter(copy))]
     #[ssz(with = "four_byte_option_usize")]
     pub best_child: Option<usize>,
+    #[superstruct(getter(copy))]
     #[ssz(with = "four_byte_option_usize")]
     pub best_descendant: Option<usize>,
     /// Indicates if an execution node has marked this block as valid. Also contains the execution
-    /// block hash.
+    /// block hash. This is only used pre-Gloas.
+    #[superstruct(only(V17), partial_getter(copy))]
     pub execution_status: ExecutionStatus,
+    #[superstruct(getter(copy))]
     #[ssz(with = "four_byte_option_checkpoint")]
     pub unrealized_justified_checkpoint: Option<Checkpoint>,
+    #[superstruct(getter(copy))]
     #[ssz(with = "four_byte_option_checkpoint")]
     pub unrealized_finalized_checkpoint: Option<Checkpoint>,
+
+    /// We track the parent payload status from which the current node was extended.
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub parent_payload_status: PayloadStatus,
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub empty_payload_weight: u64,
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub full_payload_weight: u64,
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub execution_payload_block_hash: ExecutionBlockHash,
+    /// PTC timeliness vote bitfield, indexed by PTC committee position.
+    /// Bit i set means PTC member i voted `payload_present = true`.
+    /// Tiebreak derived as: `num_set_bits() > ptc_size / 2`.
+    #[superstruct(only(V29))]
+    pub payload_timeliness_votes: BitVector<U512>,
+    /// PTC data availability vote bitfield, indexed by PTC committee position.
+    /// Bit i set means PTC member i voted `blob_data_available = true`.
+    /// Tiebreak derived as: `num_set_bits() > ptc_size / 2`.
+    #[superstruct(only(V29))]
+    pub payload_data_availability_votes: BitVector<U512>,
+    /// Whether the execution payload for this block has been received and validated locally.
+    /// Maps to `root in store.payload_states` in the spec.
+    /// When true, `is_payload_timely` and `is_payload_data_available` return true
+    /// regardless of PTC vote counts.
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub payload_received: bool,
+    /// The proposer index for this block, used by `should_apply_proposer_boost`
+    /// to detect equivocations at the parent's slot.
+    #[superstruct(only(V29), partial_getter(copy))]
+    pub proposer_index: u64,
 }
 
 #[derive(PartialEq, Debug, Encode, Decode, Serialize, Deserialize, Copy, Clone)]
@@ -126,6 +168,119 @@ impl Default for ProposerBoost {
     }
 }
 
+/// Accumulated score changes for a single proto-array node during a `find_head` pass.
+///
+/// `delta` tracks the ordinary LMD-GHOST balance change applied to the concrete block node.
+/// This is the same notion of weight that pre-gloas fork choice used.
+///
+///
+/// Under gloas we also need to track how votes contribute to the parent's virtual payload
+/// branches:
+///
+/// - `empty_delta` is the balance change attributable to votes that support the `Empty` payload
+///   interpretation of the node
+/// - `full_delta` is the balance change attributable to votes that support the `Full` payload
+///   interpretation of the node
+///
+/// Votes in `Pending` state only affect `delta`; they do not contribute to either payload bucket.
+/// During score application these payload deltas are propagated independently up the tree so that
+/// ancestors can compare children using payload-aware tie breaking.
+#[derive(Clone, PartialEq, Debug, Copy)]
+pub struct NodeDelta {
+    /// Total weight change for the node. All votes contribute regardless of payload status.
+    pub delta: i64,
+    /// Weight change from `PayloadStatus::Empty` votes.
+    pub empty_delta: i64,
+    /// Weight change from `PayloadStatus::Full` votes.
+    pub full_delta: i64,
+}
+
+impl NodeDelta {
+    /// Classify a vote into the payload bucket it contributes to for `block_slot`.
+    ///
+    /// Per the gloas model:
+    ///
+    /// - a same-slot vote is `Pending`
+    /// - a later vote with `payload_present = true` is `Full`
+    /// - a later vote with `payload_present = false` is `Empty`
+    ///
+    /// This classification is used only for payload-aware accounting; all votes still contribute to
+    /// the aggregate `delta`.
+    pub fn payload_status(
+        vote_slot: Slot,
+        payload_present: bool,
+        block_slot: Slot,
+    ) -> PayloadStatus {
+        if vote_slot == block_slot {
+            PayloadStatus::Pending
+        } else if payload_present {
+            PayloadStatus::Full
+        } else {
+            PayloadStatus::Empty
+        }
+    }
+
+    /// Add `balance` to the payload bucket selected by `status`.
+    ///
+    /// `Pending` votes do not affect payload buckets, so this becomes a no-op for that case.
+    pub fn add_payload_delta(
+        &mut self,
+        status: PayloadStatus,
+        balance: u64,
+        index: usize,
+    ) -> Result<(), Error> {
+        let field = match status {
+            PayloadStatus::Full => &mut self.full_delta,
+            PayloadStatus::Empty => &mut self.empty_delta,
+            PayloadStatus::Pending => return Ok(()),
+        };
+        *field = field
+            .checked_add(balance as i64)
+            .ok_or(Error::DeltaOverflow(index))?;
+        Ok(())
+    }
+
+    /// Create a delta that only affects the aggregate block weight.
+    ///
+    /// This is useful for callers or tests that only care about ordinary LMD-GHOST weight changes
+    /// and do not need payload-aware accounting.
+    pub fn from_delta(delta: i64) -> Self {
+        Self {
+            delta,
+            empty_delta: 0,
+            full_delta: 0,
+        }
+    }
+
+    /// Subtract `balance` from the payload bucket selected by `status`.
+    ///
+    /// `Pending` votes do not affect payload buckets, so this becomes a no-op for that case.
+    pub fn sub_payload_delta(
+        &mut self,
+        status: PayloadStatus,
+        balance: u64,
+        index: usize,
+    ) -> Result<(), Error> {
+        let field = match status {
+            PayloadStatus::Full => &mut self.full_delta,
+            PayloadStatus::Empty => &mut self.empty_delta,
+            PayloadStatus::Pending => return Ok(()),
+        };
+        *field = field
+            .checked_sub(balance as i64)
+            .ok_or(Error::DeltaOverflow(index))?;
+        Ok(())
+    }
+}
+
+/// Compare NodeDelta with i64 by comparing the aggregate `delta` field.
+/// This is used by tests that only care about the total weight delta.
+impl PartialEq<i64> for NodeDelta {
+    fn eq(&self, other: &i64) -> bool {
+        self.delta == *other
+    }
+}
+
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
 pub struct ProtoArray {
     /// Do not attempt to prune the tree unless it has at least this many nodes. Small prunes
@@ -153,7 +308,7 @@ impl ProtoArray {
     #[allow(clippy::too_many_arguments)]
     pub fn apply_score_changes<E: EthSpec>(
         &mut self,
-        mut deltas: Vec<i64>,
+        mut deltas: Vec<NodeDelta>,
         best_justified_checkpoint: Checkpoint,
         best_finalized_checkpoint: Checkpoint,
         new_justified_balances: &JustifiedBalances,
@@ -181,50 +336,66 @@ impl ProtoArray {
             // There is no need to adjust the balances or manage parent of the zero hash since it
             // is an alias to the genesis block. The weight applied to the genesis block is
             // irrelevant as we _always_ choose it and it's impossible for it to have a parent.
-            if node.root == Hash256::zero() {
+            if node.root() == Hash256::zero() {
                 continue;
             }
 
-            let execution_status_is_invalid = node.execution_status.is_invalid();
+            let execution_status_is_invalid = if let Ok(proto_node) = node.as_v17()
+                && proto_node.execution_status.is_invalid()
+            {
+                true
+            } else {
+                false
+            };
 
-            let mut node_delta = if execution_status_is_invalid {
+            let node_delta = deltas
+                .get(node_index)
+                .copied()
+                .ok_or(Error::InvalidNodeDelta(node_index))?;
+
+            let mut delta = if execution_status_is_invalid {
                 // If the node has an invalid execution payload, reduce its weight to zero.
                 0_i64
-                    .checked_sub(node.weight as i64)
+                    .checked_sub(node.weight() as i64)
                     .ok_or(Error::InvalidExecutionDeltaOverflow(node_index))?
             } else {
-                deltas
-                    .get(node_index)
-                    .copied()
-                    .ok_or(Error::InvalidNodeDelta(node_index))?
+                node_delta.delta
+            };
+
+            let (node_empty_delta, node_full_delta) = if node.as_v29().is_ok() {
+                (node_delta.empty_delta, node_delta.full_delta)
+            } else {
+                (0, 0)
             };
 
             // If we find the node for which the proposer boost was previously applied, decrease
             // the delta by the previous score amount.
+            // TODO(gloas): implement `should_apply_proposer_boost` from the Gloas spec.
+            // The spec conditionally applies proposer boost based on parent weakness and
+            // early equivocations. Currently boost is applied unconditionally.
             if self.previous_proposer_boost.root != Hash256::zero()
-                && self.previous_proposer_boost.root == node.root
+                && self.previous_proposer_boost.root == node.root()
                 // Invalid nodes will always have a weight of zero so there's no need to subtract
                 // the proposer boost delta.
                 && !execution_status_is_invalid
             {
-                node_delta = node_delta
+                delta = delta
                     .checked_sub(self.previous_proposer_boost.score as i64)
                     .ok_or(Error::DeltaOverflow(node_index))?;
             }
             // If we find the node matching the current proposer boost root, increase
             // the delta by the new score amount (unless the block has an invalid execution status).
-            //
-            // https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#get_latest_attesting_balance
+            // For Gloas (V29), `should_apply_proposer_boost` is checked after the loop
+            // with final weights, and the boost is removed if needed.
             if let Some(proposer_score_boost) = spec.proposer_score_boost
                 && proposer_boost_root != Hash256::zero()
-                    && proposer_boost_root == node.root
-                    // Invalid nodes (or their ancestors) should not receive a proposer boost.
-                    && !execution_status_is_invalid
+                && proposer_boost_root == node.root()
+                && !execution_status_is_invalid
             {
                 proposer_score =
                     calculate_committee_fraction::<E>(new_justified_balances, proposer_score_boost)
                         .ok_or(Error::ProposerBoostOverflow(node_index))?;
-                node_delta = node_delta
+                delta = delta
                     .checked_add(proposer_score as i64)
                     .ok_or(Error::DeltaOverflow(node_index))?;
             }
@@ -232,39 +403,114 @@ impl ProtoArray {
             // Apply the delta to the node.
             if execution_status_is_invalid {
                 // Invalid nodes always have a weight of 0.
-                node.weight = 0
-            } else if node_delta < 0 {
-                // Note: I am conflicted about whether to use `saturating_sub` or `checked_sub`
-                // here.
-                //
-                // I can't think of any valid reason why `node_delta.abs()` should be greater than
-                // `node.weight`, so I have chosen `checked_sub` to try and fail-fast if there is
-                // some error.
-                //
-                // However, I am not fully convinced that some valid case for `saturating_sub` does
-                // not exist.
-                node.weight = node
-                    .weight
-                    .checked_sub(node_delta.unsigned_abs())
-                    .ok_or(Error::DeltaOverflow(node_index))?;
+                *node.weight_mut() = 0;
             } else {
-                node.weight = node
-                    .weight
-                    .checked_add(node_delta as u64)
-                    .ok_or(Error::DeltaOverflow(node_index))?;
+                *node.weight_mut() = apply_delta(node.weight(), delta, node_index)?;
+            }
+
+            // Apply post-Gloas score deltas.
+            if let Ok(node) = node.as_v29_mut() {
+                node.empty_payload_weight =
+                    apply_delta(node.empty_payload_weight, node_empty_delta, node_index)?;
+                node.full_payload_weight =
+                    apply_delta(node.full_payload_weight, node_full_delta, node_index)?;
             }
 
             // Update the parent delta (if any).
-            if let Some(parent_index) = node.parent {
+            if let Some(parent_index) = node.parent() {
                 let parent_delta = deltas
                     .get_mut(parent_index)
                     .ok_or(Error::InvalidParentDelta(parent_index))?;
 
-                // Back-propagate the nodes delta to its parent.
-                *parent_delta += node_delta;
+                // Back-propagate the node's delta to its parent.
+                parent_delta.delta = parent_delta
+                    .delta
+                    .checked_add(delta)
+                    .ok_or(Error::DeltaOverflow(parent_index))?;
+
+                // Route ALL child weight into the parent's FULL or EMPTY bucket
+                // based on the child's `parent_payload_status` (the ancestor path
+                // direction). If this child is on the FULL path from the parent,
+                // all weight supports the parent's FULL virtual node, and vice versa.
+                if let Ok(child_v29) = node.as_v29() {
+                    if child_v29.parent_payload_status == PayloadStatus::Full {
+                        parent_delta.full_delta = parent_delta
+                            .full_delta
+                            .checked_add(delta)
+                            .ok_or(Error::DeltaOverflow(parent_index))?;
+                    } else {
+                        parent_delta.empty_delta = parent_delta
+                            .empty_delta
+                            .checked_add(delta)
+                            .ok_or(Error::DeltaOverflow(parent_index))?;
+                    }
+                } else {
+                    // V17 child of a V29 parent (fork transition): treat as FULL
+                    // since V17 nodes always have execution payloads inline.
+                    parent_delta.full_delta = parent_delta
+                        .full_delta
+                        .checked_add(delta)
+                        .ok_or(Error::DeltaOverflow(parent_index))?;
+                }
             }
         }
 
+        // Gloas: now that all weights are final, check `should_apply_proposer_boost`.
+        // If the boost should NOT apply, walk from the boosted node to root and subtract
+        // `proposer_score` from weight and payload weights in a single pass.
+        // We detect Gloas by checking the boosted node's variant (V29) directly.
+        if proposer_score > 0
+            && let Some(&boost_index) = self.indices.get(&proposer_boost_root)
+            && self
+                .nodes
+                .get(boost_index)
+                .is_some_and(|n| n.as_v29().is_ok())
+            && !self.should_apply_proposer_boost::<E>(
+                boost_index,
+                proposer_score,
+                new_justified_balances,
+                spec,
+            )?
+        {
+            // Single walk: subtract proposer_score from weight and payload weights.
+            let mut walk_index = Some(boost_index);
+            let mut child_payload_status: Option<PayloadStatus> = None;
+            while let Some(idx) = walk_index {
+                let node = self
+                    .nodes
+                    .get_mut(idx)
+                    .ok_or(Error::InvalidNodeIndex(idx))?;
+
+                *node.weight_mut() = node
+                    .weight()
+                    .checked_sub(proposer_score)
+                    .ok_or(Error::DeltaOverflow(idx))?;
+
+                // Subtract from the payload bucket that the child-on-path
+                // contributed to (based on the child's parent_payload_status).
+                if let Some(child_ps) = child_payload_status
+                    && let Ok(v29) = node.as_v29_mut()
+                {
+                    if child_ps == PayloadStatus::Full {
+                        v29.full_payload_weight = v29
+                            .full_payload_weight
+                            .checked_sub(proposer_score)
+                            .ok_or(Error::DeltaOverflow(idx))?;
+                    } else {
+                        v29.empty_payload_weight = v29
+                            .empty_payload_weight
+                            .checked_sub(proposer_score)
+                            .ok_or(Error::DeltaOverflow(idx))?;
+                    }
+                }
+
+                child_payload_status = node.parent_payload_status().ok();
+                walk_index = node.parent();
+            }
+
+            proposer_score = 0;
+        }
+
         // After applying all deltas, update the `previous_proposer_boost`.
         self.previous_proposer_boost = ProposerBoost {
             root: proposer_boost_root,
@@ -283,7 +529,7 @@ impl ProtoArray {
                 .ok_or(Error::InvalidNodeIndex(node_index))?;
 
             // If the node has a parent, try to update its best-child and best-descendant.
-            if let Some(parent_index) = node.parent {
+            if let Some(parent_index) = node.parent() {
                 self.maybe_update_best_child_and_descendant::<E>(
                     parent_index,
                     node_index,
@@ -306,6 +552,7 @@ impl ProtoArray {
         current_slot: Slot,
         best_justified_checkpoint: Checkpoint,
         best_finalized_checkpoint: Checkpoint,
+        spec: &ChainSpec,
     ) -> Result<(), Error> {
         // If the block is already known, simply ignore it.
         if self.indices.contains_key(&block.root) {
@@ -314,45 +561,144 @@ impl ProtoArray {
 
         let node_index = self.nodes.len();
 
-        let node = ProtoNode {
-            slot: block.slot,
-            root: block.root,
-            target_root: block.target_root,
-            current_epoch_shuffling_id: block.current_epoch_shuffling_id,
-            next_epoch_shuffling_id: block.next_epoch_shuffling_id,
-            state_root: block.state_root,
-            parent: block
-                .parent_root
-                .and_then(|parent| self.indices.get(&parent).copied()),
-            justified_checkpoint: block.justified_checkpoint,
-            finalized_checkpoint: block.finalized_checkpoint,
-            weight: 0,
-            best_child: None,
-            best_descendant: None,
-            execution_status: block.execution_status,
-            unrealized_justified_checkpoint: block.unrealized_justified_checkpoint,
-            unrealized_finalized_checkpoint: block.unrealized_finalized_checkpoint,
+        let parent_index = block
+            .parent_root
+            .and_then(|parent| self.indices.get(&parent).copied());
+
+        let node = if !spec.fork_name_at_slot::<E>(current_slot).gloas_enabled() {
+            ProtoNode::V17(ProtoNodeV17 {
+                slot: block.slot,
+                root: block.root,
+                target_root: block.target_root,
+                current_epoch_shuffling_id: block.current_epoch_shuffling_id,
+                next_epoch_shuffling_id: block.next_epoch_shuffling_id,
+                state_root: block.state_root,
+                parent: parent_index,
+                justified_checkpoint: block.justified_checkpoint,
+                finalized_checkpoint: block.finalized_checkpoint,
+                weight: 0,
+                best_child: None,
+                best_descendant: None,
+                execution_status: block.execution_status,
+                unrealized_justified_checkpoint: block.unrealized_justified_checkpoint,
+                unrealized_finalized_checkpoint: block.unrealized_finalized_checkpoint,
+            })
+        } else {
+            let execution_payload_block_hash =
+                block
+                    .execution_payload_block_hash
+                    .ok_or(Error::BrokenBlock {
+                        block_root: block.root,
+                    })?;
+
+            let execution_payload_parent_hash =
+                block
+                    .execution_payload_parent_hash
+                    .ok_or(Error::BrokenBlock {
+                        block_root: block.root,
+                    })?;
+
+            let parent_payload_status: PayloadStatus = if let Some(parent_node) =
+                parent_index.and_then(|idx| self.nodes.get(idx))
+            {
+                // Get the parent's execution block hash, handling both V17 and V29 nodes.
+                // V17 parents occur during the Gloas fork transition.
+                // TODO(gloas): the spec's `get_parent_payload_status` assumes all blocks are
+                // post-Gloas with bids. Revisit once the spec clarifies fork-transition behavior.
+                let parent_el_block_hash = match parent_node {
+                    ProtoNode::V29(v29) => Some(v29.execution_payload_block_hash),
+                    ProtoNode::V17(v17) => v17.execution_status.block_hash(),
+                };
+                // Per spec's `is_parent_node_full`: if the child's EL parent hash
+                // matches the parent's EL block hash, the child extends the parent's
+                // payload chain, meaning the parent was Full.
+                if parent_el_block_hash.is_some_and(|hash| execution_payload_parent_hash == hash) {
+                    PayloadStatus::Full
+                } else {
+                    PayloadStatus::Empty
+                }
+            } else {
+                // Parent is missing (genesis or pruned due to finalization). Default to Full
+                // since this path should only be hit at Gloas genesis, and extending the payload
+                // chain is the safe default.
+                PayloadStatus::Full
+            };
+
+            // Per spec `get_forkchoice_store`: the anchor (genesis) block has
+            // its payload state initialized (`payload_states = {anchor_root: ...}`).
+            // Without `payload_received = true` on genesis, the FULL virtual
+            // child doesn't exist in the spec's `get_node_children`, making all
+            // Full concrete children of genesis unreachable in `get_head`.
+            let is_genesis = parent_index.is_none();
+
+            ProtoNode::V29(ProtoNodeV29 {
+                slot: block.slot,
+                root: block.root,
+                target_root: block.target_root,
+                current_epoch_shuffling_id: block.current_epoch_shuffling_id,
+                next_epoch_shuffling_id: block.next_epoch_shuffling_id,
+                state_root: block.state_root,
+                parent: parent_index,
+                justified_checkpoint: block.justified_checkpoint,
+                finalized_checkpoint: block.finalized_checkpoint,
+                weight: 0,
+                best_child: None,
+                best_descendant: None,
+                unrealized_justified_checkpoint: block.unrealized_justified_checkpoint,
+                unrealized_finalized_checkpoint: block.unrealized_finalized_checkpoint,
+                parent_payload_status,
+                empty_payload_weight: 0,
+                full_payload_weight: 0,
+                execution_payload_block_hash,
+                // Per spec `get_forkchoice_store`: the anchor block's PTC votes are
+                // initialized to all-True, ensuring `is_payload_timely` and
+                // `is_payload_data_available` return true for the anchor.
+                payload_timeliness_votes: if is_genesis {
+                    let mut bv = BitVector::new();
+                    for i in 0..bv.len() {
+                        let _ = bv.set(i, true);
+                    }
+                    bv
+                } else {
+                    BitVector::default()
+                },
+                payload_data_availability_votes: if is_genesis {
+                    let mut bv = BitVector::new();
+                    for i in 0..bv.len() {
+                        let _ = bv.set(i, true);
+                    }
+                    bv
+                } else {
+                    BitVector::default()
+                },
+                payload_received: is_genesis,
+                proposer_index: block.proposer_index.unwrap_or(0),
+            })
         };
 
-        // If the parent has an invalid execution status, return an error before adding the block to
-        // `self`.
-        if let Some(parent_index) = node.parent {
+        // If the parent has an invalid execution status, return an error before adding the
+        // block to `self`. This applies only when the parent is a V17 node with execution tracking.
+        if let Some(parent_index) = node.parent() {
             let parent = self
                 .nodes
                 .get(parent_index)
                 .ok_or(Error::InvalidNodeIndex(parent_index))?;
-            if parent.execution_status.is_invalid() {
+
+            // Execution status tracking only exists on V17 (pre-Gloas) nodes.
+            if let Ok(v17) = parent.as_v17()
+                && v17.execution_status.is_invalid()
+            {
                 return Err(Error::ParentExecutionStatusIsInvalid {
                     block_root: block.root,
-                    parent_root: parent.root,
+                    parent_root: parent.root(),
                 });
             }
         }
 
-        self.indices.insert(node.root, node_index);
+        self.indices.insert(node.root(), node_index);
         self.nodes.push(node.clone());
 
-        if let Some(parent_index) = node.parent {
+        if let Some(parent_index) = node.parent() {
             self.maybe_update_best_child_and_descendant::<E>(
                 parent_index,
                 node_index,
@@ -369,6 +715,88 @@ impl ProtoArray {
         Ok(())
     }
 
+    /// Spec's `should_apply_proposer_boost` for Gloas.
+    ///
+    /// Returns `true` if the proposer boost should be kept. Returns `false` if the
+    /// boost should be subtracted (invalidated) because the parent is weak and there
+    /// are no equivocating blocks at the parent's slot.
+    fn should_apply_proposer_boost<E: EthSpec>(
+        &self,
+        boost_index: usize,
+        proposer_score: u64,
+        justified_balances: &JustifiedBalances,
+        spec: &ChainSpec,
+    ) -> Result<bool, Error> {
+        let boost_node = self
+            .nodes
+            .get(boost_index)
+            .ok_or(Error::InvalidNodeIndex(boost_index))?;
+
+        let Some(parent_index) = boost_node.parent() else {
+            return Ok(true); // Genesis — always apply.
+        };
+
+        let parent = self
+            .nodes
+            .get(parent_index)
+            .ok_or(Error::InvalidNodeIndex(parent_index))?;
+
+        // Parent not from the immediately previous slot — always apply.
+        if parent.slot() + 1 < boost_node.slot() {
+            return Ok(true);
+        }
+
+        // Check if the parent is "weak" (low attestation weight).
+        // Parent weight currently includes the back-propagated boost, so subtract it.
+        let reorg_threshold = calculate_committee_fraction::<E>(
+            justified_balances,
+            spec.reorg_head_weight_threshold.unwrap_or(20),
+        )
+        .unwrap_or(0);
+
+        let parent_weight_without_boost = parent.weight().saturating_sub(proposer_score);
+        if parent_weight_without_boost >= reorg_threshold {
+            return Ok(true); // Parent is not weak — apply.
+        }
+
+        // Parent is weak. Apply boost unless there's an equivocating block at
+        // the parent's slot from the same proposer.
+        let parent_slot = parent.slot();
+        let parent_root = parent.root();
+        let parent_proposer = parent.proposer_index().unwrap_or(u64::MAX);
+
+        let has_equivocation = self.nodes.iter().any(|n| {
+            n.as_v29().is_ok()
+                && n.slot() == parent_slot
+                && n.root() != parent_root
+                && n.proposer_index().unwrap_or(u64::MAX - 1) == parent_proposer
+        });
+
+        Ok(!has_equivocation)
+    }
+
+    /// Process an execution payload for a Gloas block.
+    ///
+    /// Sets `payload_received` to true, which makes `is_payload_timely` and
+    /// `is_payload_data_available` return true regardless of PTC votes.
+    /// This maps to `store.payload_states[root] = state` in the spec.
+    pub fn on_valid_execution_payload(&mut self, block_root: Hash256) -> Result<(), Error> {
+        let index = *self
+            .indices
+            .get(&block_root)
+            .ok_or(Error::NodeUnknown(block_root))?;
+        let node = self
+            .nodes
+            .get_mut(index)
+            .ok_or(Error::InvalidNodeIndex(index))?;
+        let v29 = node
+            .as_v29_mut()
+            .map_err(|_| Error::InvalidNodeVariant { block_root })?;
+        v29.payload_received = true;
+
+        Ok(())
+    }
+
     /// Updates the `block_root` and all ancestors to have validated execution payloads.
     ///
     /// Returns an error if:
@@ -402,33 +830,48 @@ impl ProtoArray {
                 .nodes
                 .get_mut(index)
                 .ok_or(Error::InvalidNodeIndex(index))?;
-            let parent_index = match node.execution_status {
-                // We have reached a node that we already know is valid. No need to iterate further
-                // since we assume an ancestors have already been set to valid.
-                ExecutionStatus::Valid(_) => return Ok(()),
-                // We have reached an irrelevant node, this node is prior to a terminal execution
-                // block. There's no need to iterate further, it's impossible for this block to have
-                // any relevant ancestors.
-                ExecutionStatus::Irrelevant(_) => return Ok(()),
-                // The block has an unknown status, set it to valid since any ancestor of a valid
-                // payload can be considered valid.
-                ExecutionStatus::Optimistic(payload_block_hash) => {
-                    node.execution_status = ExecutionStatus::Valid(payload_block_hash);
+            let parent_index = match node {
+                ProtoNode::V17(node) => match node.execution_status {
+                    // We have reached a node that we already know is valid. No need to iterate further
+                    // since we assume an ancestors have already been set to valid.
+                    ExecutionStatus::Valid(_) => return Ok(()),
+                    // We have reached an irrelevant node, this node is prior to a terminal execution
+                    // block. There's no need to iterate further, it's impossible for this block to have
+                    // any relevant ancestors.
+                    ExecutionStatus::Irrelevant(_) => return Ok(()),
+                    // The block has an unknown status, set it to valid since any ancestor of a valid
+                    // payload can be considered valid.
+                    ExecutionStatus::Optimistic(payload_block_hash) => {
+                        node.execution_status = ExecutionStatus::Valid(payload_block_hash);
+                        if let Some(parent_index) = node.parent {
+                            parent_index
+                        } else {
+                            // We have reached the root block, iteration complete.
+                            return Ok(());
+                        }
+                    }
+                    // An ancestor of the valid payload was invalid. This is a serious error which
+                    // indicates a consensus failure in the execution node. This is unrecoverable.
+                    ExecutionStatus::Invalid(ancestor_payload_block_hash) => {
+                        return Err(Error::InvalidAncestorOfValidPayload {
+                            ancestor_block_root: node.root,
+                            ancestor_payload_block_hash,
+                        });
+                    }
+                },
+                // Gloas nodes don't carry `ExecutionStatus`. Mark the validated
+                // block as payload-received so that `is_payload_timely` /
+                // `is_payload_data_available` and `index == 1` attestations work.
+                ProtoNode::V29(node) => {
+                    if index == verified_node_index {
+                        node.payload_received = true;
+                    }
                     if let Some(parent_index) = node.parent {
                         parent_index
                     } else {
-                        // We have reached the root block, iteration complete.
                         return Ok(());
                     }
                 }
-                // An ancestor of the valid payload was invalid. This is a serious error which
-                // indicates a consensus failure in the execution node. This is unrecoverable.
-                ExecutionStatus::Invalid(ancestor_payload_block_hash) => {
-                    return Err(Error::InvalidAncestorOfValidPayload {
-                        ancestor_block_root: node.root,
-                        ancestor_payload_block_hash,
-                    });
-                }
             };
 
             index = parent_index;
@@ -484,10 +927,11 @@ impl ProtoArray {
                 .get_mut(index)
                 .ok_or(Error::InvalidNodeIndex(index))?;
 
-            match node.execution_status {
-                ExecutionStatus::Valid(hash)
-                | ExecutionStatus::Invalid(hash)
-                | ExecutionStatus::Optimistic(hash) => {
+            let node_execution_status = node.execution_status();
+            match node_execution_status {
+                Ok(ExecutionStatus::Valid(hash))
+                | Ok(ExecutionStatus::Invalid(hash))
+                | Ok(ExecutionStatus::Optimistic(hash)) => {
                     // If we're no longer processing the `head_block_root` and the last valid
                     // ancestor is unknown, exit this loop and proceed to invalidate and
                     // descendants of `head_block_root`/`latest_valid_ancestor_root`.
@@ -496,7 +940,7 @@ impl ProtoArray {
                     // supplied, don't validate any ancestors. The alternative is to invalidate
                     // *all* ancestors, which would likely involve shutting down the client due to
                     // an invalid justified checkpoint.
-                    if !latest_valid_ancestor_is_descendant && node.root != head_block_root {
+                    if !latest_valid_ancestor_is_descendant && node.root() != head_block_root {
                         break;
                     } else if op.latest_valid_ancestor() == Some(hash) {
                         // If the `best_child` or `best_descendant` of the latest valid hash was
@@ -507,63 +951,67 @@ impl ProtoArray {
                         // defend against errors which might result in an invalid block being set as
                         // head.
                         if node
-                            .best_child
+                            .best_child()
                             .is_some_and(|i| invalidated_indices.contains(&i))
                         {
-                            node.best_child = None
+                            *node.best_child_mut() = None
                         }
                         if node
-                            .best_descendant
+                            .best_descendant()
                             .is_some_and(|i| invalidated_indices.contains(&i))
                         {
-                            node.best_descendant = None
+                            *node.best_descendant_mut() = None
                         }
 
                         break;
                     }
                 }
-                ExecutionStatus::Irrelevant(_) => break,
+                Ok(ExecutionStatus::Irrelevant(_)) => break,
+                Err(_) => break,
             }
 
             // Only invalidate the head block if either:
             //
             // - The head block was specifically indicated to be invalidated.
             // - The latest valid hash is a known ancestor.
-            if node.root != head_block_root
+            if node.root() != head_block_root
                 || op.invalidate_block_root()
                 || latest_valid_ancestor_is_descendant
             {
-                match &node.execution_status {
+                match node.execution_status() {
                     // It's illegal for an execution client to declare that some previously-valid block
                     // is now invalid. This is a consensus failure on their behalf.
-                    ExecutionStatus::Valid(hash) => {
+                    Ok(ExecutionStatus::Valid(hash)) => {
                         return Err(Error::ValidExecutionStatusBecameInvalid {
-                            block_root: node.root,
-                            payload_block_hash: *hash,
+                            block_root: node.root(),
+                            payload_block_hash: hash,
                         });
                     }
-                    ExecutionStatus::Optimistic(hash) => {
+                    Ok(ExecutionStatus::Optimistic(hash)) => {
                         invalidated_indices.insert(index);
-                        node.execution_status = ExecutionStatus::Invalid(*hash);
+                        if let ProtoNode::V17(node) = node {
+                            node.execution_status = ExecutionStatus::Invalid(hash);
+                        }
 
                         // It's impossible for an invalid block to lead to a "best" block, so set these
                         // fields to `None`.
                         //
                         // Failing to set these values will result in `Self::node_leads_to_viable_head`
                         // returning `false` for *valid* ancestors of invalid blocks.
-                        node.best_child = None;
-                        node.best_descendant = None;
+                        *node.best_child_mut() = None;
+                        *node.best_descendant_mut() = None;
                     }
                     // The block is already invalid, but keep going backwards to ensure all ancestors
                     // are updated.
-                    ExecutionStatus::Invalid(_) => (),
+                    Ok(ExecutionStatus::Invalid(_)) => (),
                     // This block is pre-merge, therefore it has no execution status. Nor do its
                     // ancestors.
-                    ExecutionStatus::Irrelevant(_) => break,
+                    Ok(ExecutionStatus::Irrelevant(_)) => break,
+                    Err(_) => (),
                 }
             }
 
-            if let Some(parent_index) = node.parent {
+            if let Some(parent_index) = node.parent() {
                 index = parent_index
             } else {
                 // The root of the block tree has been reached (aka the finalized block), without
@@ -597,24 +1045,27 @@ impl ProtoArray {
                 .get_mut(index)
                 .ok_or(Error::InvalidNodeIndex(index))?;
 
-            if let Some(parent_index) = node.parent
+            if let Some(parent_index) = node.parent()
                 && invalidated_indices.contains(&parent_index)
             {
-                match &node.execution_status {
-                    ExecutionStatus::Valid(hash) => {
+                match node.execution_status() {
+                    Ok(ExecutionStatus::Valid(hash)) => {
                         return Err(Error::ValidExecutionStatusBecameInvalid {
-                            block_root: node.root,
-                            payload_block_hash: *hash,
+                            block_root: node.root(),
+                            payload_block_hash: hash,
                         });
                     }
-                    ExecutionStatus::Optimistic(hash) | ExecutionStatus::Invalid(hash) => {
-                        node.execution_status = ExecutionStatus::Invalid(*hash)
+                    Ok(ExecutionStatus::Optimistic(hash)) | Ok(ExecutionStatus::Invalid(hash)) => {
+                        if let ProtoNode::V17(node) = node {
+                            node.execution_status = ExecutionStatus::Invalid(hash)
+                        }
                     }
-                    ExecutionStatus::Irrelevant(_) => {
+                    Ok(ExecutionStatus::Irrelevant(_)) => {
                         return Err(Error::IrrelevantDescendant {
-                            block_root: node.root,
+                            block_root: node.root(),
                         });
                     }
+                    Err(_) => (),
                 }
 
                 invalidated_indices.insert(index);
@@ -652,18 +1103,62 @@ impl ProtoArray {
 
         // Since there are no valid descendants of a justified block with an invalid execution
         // payload, there would be no head to choose from.
-        //
-        // Fork choice is effectively broken until a new justified root is set. It might not be
-        // practically possible to set a new justified root if we are unable to find a new head.
-        //
-        // This scenario is *unsupported*. It represents a serious consensus failure.
-        if justified_node.execution_status.is_invalid() {
+        // Execution status tracking only exists on V17 (pre-Gloas) nodes.
+        if let Ok(v17) = justified_node.as_v17()
+            && v17.execution_status.is_invalid()
+        {
             return Err(Error::InvalidJustifiedCheckpointExecutionStatus {
                 justified_root: *justified_root,
             });
         }
 
-        let best_descendant_index = justified_node.best_descendant.unwrap_or(justified_index);
+        // For V29 (Gloas) justified nodes, use the virtual tree walk directly.
+        if justified_node.as_v29().is_ok() {
+            return self.find_head_v29_walk::<E>(
+                justified_index,
+                current_slot,
+                best_justified_checkpoint,
+                best_finalized_checkpoint,
+            );
+        }
+
+        // Pre-Gloas justified node, but descendants may be V29.
+        // Walk via best_child chain; switch to V29 walk when we hit one.
+        if justified_node.best_child().is_some() || justified_node.best_descendant().is_some() {
+            let mut current_index = justified_index;
+            loop {
+                let node = self
+                    .nodes
+                    .get(current_index)
+                    .ok_or(Error::InvalidNodeIndex(current_index))?;
+
+                // Hit a V29 node — switch to virtual tree walk.
+                if node.as_v29().is_ok() {
+                    return self.find_head_v29_walk::<E>(
+                        current_index,
+                        current_slot,
+                        best_justified_checkpoint,
+                        best_finalized_checkpoint,
+                    );
+                }
+
+                // V17 node: follow best_child.
+                if let Some(bc_idx) = node.best_child() {
+                    current_index = bc_idx;
+                } else {
+                    break;
+                }
+            }
+
+            let head_node = self
+                .nodes
+                .get(current_index)
+                .ok_or(Error::InvalidNodeIndex(current_index))?;
+            return Ok(head_node.root());
+        }
+
+        // Pre-Gloas fallback: use best_descendant directly.
+        let best_descendant_index = justified_node.best_descendant().unwrap_or(justified_index);
 
         let best_node = self
             .nodes
@@ -682,13 +1177,161 @@ impl ProtoArray {
                 start_root: *justified_root,
                 justified_checkpoint: best_justified_checkpoint,
                 finalized_checkpoint: best_finalized_checkpoint,
-                head_root: best_node.root,
-                head_justified_checkpoint: best_node.justified_checkpoint,
-                head_finalized_checkpoint: best_node.finalized_checkpoint,
+                head_root: best_node.root(),
+                head_justified_checkpoint: *best_node.justified_checkpoint(),
+                head_finalized_checkpoint: *best_node.finalized_checkpoint(),
             })));
         }
 
-        Ok(best_node.root)
+        Ok(best_node.root())
+    }
+
+    /// V29 virtual tree walk for `find_head`.
+    ///
+    /// At each V29 node, determine the preferred payload direction (FULL or EMPTY)
+    /// by comparing weights. If `best_child` matches the preferred direction, follow
+    /// it directly. Otherwise, scan all nodes to find the best child matching
+    /// the preferred direction.
+    fn find_head_v29_walk<E: EthSpec>(
+        &self,
+        start_index: usize,
+        current_slot: Slot,
+        best_justified_checkpoint: Checkpoint,
+        best_finalized_checkpoint: Checkpoint,
+    ) -> Result<Hash256, Error> {
+        let ptc_size = E::ptc_size();
+        let mut current_index = start_index;
+
+        loop {
+            let node = self
+                .nodes
+                .get(current_index)
+                .ok_or(Error::InvalidNodeIndex(current_index))?;
+
+            let Ok(v29) = node.as_v29() else { break };
+
+            let prefer_full = Self::v29_prefer_full(v29, node.slot(), current_slot, ptc_size);
+            let preferred_status = if prefer_full {
+                PayloadStatus::Full
+            } else {
+                PayloadStatus::Empty
+            };
+
+            // Fast path: check if best_child already matches the preferred direction.
+            let next_index = if let Some(best_child_index) = node.best_child() {
+                let best_child_node = self
+                    .nodes
+                    .get(best_child_index)
+                    .ok_or(Error::InvalidNodeIndex(best_child_index))?;
+                if best_child_node
+                    .as_v29()
+                    .is_ok_and(|v| v.parent_payload_status == preferred_status)
+                {
+                    Some(best_child_index)
+                } else {
+                    // best_child is on the wrong direction. Scan for the best matching child.
+                    self.find_best_child_with_status::<E>(
+                        current_index,
+                        preferred_status,
+                        current_slot,
+                        best_justified_checkpoint,
+                        best_finalized_checkpoint,
+                    )?
+                }
+            } else {
+                None
+            };
+
+            if let Some(child_index) = next_index {
+                current_index = child_index;
+            } else {
+                break;
+            }
+        }
+
+        let head_node = self
+            .nodes
+            .get(current_index)
+            .ok_or(Error::InvalidNodeIndex(current_index))?;
+        Ok(head_node.root())
+    }
+
+    /// Find the best viable child of `parent_index` whose `parent_payload_status` matches
+    /// `target_status`. Returns `None` if no matching viable child exists.
+    fn find_best_child_with_status<E: EthSpec>(
+        &self,
+        parent_index: usize,
+        target_status: PayloadStatus,
+        current_slot: Slot,
+        best_justified_checkpoint: Checkpoint,
+        best_finalized_checkpoint: Checkpoint,
+    ) -> Result<Option<usize>, Error> {
+        let mut best: Option<(usize, u64, Hash256)> = None;
+        for (node_index, node) in self.nodes.iter().enumerate() {
+            if node.parent() != Some(parent_index) {
+                continue;
+            }
+            if !node
+                .as_v29()
+                .is_ok_and(|v| v.parent_payload_status == target_status)
+            {
+                continue;
+            }
+            if !self.node_leads_to_viable_head::<E>(
+                node,
+                current_slot,
+                best_justified_checkpoint,
+                best_finalized_checkpoint,
+            )? {
+                continue;
+            }
+
+            let child_weight = node.weight();
+            let child_root = node.root();
+            let replace = if let Some((_, best_weight, best_root)) = best {
+                child_weight > best_weight
+                    || (child_weight == best_weight && child_root >= best_root)
+            } else {
+                true
+            };
+
+            if replace {
+                best = Some((node_index, child_weight, child_root));
+            }
+        }
+
+        Ok(best.map(|(index, _, _)| index))
+    }
+
+    /// Determine whether a V29 node prefers the FULL or EMPTY direction.
+    fn v29_prefer_full(
+        v29: &ProtoNodeV29,
+        node_slot: Slot,
+        current_slot: Slot,
+        ptc_size: usize,
+    ) -> bool {
+        if !v29.payload_received {
+            return false;
+        }
+        if node_slot + 1 != current_slot {
+            // Weight comparison, tiebreak to payload_received.
+            if v29.full_payload_weight != v29.empty_payload_weight {
+                v29.full_payload_weight > v29.empty_payload_weight
+            } else {
+                v29.payload_received
+            }
+        } else {
+            // Previous slot: PTC tiebreaker only.
+            is_payload_timely(
+                &v29.payload_timeliness_votes,
+                ptc_size,
+                v29.payload_received,
+            ) && is_payload_data_available(
+                &v29.payload_data_availability_votes,
+                ptc_size,
+                v29.payload_received,
+            )
+        }
     }
 
     /// Update the tree with new finalization information. The tree is only actually pruned if both
@@ -721,7 +1364,7 @@ impl ProtoArray {
                 .nodes
                 .get(node_index)
                 .ok_or(Error::InvalidNodeIndex(node_index))?
-                .root;
+                .root();
             self.indices.remove(root);
         }
 
@@ -738,19 +1381,19 @@ impl ProtoArray {
         // Iterate through all the existing nodes and adjust their indices to match the new layout
         // of `self.nodes`.
         for node in self.nodes.iter_mut() {
-            if let Some(parent) = node.parent {
+            if let Some(parent) = node.parent() {
                 // If `node.parent` is less than `finalized_index`, set it to `None`.
-                node.parent = parent.checked_sub(finalized_index);
+                *node.parent_mut() = parent.checked_sub(finalized_index);
             }
-            if let Some(best_child) = node.best_child {
-                node.best_child = Some(
+            if let Some(best_child) = node.best_child() {
+                *node.best_child_mut() = Some(
                     best_child
                         .checked_sub(finalized_index)
                         .ok_or(Error::IndexOverflow("best_child"))?,
                 );
             }
-            if let Some(best_descendant) = node.best_descendant {
-                node.best_descendant = Some(
+            if let Some(best_descendant) = node.best_descendant() {
+                *node.best_descendant_mut() = Some(
                     best_descendant
                         .checked_sub(finalized_index)
                         .ok_or(Error::IndexOverflow("best_descendant"))?,
@@ -800,17 +1443,15 @@ impl ProtoArray {
 
         // These three variables are aliases to the three options that we may set the
         // `parent.best_child` and `parent.best_descendant` to.
-        //
-        // I use the aliases to assist readability.
         let change_to_none = (None, None);
         let change_to_child = (
             Some(child_index),
-            child.best_descendant.or(Some(child_index)),
+            child.best_descendant().or(Some(child_index)),
         );
-        let no_change = (parent.best_child, parent.best_descendant);
+        let no_change = (parent.best_child(), parent.best_descendant());
 
         let (new_best_child, new_best_descendant) =
-            if let Some(best_child_index) = parent.best_child {
+            if let Some(best_child_index) = parent.best_child() {
                 if best_child_index == child_index && !child_leads_to_viable_head {
                     // If the child is already the best-child of the parent but it's not viable for
                     // the head, remove it.
@@ -833,32 +1474,22 @@ impl ProtoArray {
                     )?;
 
                     if child_leads_to_viable_head && !best_child_leads_to_viable_head {
-                        // The child leads to a viable head, but the current best-child doesn't.
                         change_to_child
                     } else if !child_leads_to_viable_head && best_child_leads_to_viable_head {
-                        // The best child leads to a viable head, but the child doesn't.
                         no_change
-                    } else if child.weight == best_child.weight {
-                        // Tie-breaker of equal weights by root.
-                        if child.root >= best_child.root {
-                            change_to_child
-                        } else {
-                            no_change
-                        }
+                    } else if child.weight() > best_child.weight() {
+                        change_to_child
+                    } else if child.weight() < best_child.weight() {
+                        no_change
+                    } else if *child.root() >= *best_child.root() {
+                        change_to_child
                     } else {
-                        // Choose the winner by weight.
-                        if child.weight > best_child.weight {
-                            change_to_child
-                        } else {
-                            no_change
-                        }
+                        no_change
                     }
                 }
             } else if child_leads_to_viable_head {
-                // There is no current best-child and the child is viable.
                 change_to_child
             } else {
-                // There is no current best-child but the child is not viable.
                 no_change
             };
 
@@ -867,8 +1498,8 @@ impl ProtoArray {
             .get_mut(parent_index)
             .ok_or(Error::InvalidNodeIndex(parent_index))?;
 
-        parent.best_child = new_best_child;
-        parent.best_descendant = new_best_descendant;
+        *parent.best_child_mut() = new_best_child;
+        *parent.best_descendant_mut() = new_best_descendant;
 
         Ok(())
     }
@@ -883,7 +1514,7 @@ impl ProtoArray {
         best_finalized_checkpoint: Checkpoint,
     ) -> Result<bool, Error> {
         let best_descendant_is_viable_for_head =
-            if let Some(best_descendant_index) = node.best_descendant {
+            if let Some(best_descendant_index) = node.best_descendant() {
                 let best_descendant = self
                     .nodes
                     .get(best_descendant_index)
@@ -921,25 +1552,27 @@ impl ProtoArray {
         best_justified_checkpoint: Checkpoint,
         best_finalized_checkpoint: Checkpoint,
     ) -> bool {
-        if node.execution_status.is_invalid() {
+        if let Ok(proto_node) = node.as_v17()
+            && proto_node.execution_status.is_invalid()
+        {
             return false;
         }
 
         let genesis_epoch = Epoch::new(0);
         let current_epoch = current_slot.epoch(E::slots_per_epoch());
-        let node_epoch = node.slot.epoch(E::slots_per_epoch());
-        let node_justified_checkpoint = node.justified_checkpoint;
+        let node_epoch = node.slot().epoch(E::slots_per_epoch());
+        let node_justified_checkpoint = node.justified_checkpoint();
 
         let voting_source = if current_epoch > node_epoch {
             // The block is from a prior epoch, the voting source will be pulled-up.
-            node.unrealized_justified_checkpoint
+            node.unrealized_justified_checkpoint()
                 // Sometimes we don't track the unrealized justification. In
                 // that case, just use the fully-realized justified checkpoint.
-                .unwrap_or(node_justified_checkpoint)
+                .unwrap_or(*node_justified_checkpoint)
         } else {
             // The block is not from a prior epoch, therefore the voting source
             // is not pulled up.
-            node_justified_checkpoint
+            *node_justified_checkpoint
         };
 
         let correct_justified = best_justified_checkpoint.epoch == genesis_epoch
@@ -948,7 +1581,7 @@ impl ProtoArray {
 
         let correct_finalized = best_finalized_checkpoint.epoch == genesis_epoch
             || self
-                .is_finalized_checkpoint_or_descendant::<E>(node.root, best_finalized_checkpoint);
+                .is_finalized_checkpoint_or_descendant::<E>(node.root(), best_finalized_checkpoint);
 
         correct_justified && correct_finalized
     }
@@ -970,7 +1603,7 @@ impl ProtoArray {
         block_root: &Hash256,
     ) -> impl Iterator<Item = (Hash256, Slot)> + 'a {
         self.iter_nodes(block_root)
-            .map(|node| (node.root, node.slot))
+            .map(|node| (node.root(), node.slot()))
     }
 
     /// Returns `true` if the `descendant_root` has an ancestor with `ancestor_root`. Always
@@ -991,8 +1624,8 @@ impl ProtoArray {
             .and_then(|ancestor_index| self.nodes.get(*ancestor_index))
             .and_then(|ancestor| {
                 self.iter_block_roots(&descendant_root)
-                    .take_while(|(_root, slot)| *slot >= ancestor.slot)
-                    .find(|(_root, slot)| *slot == ancestor.slot)
+                    .take_while(|(_root, slot)| *slot >= ancestor.slot())
+                    .find(|(_root, slot)| *slot == ancestor.slot())
                     .map(|(root, _slot)| root == ancestor_root)
             })
             .unwrap_or(false)
@@ -1031,15 +1664,15 @@ impl ProtoArray {
         // Run this check once, outside of the loop rather than inside the loop.
         // If the conditions don't match for this node then they're unlikely to
         // start matching for its ancestors.
-        for checkpoint in &[node.finalized_checkpoint, node.justified_checkpoint] {
-            if checkpoint == &best_finalized_checkpoint {
+        for checkpoint in &[node.finalized_checkpoint(), node.justified_checkpoint()] {
+            if **checkpoint == best_finalized_checkpoint {
                 return true;
             }
         }
 
         for checkpoint in &[
-            node.unrealized_finalized_checkpoint,
-            node.unrealized_justified_checkpoint,
+            node.unrealized_finalized_checkpoint(),
+            node.unrealized_justified_checkpoint(),
         ] {
             if checkpoint.is_some_and(|cp| cp == best_finalized_checkpoint) {
                 return true;
@@ -1049,13 +1682,13 @@ impl ProtoArray {
         loop {
             // If `node` is less than or equal to the finalized slot then `node`
             // must be the finalized block.
-            if node.slot <= finalized_slot {
-                return node.root == finalized_root;
+            if node.slot() <= finalized_slot {
+                return node.root() == finalized_root;
             }
 
             // Since `node` is from a higher slot that the finalized checkpoint,
             // replace `node` with the parent of `node`.
-            if let Some(parent) = node.parent.and_then(|index| self.nodes.get(index)) {
+            if let Some(parent) = node.parent().and_then(|index| self.nodes.get(index)) {
                 node = parent
             } else {
                 // If `node` is not the finalized block and its parent does not
@@ -1077,11 +1710,12 @@ impl ProtoArray {
             .iter()
             .rev()
             .find(|node| {
-                node.execution_status
-                    .block_hash()
+                node.execution_status()
+                    .ok()
+                    .and_then(|execution_status| execution_status.block_hash())
                     .is_some_and(|node_block_hash| node_block_hash == *block_hash)
             })
-            .map(|node| node.root)
+            .map(|node| node.root())
     }
 
     /// Returns all nodes that have zero children and are descended from the finalized checkpoint.
@@ -1096,9 +1730,9 @@ impl ProtoArray {
         self.nodes
             .iter()
             .filter(|node| {
-                node.best_child.is_none()
+                node.best_child().is_none()
                     && self.is_finalized_checkpoint_or_descendant::<E>(
-                        node.root,
+                        node.root(),
                         best_finalized_checkpoint,
                     )
             })
@@ -1106,6 +1740,32 @@ impl ProtoArray {
     }
 }
 
+/// Derive `is_payload_timely` from the timeliness vote bitfield.
+///
+/// Per spec: returns false if the payload has not been received locally
+/// (`payload_received == false`, i.e. `root not in store.payload_states`),
+/// regardless of PTC votes. Both local receipt and PTC threshold are required.
+pub fn is_payload_timely(
+    timeliness_votes: &BitVector<U512>,
+    ptc_size: usize,
+    payload_received: bool,
+) -> bool {
+    payload_received && timeliness_votes.num_set_bits() > ptc_size / 2
+}
+
+/// Derive `is_payload_data_available` from the data availability vote bitfield.
+///
+/// Per spec: returns false if the payload has not been received locally
+/// (`payload_received == false`, i.e. `root not in store.payload_states`),
+/// regardless of PTC votes. Both local receipt and PTC threshold are required.
+pub fn is_payload_data_available(
+    availability_votes: &BitVector<U512>,
+    ptc_size: usize,
+    payload_received: bool,
+) -> bool {
+    payload_received && availability_votes.num_set_bits() > ptc_size / 2
+}
+
 /// A helper method to calculate the proposer boost based on the given `justified_balances`.
 ///
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#get_latest_attesting_balance
@@ -1121,6 +1781,19 @@ pub fn calculate_committee_fraction<E: EthSpec>(
         .checked_div(100)
 }
 
+/// Apply a signed delta to an unsigned weight, returning an error on overflow.
+fn apply_delta(weight: u64, delta: i64, index: usize) -> Result<u64, Error> {
+    if delta < 0 {
+        weight
+            .checked_sub(delta.unsigned_abs())
+            .ok_or(Error::DeltaOverflow(index))
+    } else {
+        weight
+            .checked_add(delta as u64)
+            .ok_or(Error::DeltaOverflow(index))
+    }
+}
+
 /// Reverse iterator over one path through a `ProtoArray`.
 pub struct Iter<'a> {
     next_node_index: Option<usize>,
@@ -1133,7 +1806,7 @@ impl<'a> Iterator for Iter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         let next_node_index = self.next_node_index?;
         let node = self.proto_array.nodes.get(next_node_index)?;
-        self.next_node_index = node.parent;
+        self.next_node_index = node.parent();
         Some(node)
     }
 }
diff --git a/consensus/proto_array/src/proto_array_fork_choice.rs b/consensus/proto_array/src/proto_array_fork_choice.rs
index 3edf1e0644d..64ec5a85498 100644
--- a/consensus/proto_array/src/proto_array_fork_choice.rs
+++ b/consensus/proto_array/src/proto_array_fork_choice.rs
@@ -2,8 +2,8 @@ use crate::{
     JustifiedBalances,
     error::Error,
     proto_array::{
-        InvalidationOperation, Iter, ProposerBoost, ProtoArray, ProtoNode,
-        calculate_committee_fraction,
+        InvalidationOperation, Iter, NodeDelta, ProposerBoost, ProtoArray, ProtoNode,
+        calculate_committee_fraction, is_payload_data_available, is_payload_timely,
     },
     ssz_container::SszContainer,
 };
@@ -26,10 +26,19 @@ pub const DEFAULT_PRUNE_THRESHOLD: usize = 256;
 pub struct VoteTracker {
     current_root: Hash256,
     next_root: Hash256,
-    next_epoch: Epoch,
+    current_slot: Slot,
+    next_slot: Slot,
+    current_payload_present: bool,
+    next_payload_present: bool,
 }
 
-/// Represents the verification status of an execution payload.
+pub struct LatestMessage {
+    pub slot: Slot,
+    pub root: Hash256,
+    pub payload_present: bool,
+}
+
+/// Represents the verification status of an execution payload pre-Gloas.
 #[derive(Clone, Copy, Debug, PartialEq, Encode, Decode, Serialize, Deserialize)]
 #[ssz(enum_behaviour = "union")]
 pub enum ExecutionStatus {
@@ -49,6 +58,16 @@ pub enum ExecutionStatus {
     Irrelevant(bool),
 }
 
+/// Represents the status of an execution payload post-Gloas.
+#[derive(Clone, Copy, Debug, PartialEq, Encode, Decode, Serialize, Deserialize)]
+#[ssz(enum_behaviour = "tag")]
+#[repr(u8)]
+pub enum PayloadStatus {
+    Empty = 0,
+    Full = 1,
+    Pending = 2,
+}
+
 impl ExecutionStatus {
     pub fn is_execution_enabled(&self) -> bool {
         !matches!(self, ExecutionStatus::Irrelevant(_))
@@ -159,6 +178,11 @@ pub struct Block {
     pub execution_status: ExecutionStatus,
     pub unrealized_justified_checkpoint: Option<Checkpoint>,
     pub unrealized_finalized_checkpoint: Option<Checkpoint>,
+
+    /// post-Gloas fields
+    pub execution_payload_parent_hash: Option<ExecutionBlockHash>,
+    pub execution_payload_block_hash: Option<ExecutionBlockHash>,
+    pub proposer_index: Option<u64>,
 }
 
 impl Block {
@@ -422,6 +446,9 @@ impl ProtoArrayForkChoice {
         current_epoch_shuffling_id: AttestationShufflingId,
         next_epoch_shuffling_id: AttestationShufflingId,
         execution_status: ExecutionStatus,
+        execution_payload_parent_hash: Option<ExecutionBlockHash>,
+        execution_payload_block_hash: Option<ExecutionBlockHash>,
+        spec: &ChainSpec,
     ) -> Result<Self, String> {
         let mut proto_array = ProtoArray {
             prune_threshold: DEFAULT_PRUNE_THRESHOLD,
@@ -445,6 +472,9 @@ impl ProtoArrayForkChoice {
             execution_status,
             unrealized_justified_checkpoint: Some(justified_checkpoint),
             unrealized_finalized_checkpoint: Some(finalized_checkpoint),
+            execution_payload_parent_hash,
+            execution_payload_block_hash,
+            proposer_index: None,
         };
 
         proto_array
@@ -453,6 +483,7 @@ impl ProtoArrayForkChoice {
                 current_slot,
                 justified_checkpoint,
                 finalized_checkpoint,
+                spec,
             )
             .map_err(|e| format!("Failed to add finalized block to proto_array: {:?}", e))?;
 
@@ -463,6 +494,11 @@ impl ProtoArrayForkChoice {
         })
     }
 
+    pub fn on_execution_payload(&mut self, block_root: Hash256) -> Result<(), String> {
+        self.proto_array
+            .on_valid_execution_payload(block_root)
+            .map_err(|e| format!("Failed to process execution payload: {:?}", e))
+    }
     /// See `ProtoArray::propagate_execution_payload_validation` for documentation.
     pub fn process_execution_payload_validation(
         &mut self,
@@ -488,24 +524,65 @@ impl ProtoArrayForkChoice {
         &mut self,
         validator_index: usize,
         block_root: Hash256,
-        target_epoch: Epoch,
+        attestation_slot: Slot,
+        payload_present: bool,
     ) -> Result<(), String> {
         let vote = self.votes.get_mut(validator_index);
 
-        if target_epoch > vote.next_epoch || *vote == VoteTracker::default() {
+        if attestation_slot > vote.next_slot || *vote == VoteTracker::default() {
             vote.next_root = block_root;
-            vote.next_epoch = target_epoch;
+            vote.next_slot = attestation_slot;
+            vote.next_payload_present = payload_present;
         }
 
         Ok(())
     }
 
+    /// Process a PTC vote by setting the appropriate bits on the target block's V29 node.
+    ///
+    /// `ptc_index` is the voter's position in the PTC committee (resolved by the caller).
+    /// This writes directly to the node's bitfields, bypassing the delta pipeline.
+    pub fn process_payload_attestation(
+        &mut self,
+        block_root: Hash256,
+        ptc_index: usize,
+        payload_present: bool,
+        blob_data_available: bool,
+    ) -> Result<(), String> {
+        let node_index = self
+            .proto_array
+            .indices
+            .get(&block_root)
+            .copied()
+            .ok_or_else(|| {
+                format!("process_payload_attestation: unknown block root {block_root:?}")
+            })?;
+        let node = self.proto_array.nodes.get_mut(node_index).ok_or_else(|| {
+            format!("process_payload_attestation: invalid node index {node_index}")
+        })?;
+        let v29 = node
+            .as_v29_mut()
+            .map_err(|_| format!("process_payload_attestation: node {block_root:?} is not V29"))?;
+
+        v29.payload_timeliness_votes
+            .set(ptc_index, payload_present)
+            .map_err(|e| format!("process_payload_attestation: timeliness set failed: {e:?}"))?;
+        v29.payload_data_availability_votes
+            .set(ptc_index, blob_data_available)
+            .map_err(|e| {
+                format!("process_payload_attestation: data availability set failed: {e:?}")
+            })?;
+
+        Ok(())
+    }
+
     pub fn process_block<E: EthSpec>(
         &mut self,
         block: Block,
         current_slot: Slot,
         justified_checkpoint: Checkpoint,
         finalized_checkpoint: Checkpoint,
+        spec: &ChainSpec,
     ) -> Result<(), String> {
         if block.parent_root.is_none() {
             return Err("Missing parent root".to_string());
@@ -517,6 +594,7 @@ impl ProtoArrayForkChoice {
                 current_slot,
                 justified_checkpoint,
                 finalized_checkpoint,
+                spec,
             )
             .map_err(|e| format!("process_block_error: {:?}", e))
     }
@@ -534,9 +612,16 @@ impl ProtoArrayForkChoice {
     ) -> Result<Hash256, String> {
         let old_balances = &mut self.balances;
         let new_balances = justified_state_balances;
+        let node_slots = self
+            .proto_array
+            .nodes
+            .iter()
+            .map(|node| node.slot())
+            .collect::<Vec<_>>();
 
         let deltas = compute_deltas(
             &self.proto_array.indices,
+            &node_slots,
             &mut self.votes,
             &old_balances.effective_balances,
             &new_balances.effective_balances,
@@ -593,13 +678,13 @@ impl ProtoArrayForkChoice {
         )?;
 
         // Only re-org a single slot. This prevents cascading failures during asynchrony.
-        let head_slot_ok = info.head_node.slot + 1 == current_slot;
+        let head_slot_ok = info.head_node.slot().saturating_add(1_u64) == current_slot;
         if !head_slot_ok {
             return Err(DoNotReOrg::HeadDistance.into());
         }
 
         // Only re-org if the head's weight is less than the heads configured committee fraction.
-        let head_weight = info.head_node.weight;
+        let head_weight = info.head_node.weight();
         let re_org_head_weight_threshold = info.re_org_head_weight_threshold;
         let weak_head = head_weight < re_org_head_weight_threshold;
         if !weak_head {
@@ -611,7 +696,7 @@ impl ProtoArrayForkChoice {
         }
 
         // Only re-org if the parent's weight is greater than the parents configured committee fraction.
-        let parent_weight = info.parent_node.weight;
+        let parent_weight = info.parent_node.weight();
         let re_org_parent_weight_threshold = info.re_org_parent_weight_threshold;
         let parent_strong = parent_weight > re_org_parent_weight_threshold;
         if !parent_strong {
@@ -650,14 +735,14 @@ impl ProtoArrayForkChoice {
         let parent_node = nodes.pop().ok_or(DoNotReOrg::MissingHeadOrParentNode)?;
         let head_node = nodes.pop().ok_or(DoNotReOrg::MissingHeadOrParentNode)?;
 
-        let parent_slot = parent_node.slot;
-        let head_slot = head_node.slot;
-        let re_org_block_slot = head_slot + 1;
+        let parent_slot = parent_node.slot();
+        let head_slot = head_node.slot();
+        let re_org_block_slot = head_slot.saturating_add(1_u64);
 
         // Check finalization distance.
         let proposal_epoch = re_org_block_slot.epoch(E::slots_per_epoch());
         let finalized_epoch = head_node
-            .unrealized_finalized_checkpoint
+            .unrealized_finalized_checkpoint()
             .ok_or(DoNotReOrg::MissingHeadFinalizedCheckpoint)?
             .epoch;
         let epochs_since_finalization = proposal_epoch.saturating_sub(finalized_epoch).as_u64();
@@ -689,10 +774,10 @@ impl ProtoArrayForkChoice {
         }
 
         // Check FFG.
-        let ffg_competitive = parent_node.unrealized_justified_checkpoint
-            == head_node.unrealized_justified_checkpoint
-            && parent_node.unrealized_finalized_checkpoint
-                == head_node.unrealized_finalized_checkpoint;
+        let ffg_competitive = parent_node.unrealized_justified_checkpoint()
+            == head_node.unrealized_justified_checkpoint()
+            && parent_node.unrealized_finalized_checkpoint()
+                == head_node.unrealized_finalized_checkpoint();
         if !ffg_competitive {
             return Err(DoNotReOrg::JustificationAndFinalizationNotCompetitive.into());
         }
@@ -720,10 +805,10 @@ impl ProtoArrayForkChoice {
     /// This will operate on *all* blocks, even those that do not descend from the finalized
     /// ancestor.
     pub fn contains_invalid_payloads(&mut self) -> bool {
-        self.proto_array
-            .nodes
-            .iter()
-            .any(|node| node.execution_status.is_invalid())
+        self.proto_array.nodes.iter().any(|node| {
+            node.execution_status()
+                .is_ok_and(|status| status.is_invalid())
+        })
     }
 
     /// For all nodes, regardless of their relationship to the finalized block, set their execution
@@ -748,9 +833,11 @@ impl ProtoArrayForkChoice {
                 .get_mut(node_index)
                 .ok_or("unreachable index out of bounds in proto_array nodes")?;
 
-            match node.execution_status {
-                ExecutionStatus::Invalid(block_hash) => {
-                    node.execution_status = ExecutionStatus::Optimistic(block_hash);
+            match node.execution_status() {
+                Ok(ExecutionStatus::Invalid(block_hash)) => {
+                    if let ProtoNode::V17(node) = node {
+                        node.execution_status = ExecutionStatus::Optimistic(block_hash);
+                    }
 
                     // Restore the weight of the node, it would have been set to `0` in
                     // `apply_score_changes` when it was invalidated.
@@ -760,7 +847,7 @@ impl ProtoArrayForkChoice {
                         .iter()
                         .enumerate()
                         .filter_map(|(validator_index, vote)| {
-                            if vote.current_root == node.root {
+                            if vote.current_root == node.root() {
                                 // Any voting validator that does not have a balance should be
                                 // ignored. This is consistent with `compute_deltas`.
                                 self.balances.effective_balances.get(validator_index)
@@ -773,7 +860,7 @@ impl ProtoArrayForkChoice {
                     // If the invalid root was boosted, apply the weight to it and
                     // ancestors.
                     if let Some(proposer_score_boost) = spec.proposer_score_boost
-                        && self.proto_array.previous_proposer_boost.root == node.root
+                        && self.proto_array.previous_proposer_boost.root == node.root()
                     {
                         // Compute the score based upon the current balances. We can't rely on
                         // the `previous_proposr_boost.score` since it is set to zero with an
@@ -794,12 +881,12 @@ impl ProtoArrayForkChoice {
                     if restored_weight > 0 {
                         let mut node_or_ancestor = node;
                         loop {
-                            node_or_ancestor.weight = node_or_ancestor
-                                .weight
+                            *node_or_ancestor.weight_mut() = node_or_ancestor
+                                .weight()
                                 .checked_add(restored_weight)
                                 .ok_or("Overflow when adding weight to ancestor")?;
 
-                            if let Some(parent_index) = node_or_ancestor.parent {
+                            if let Some(parent_index) = node_or_ancestor.parent() {
                                 node_or_ancestor = self
                                     .proto_array
                                     .nodes
@@ -815,11 +902,14 @@ impl ProtoArrayForkChoice {
                 }
                 // There are no balance changes required if the node was either valid or
                 // optimistic.
-                ExecutionStatus::Valid(block_hash) | ExecutionStatus::Optimistic(block_hash) => {
-                    node.execution_status = ExecutionStatus::Optimistic(block_hash)
+                Ok(ExecutionStatus::Valid(block_hash))
+                | Ok(ExecutionStatus::Optimistic(block_hash)) => {
+                    if let ProtoNode::V17(node) = node {
+                        node.execution_status = ExecutionStatus::Optimistic(block_hash)
+                    }
                 }
                 // An irrelevant node cannot become optimistic, this is a no-op.
-                ExecutionStatus::Irrelevant(_) => (),
+                Ok(ExecutionStatus::Irrelevant(_)) | Err(_) => (),
             }
         }
 
@@ -856,30 +946,43 @@ impl ProtoArrayForkChoice {
     pub fn get_block(&self, block_root: &Hash256) -> Option<Block> {
         let block = self.get_proto_node(block_root)?;
         let parent_root = block
-            .parent
+            .parent()
             .and_then(|i| self.proto_array.nodes.get(i))
-            .map(|parent| parent.root);
+            .map(|parent| parent.root());
 
         Some(Block {
-            slot: block.slot,
-            root: block.root,
+            slot: block.slot(),
+            root: block.root(),
             parent_root,
-            state_root: block.state_root,
-            target_root: block.target_root,
-            current_epoch_shuffling_id: block.current_epoch_shuffling_id.clone(),
-            next_epoch_shuffling_id: block.next_epoch_shuffling_id.clone(),
-            justified_checkpoint: block.justified_checkpoint,
-            finalized_checkpoint: block.finalized_checkpoint,
-            execution_status: block.execution_status,
-            unrealized_justified_checkpoint: block.unrealized_justified_checkpoint,
-            unrealized_finalized_checkpoint: block.unrealized_finalized_checkpoint,
+            state_root: block.state_root(),
+            target_root: block.target_root(),
+            current_epoch_shuffling_id: block.current_epoch_shuffling_id().clone(),
+            next_epoch_shuffling_id: block.next_epoch_shuffling_id().clone(),
+            justified_checkpoint: *block.justified_checkpoint(),
+            finalized_checkpoint: *block.finalized_checkpoint(),
+            execution_status: block
+                .execution_status()
+                .unwrap_or_else(|_| ExecutionStatus::irrelevant()),
+            unrealized_justified_checkpoint: block.unrealized_justified_checkpoint(),
+            unrealized_finalized_checkpoint: block.unrealized_finalized_checkpoint(),
+            execution_payload_parent_hash: None,
+            execution_payload_block_hash: block.execution_payload_block_hash().ok(),
+            proposer_index: block.proposer_index().ok(),
         })
     }
 
     /// Returns the `block.execution_status` field, if the block is present.
     pub fn get_block_execution_status(&self, block_root: &Hash256) -> Option<ExecutionStatus> {
         let block = self.get_proto_node(block_root)?;
-        Some(block.execution_status)
+        block.execution_status().ok()
+    }
+
+    /// Returns whether the execution payload for a block has been received.
+    /// Returns `false` for pre-GLOAS (V17) nodes or unknown blocks.
+    pub fn is_payload_received(&self, block_root: &Hash256) -> bool {
+        self.get_proto_node(block_root)
+            .and_then(|node| node.payload_received().ok())
+            .unwrap_or(false)
     }
 
     /// Returns the weight of a given block.
@@ -888,7 +991,59 @@ impl ProtoArrayForkChoice {
         self.proto_array
             .nodes
             .get(*block_index)
-            .map(|node| node.weight)
+            .map(|node| node.weight())
+    }
+
+    /// Returns the payload status of the head node based on accumulated weights and tiebreaker.
+    ///
+    /// Returns `Full` if `full_payload_weight > empty_payload_weight`.
+    /// Returns `Empty` if `empty_payload_weight > full_payload_weight`.
+    /// On ties:
+    ///   - Previous slot (`slot + 1 == current_slot`): prefer Full only when timely and
+    ///     data available (per `should_extend_payload`).
+    ///   - Otherwise: prefer Full when payload has been received.
+    ///
+    /// Returns `None` for V17 nodes.
+    pub fn head_payload_status<E: EthSpec>(
+        &self,
+        head_root: &Hash256,
+        current_slot: Slot,
+    ) -> Option<PayloadStatus> {
+        let node = self.get_proto_node(head_root)?;
+        let v29 = node.as_v29().ok()?;
+
+        // Replicate the spec's virtual tree walk tiebreaker at the head node.
+        let use_tiebreaker_only = node.slot() + 1 == current_slot;
+
+        if !use_tiebreaker_only {
+            // Compare weights, then fall back to tiebreaker.
+            if v29.full_payload_weight > v29.empty_payload_weight {
+                return Some(PayloadStatus::Full);
+            } else if v29.empty_payload_weight > v29.full_payload_weight {
+                return Some(PayloadStatus::Empty);
+            }
+            // Equal weights: prefer FULL if payload received.
+            if v29.payload_received {
+                Some(PayloadStatus::Full)
+            } else {
+                Some(PayloadStatus::Empty)
+            }
+        } else {
+            // Previous slot: should_extend_payload tiebreaker.
+            if is_payload_timely(
+                &v29.payload_timeliness_votes,
+                E::ptc_size(),
+                v29.payload_received,
+            ) && is_payload_data_available(
+                &v29.payload_data_availability_votes,
+                E::ptc_size(),
+                v29.payload_received,
+            ) {
+                Some(PayloadStatus::Full)
+            } else {
+                Some(PayloadStatus::Empty)
+            }
+        }
     }
 
     /// See `ProtoArray` documentation.
@@ -907,14 +1062,18 @@ impl ProtoArrayForkChoice {
             .is_finalized_checkpoint_or_descendant::<E>(descendant_root, best_finalized_checkpoint)
     }
 
-    pub fn latest_message(&self, validator_index: usize) -> Option<(Hash256, Epoch)> {
+    pub fn latest_message(&self, validator_index: usize) -> Option<LatestMessage> {
         if validator_index < self.votes.0.len() {
             let vote = &self.votes.0[validator_index];
 
             if *vote == VoteTracker::default() {
                 None
             } else {
-                Some((vote.next_root, vote.next_epoch))
+                Some(LatestMessage {
+                    root: vote.next_root,
+                    slot: vote.next_slot,
+                    payload_present: vote.next_payload_present,
+                })
             }
         } else {
             None
@@ -934,21 +1093,12 @@ impl ProtoArrayForkChoice {
         self.proto_array.iter_block_roots(block_root)
     }
 
-    pub fn as_ssz_container(
-        &self,
-        justified_checkpoint: Checkpoint,
-        finalized_checkpoint: Checkpoint,
-    ) -> SszContainer {
-        SszContainer::from_proto_array(self, justified_checkpoint, finalized_checkpoint)
+    pub fn as_ssz_container(&self) -> SszContainer {
+        SszContainer::from_proto_array(self)
     }
 
-    pub fn as_bytes(
-        &self,
-        justified_checkpoint: Checkpoint,
-        finalized_checkpoint: Checkpoint,
-    ) -> Vec<u8> {
-        self.as_ssz_container(justified_checkpoint, finalized_checkpoint)
-            .as_ssz_bytes()
+    pub fn as_bytes(&self) -> Vec<u8> {
+        self.as_ssz_container().as_ssz_bytes()
     }
 
     pub fn from_bytes(bytes: &[u8], balances: JustifiedBalances) -> Result<Self, String> {
@@ -1002,12 +1152,27 @@ impl ProtoArrayForkChoice {
 ///   always valid).
 fn compute_deltas(
     indices: &HashMap<Hash256, usize>,
+    node_slots: &[Slot],
     votes: &mut ElasticList<VoteTracker>,
     old_balances: &[u64],
     new_balances: &[u64],
     equivocating_indices: &BTreeSet<u64>,
-) -> Result<Vec<i64>, Error> {
-    let mut deltas = vec![0_i64; indices.len()];
+) -> Result<Vec<NodeDelta>, Error> {
+    let block_slot = |index: usize| -> Result<Slot, Error> {
+        node_slots
+            .get(index)
+            .copied()
+            .ok_or(Error::InvalidNodeDelta(index))
+    };
+
+    let mut deltas = vec![
+        NodeDelta {
+            delta: 0,
+            empty_delta: 0,
+            full_delta: 0,
+        };
+        indices.len()
+    ];
 
     for (val_index, vote) in votes.iter_mut().enumerate() {
         // There is no need to create a score change if the validator has never voted or both their
@@ -1032,17 +1197,25 @@ fn compute_deltas(
                 let old_balance = old_balances.get(val_index).copied().unwrap_or(0);
 
                 if let Some(current_delta_index) = indices.get(&vote.current_root).copied() {
-                    let delta = deltas
-                        .get(current_delta_index)
-                        .ok_or(Error::InvalidNodeDelta(current_delta_index))?
+                    let node_delta = deltas
+                        .get_mut(current_delta_index)
+                        .ok_or(Error::InvalidNodeDelta(current_delta_index))?;
+                    node_delta.delta = node_delta
+                        .delta
                         .checked_sub(old_balance as i64)
                         .ok_or(Error::DeltaOverflow(current_delta_index))?;
 
-                    // Array access safe due to check on previous line.
-                    deltas[current_delta_index] = delta;
+                    let status = NodeDelta::payload_status(
+                        vote.current_slot,
+                        vote.current_payload_present,
+                        block_slot(current_delta_index)?,
+                    );
+                    node_delta.sub_payload_delta(status, old_balance, current_delta_index)?;
                 }
 
                 vote.current_root = Hash256::zero();
+                vote.current_slot = Slot::new(0);
+                vote.current_payload_present = false;
             }
             // We've handled this slashed validator, continue without applying an ordinary delta.
             continue;
@@ -1059,34 +1232,52 @@ fn compute_deltas(
         // on-boarded less validators than the prior fork.
         let new_balance = new_balances.get(val_index).copied().unwrap_or(0);
 
-        if vote.current_root != vote.next_root || old_balance != new_balance {
+        if vote.current_root != vote.next_root
+            || old_balance != new_balance
+            || vote.current_payload_present != vote.next_payload_present
+            || vote.current_slot != vote.next_slot
+        {
             // We ignore the vote if it is not known in `indices`. We assume that it is outside
             // of our tree (i.e., pre-finalization) and therefore not interesting.
             if let Some(current_delta_index) = indices.get(&vote.current_root).copied() {
-                let delta = deltas
-                    .get(current_delta_index)
-                    .ok_or(Error::InvalidNodeDelta(current_delta_index))?
+                let node_delta = deltas
+                    .get_mut(current_delta_index)
+                    .ok_or(Error::InvalidNodeDelta(current_delta_index))?;
+                node_delta.delta = node_delta
+                    .delta
                     .checked_sub(old_balance as i64)
                     .ok_or(Error::DeltaOverflow(current_delta_index))?;
 
-                // Array access safe due to check on previous line.
-                deltas[current_delta_index] = delta;
+                let status = NodeDelta::payload_status(
+                    vote.current_slot,
+                    vote.current_payload_present,
+                    block_slot(current_delta_index)?,
+                );
+                node_delta.sub_payload_delta(status, old_balance, current_delta_index)?;
             }
 
             // We ignore the vote if it is not known in `indices`. We assume that it is outside
             // of our tree (i.e., pre-finalization) and therefore not interesting.
             if let Some(next_delta_index) = indices.get(&vote.next_root).copied() {
-                let delta = deltas
-                    .get(next_delta_index)
-                    .ok_or(Error::InvalidNodeDelta(next_delta_index))?
+                let node_delta = deltas
+                    .get_mut(next_delta_index)
+                    .ok_or(Error::InvalidNodeDelta(next_delta_index))?;
+                node_delta.delta = node_delta
+                    .delta
                     .checked_add(new_balance as i64)
                     .ok_or(Error::DeltaOverflow(next_delta_index))?;
 
-                // Array access safe due to check on previous line.
-                deltas[next_delta_index] = delta;
+                let status = NodeDelta::payload_status(
+                    vote.next_slot,
+                    vote.next_payload_present,
+                    block_slot(next_delta_index)?,
+                );
+                node_delta.add_payload_delta(status, new_balance, next_delta_index)?;
             }
 
             vote.current_root = vote.next_root;
+            vote.current_slot = vote.next_slot;
+            vote.current_payload_present = vote.next_payload_present;
         }
     }
 
@@ -1104,8 +1295,13 @@ mod test_compute_deltas {
         Hash256::from_low_u64_be(i as u64 + 1)
     }
 
+    fn test_node_slots(count: usize) -> Vec<Slot> {
+        vec![Slot::new(0); count]
+    }
+
     #[test]
     fn finalized_descendant() {
+        let spec = MainnetEthSpec::default_spec();
         let genesis_slot = Slot::new(0);
         let genesis_epoch = Epoch::new(0);
 
@@ -1136,6 +1332,9 @@ mod test_compute_deltas {
             junk_shuffling_id.clone(),
             junk_shuffling_id.clone(),
             execution_status,
+            None,
+            None,
+            &spec,
         )
         .unwrap();
 
@@ -1152,13 +1351,17 @@ mod test_compute_deltas {
                     next_epoch_shuffling_id: junk_shuffling_id.clone(),
                     justified_checkpoint: genesis_checkpoint,
                     finalized_checkpoint: genesis_checkpoint,
-                    execution_status,
                     unrealized_justified_checkpoint: Some(genesis_checkpoint),
+                    execution_status,
                     unrealized_finalized_checkpoint: Some(genesis_checkpoint),
+                    execution_payload_parent_hash: None,
+                    execution_payload_block_hash: None,
+                    proposer_index: None,
                 },
                 genesis_slot + 1,
                 genesis_checkpoint,
                 genesis_checkpoint,
+                &spec,
             )
             .unwrap();
 
@@ -1180,10 +1383,14 @@ mod test_compute_deltas {
                     execution_status,
                     unrealized_justified_checkpoint: None,
                     unrealized_finalized_checkpoint: None,
+                    execution_payload_parent_hash: None,
+                    execution_payload_block_hash: None,
+                    proposer_index: None,
                 },
                 genesis_slot + 1,
                 genesis_checkpoint,
                 genesis_checkpoint,
+                &spec,
             )
             .unwrap();
 
@@ -1259,6 +1466,7 @@ mod test_compute_deltas {
     /// *checkpoint*, not just the finalized *block*.
     #[test]
     fn finalized_descendant_edge_case() {
+        let spec = MainnetEthSpec::default_spec();
         let get_block_root = Hash256::from_low_u64_be;
         let genesis_slot = Slot::new(0);
         let junk_state_root = Hash256::zero();
@@ -1280,6 +1488,9 @@ mod test_compute_deltas {
             junk_shuffling_id.clone(),
             junk_shuffling_id.clone(),
             execution_status,
+            None,
+            None,
+            &spec,
         )
         .unwrap();
 
@@ -1308,10 +1519,14 @@ mod test_compute_deltas {
                         execution_status,
                         unrealized_justified_checkpoint: Some(genesis_checkpoint),
                         unrealized_finalized_checkpoint: Some(genesis_checkpoint),
+                        execution_payload_parent_hash: None,
+                        execution_payload_block_hash: None,
+                        proposer_index: None,
                     },
                     Slot::from(block.slot),
                     genesis_checkpoint,
                     genesis_checkpoint,
+                    &spec,
                 )
                 .unwrap();
         };
@@ -1414,7 +1629,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: Hash256::zero(),
                 next_root: Hash256::zero(),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
             old_balances.push(0);
             new_balances.push(0);
@@ -1422,6 +1640,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1465,7 +1684,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: Hash256::zero(),
                 next_root: hash_from_index(0),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
             old_balances.push(BALANCE);
             new_balances.push(BALANCE);
@@ -1473,6 +1695,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1523,7 +1746,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: Hash256::zero(),
                 next_root: hash_from_index(i),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
             old_balances.push(BALANCE);
             new_balances.push(BALANCE);
@@ -1531,6 +1757,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1576,7 +1803,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: hash_from_index(0),
                 next_root: hash_from_index(1),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
             old_balances.push(BALANCE);
             new_balances.push(BALANCE);
@@ -1584,6 +1814,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1640,18 +1871,25 @@ mod test_compute_deltas {
         votes.0.push(VoteTracker {
             current_root: hash_from_index(1),
             next_root: Hash256::zero(),
-            next_epoch: Epoch::new(0),
+            current_slot: Slot::new(0),
+            next_slot: Slot::new(0),
+            current_payload_present: false,
+            next_payload_present: false,
         });
 
         // One validator moves their vote from the block to something outside the tree.
         votes.0.push(VoteTracker {
             current_root: hash_from_index(1),
             next_root: Hash256::from_low_u64_be(1337),
-            next_epoch: Epoch::new(0),
+            current_slot: Slot::new(0),
+            next_slot: Slot::new(0),
+            current_payload_present: false,
+            next_payload_present: false,
         });
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1693,7 +1931,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: hash_from_index(0),
                 next_root: hash_from_index(1),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
             old_balances.push(OLD_BALANCE);
             new_balances.push(NEW_BALANCE);
@@ -1701,6 +1942,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1762,12 +2004,16 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: hash_from_index(1),
                 next_root: hash_from_index(2),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
         }
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1818,12 +2064,16 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: hash_from_index(1),
                 next_root: hash_from_index(2),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
         }
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1872,7 +2122,10 @@ mod test_compute_deltas {
             votes.0.push(VoteTracker {
                 current_root: hash_from_index(1),
                 next_root: hash_from_index(2),
-                next_epoch: Epoch::new(0),
+                current_slot: Slot::new(0),
+                next_slot: Slot::new(0),
+                current_payload_present: false,
+                next_payload_present: false,
             });
         }
 
@@ -1881,6 +2134,7 @@ mod test_compute_deltas {
 
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &old_balances,
             &new_balances,
@@ -1910,6 +2164,7 @@ mod test_compute_deltas {
         // Re-computing the deltas should be a no-op (no repeat deduction for the slashed validator).
         let deltas = compute_deltas(
             &indices,
+            &test_node_slots(indices.len()),
             &mut votes,
             &new_balances,
             &new_balances,
@@ -1918,4 +2173,68 @@ mod test_compute_deltas {
         .expect("should compute deltas");
         assert_eq!(deltas, vec![0, 0]);
     }
+
+    #[test]
+    fn payload_bucket_changes_on_non_pending_vote() {
+        const BALANCE: u64 = 42;
+
+        let mut indices = HashMap::new();
+        indices.insert(hash_from_index(1), 0);
+
+        let node_slots = vec![Slot::new(0)];
+        let mut votes = ElasticList(vec![VoteTracker {
+            current_root: hash_from_index(1),
+            next_root: hash_from_index(1),
+            current_slot: Slot::new(1),
+            next_slot: Slot::new(1),
+            current_payload_present: false,
+            next_payload_present: true,
+        }]);
+
+        let deltas = compute_deltas(
+            &indices,
+            &node_slots,
+            &mut votes,
+            &[BALANCE],
+            &[BALANCE],
+            &BTreeSet::new(),
+        )
+        .expect("should compute deltas");
+
+        assert_eq!(deltas[0].delta, 0);
+        assert_eq!(deltas[0].empty_delta, -(BALANCE as i64));
+        assert_eq!(deltas[0].full_delta, BALANCE as i64);
+    }
+
+    #[test]
+    fn pending_vote_only_updates_regular_weight() {
+        const BALANCE: u64 = 42;
+
+        let mut indices = HashMap::new();
+        indices.insert(hash_from_index(1), 0);
+
+        let node_slots = vec![Slot::new(0)];
+        let mut votes = ElasticList(vec![VoteTracker {
+            current_root: hash_from_index(1),
+            next_root: hash_from_index(1),
+            current_slot: Slot::new(0),
+            next_slot: Slot::new(0),
+            current_payload_present: false,
+            next_payload_present: true,
+        }]);
+
+        let deltas = compute_deltas(
+            &indices,
+            &node_slots,
+            &mut votes,
+            &[BALANCE],
+            &[BALANCE],
+            &BTreeSet::new(),
+        )
+        .expect("should compute deltas");
+
+        assert_eq!(deltas[0].delta, 0);
+        assert_eq!(deltas[0].empty_delta, 0);
+        assert_eq!(deltas[0].full_delta, 0);
+    }
 }
diff --git a/consensus/proto_array/src/ssz_container.rs b/consensus/proto_array/src/ssz_container.rs
index 1e01b74c8cd..664dfe3ceba 100644
--- a/consensus/proto_array/src/ssz_container.rs
+++ b/consensus/proto_array/src/ssz_container.rs
@@ -1,29 +1,24 @@
 use crate::proto_array::ProposerBoost;
 use crate::{
     Error, JustifiedBalances,
-    proto_array::{ProtoArray, ProtoNodeV17},
+    proto_array::{ProtoArray, ProtoNode, ProtoNodeV17},
     proto_array_fork_choice::{ElasticList, ProtoArrayForkChoice, VoteTracker},
 };
 use ssz::{Encode, four_byte_option_impl};
 use ssz_derive::{Decode, Encode};
 use std::collections::HashMap;
-use superstruct::superstruct;
 use types::{Checkpoint, Hash256};
 
 // Define a "legacy" implementation of `Option<usize>` which uses four bytes for encoding the union
 // selector.
 four_byte_option_impl!(four_byte_option_checkpoint, Checkpoint);
 
-pub type SszContainer = SszContainerV28;
+pub type SszContainer = SszContainerV29;
 
-#[superstruct(
-    variants(V17, V28),
-    variant_attributes(derive(Encode, Decode, Clone)),
-    no_enum
-)]
-pub struct SszContainer {
+/// Proto-array container introduced in schema V17.
+#[derive(Encode, Decode, Clone)]
+pub struct SszContainerV17 {
     pub votes: Vec<VoteTracker>,
-    #[superstruct(only(V17))]
     pub balances: Vec<u64>,
     pub prune_threshold: usize,
     // Deprecated, remove in a future schema migration
@@ -35,19 +30,37 @@ pub struct SszContainer {
     pub previous_proposer_boost: ProposerBoost,
 }
 
-impl SszContainer {
-    pub fn from_proto_array(
-        from: &ProtoArrayForkChoice,
-        justified_checkpoint: Checkpoint,
-        finalized_checkpoint: Checkpoint,
-    ) -> Self {
+/// Proto-array container introduced in schema V28.
+#[derive(Encode, Decode, Clone)]
+pub struct SszContainerV28 {
+    pub votes: Vec<VoteTracker>,
+    pub prune_threshold: usize,
+    // Deprecated, remove in a future schema migration
+    justified_checkpoint: Checkpoint,
+    // Deprecated, remove in a future schema migration
+    finalized_checkpoint: Checkpoint,
+    pub nodes: Vec<ProtoNodeV17>,
+    pub indices: Vec<(Hash256, usize)>,
+    pub previous_proposer_boost: ProposerBoost,
+}
+
+/// Current container version. Uses union-encoded `ProtoNode` to support mixed V17/V29 nodes.
+#[derive(Encode, Decode, Clone)]
+pub struct SszContainerV29 {
+    pub votes: Vec<VoteTracker>,
+    pub prune_threshold: usize,
+    pub nodes: Vec<ProtoNode>,
+    pub indices: Vec<(Hash256, usize)>,
+    pub previous_proposer_boost: ProposerBoost,
+}
+
+impl SszContainerV29 {
+    pub fn from_proto_array(from: &ProtoArrayForkChoice) -> Self {
         let proto_array = &from.proto_array;
 
         Self {
             votes: from.votes.0.clone(),
             prune_threshold: proto_array.prune_threshold,
-            justified_checkpoint,
-            finalized_checkpoint,
             nodes: proto_array.nodes.clone(),
             indices: proto_array.indices.iter().map(|(k, v)| (*k, *v)).collect(),
             previous_proposer_boost: proto_array.previous_proposer_boost,
@@ -55,10 +68,10 @@ impl SszContainer {
     }
 }
 
-impl TryFrom<(SszContainer, JustifiedBalances)> for ProtoArrayForkChoice {
+impl TryFrom<(SszContainerV29, JustifiedBalances)> for ProtoArrayForkChoice {
     type Error = Error;
 
-    fn try_from((from, balances): (SszContainer, JustifiedBalances)) -> Result<Self, Error> {
+    fn try_from((from, balances): (SszContainerV29, JustifiedBalances)) -> Result<Self, Error> {
         let proto_array = ProtoArray {
             prune_threshold: from.prune_threshold,
             nodes: from.nodes,
@@ -74,7 +87,7 @@ impl TryFrom<(SszContainer, JustifiedBalances)> for ProtoArrayForkChoice {
     }
 }
 
-// Convert V17 to V28 by dropping balances.
+// Convert legacy V17 to V28 by dropping balances.
 impl From<SszContainerV17> for SszContainerV28 {
     fn from(v17: SszContainerV17) -> Self {
         Self {
@@ -89,7 +102,7 @@ impl From<SszContainerV17> for SszContainerV28 {
     }
 }
 
-// Convert V28 to V17 by re-adding balances.
+// Convert legacy V28 to V17 by re-adding balances.
 impl From<(SszContainerV28, JustifiedBalances)> for SszContainerV17 {
     fn from((v28, balances): (SszContainerV28, JustifiedBalances)) -> Self {
         Self {
@@ -104,3 +117,40 @@ impl From<(SszContainerV28, JustifiedBalances)> for SszContainerV17 {
         }
     }
 }
+
+// Convert legacy V28 to current V29.
+impl From<SszContainerV28> for SszContainerV29 {
+    fn from(v28: SszContainerV28) -> Self {
+        Self {
+            votes: v28.votes,
+            prune_threshold: v28.prune_threshold,
+            nodes: v28.nodes.into_iter().map(ProtoNode::V17).collect(),
+            indices: v28.indices,
+            previous_proposer_boost: v28.previous_proposer_boost,
+        }
+    }
+}
+
+// Downgrade current V29 to legacy V28 (lossy: V29 nodes lose payload-specific fields).
+impl From<SszContainerV29> for SszContainerV28 {
+    fn from(v29: SszContainerV29) -> Self {
+        Self {
+            votes: v29.votes,
+            prune_threshold: v29.prune_threshold,
+            // These checkpoints are not consumed in v28 paths since the upgrade from v17,
+            // we can safely default the values.
+            justified_checkpoint: Checkpoint::default(),
+            finalized_checkpoint: Checkpoint::default(),
+            nodes: v29
+                .nodes
+                .into_iter()
+                .filter_map(|node| match node {
+                    ProtoNode::V17(v17) => Some(v17),
+                    ProtoNode::V29(_) => None,
+                })
+                .collect(),
+            indices: v29.indices,
+            previous_proposer_boost: v29.previous_proposer_boost,
+        }
+    }
+}
diff --git a/testing/ef_tests/src/cases/fork_choice.rs b/testing/ef_tests/src/cases/fork_choice.rs
index 07a7d4c6b6c..a1c93d65bb1 100644
--- a/testing/ef_tests/src/cases/fork_choice.rs
+++ b/testing/ef_tests/src/cases/fork_choice.rs
@@ -30,7 +30,8 @@ use types::{
     Attestation, AttestationRef, AttesterSlashing, AttesterSlashingRef, BeaconBlock, BeaconState,
     BlobSidecar, BlobsList, BlockImportSource, Checkpoint, DataColumnSidecar,
     DataColumnSidecarList, DataColumnSubnetId, ExecutionBlockHash, Hash256, IndexedAttestation,
-    KzgProof, ProposerPreparationData, SignedBeaconBlock, Slot, Uint256,
+    KzgProof, ProposerPreparationData, SignedBeaconBlock, SignedExecutionPayloadEnvelope, Slot,
+    Uint256,
 };
 
 // When set to true, cache any states fetched from the db.
@@ -72,6 +73,7 @@ pub struct Checks {
     proposer_boost_root: Option<Hash256>,
     get_proposer_head: Option<Hash256>,
     should_override_forkchoice_update: Option<ShouldOverrideFcu>,
+    head_payload_status: Option<u8>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -94,7 +96,15 @@ impl From<PayloadStatus> for PayloadStatusV1 {
 
 #[derive(Debug, Clone, Deserialize)]
 #[serde(untagged, deny_unknown_fields)]
-pub enum Step<TBlock, TBlobs, TColumns, TAttestation, TAttesterSlashing, TPowBlock> {
+pub enum Step<
+    TBlock,
+    TBlobs,
+    TColumns,
+    TAttestation,
+    TAttesterSlashing,
+    TPowBlock,
+    TExecutionPayload = String,
+> {
     Tick {
         tick: u64,
     },
@@ -128,6 +138,10 @@ pub enum Step<TBlock, TBlobs, TColumns, TAttestation, TAttesterSlashing, TPowBlo
         columns: Option<TColumns>,
         valid: bool,
     },
+    OnExecutionPayload {
+        execution_payload: TExecutionPayload,
+        valid: bool,
+    },
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -151,6 +165,7 @@ pub struct ForkChoiceTest<E: EthSpec> {
             Attestation<E>,
             AttesterSlashing<E>,
             PowBlock,
+            SignedExecutionPayloadEnvelope<E>,
         >,
     >,
 }
@@ -271,6 +286,17 @@ impl<E: EthSpec> LoadCase for ForkChoiceTest<E> {
                         valid,
                     })
                 }
+                Step::OnExecutionPayload {
+                    execution_payload,
+                    valid,
+                } => {
+                    let envelope =
+                        ssz_decode_file(&path.join(format!("{execution_payload}.ssz_snappy")))?;
+                    Ok(Step::OnExecutionPayload {
+                        execution_payload: envelope,
+                        valid,
+                    })
+                }
             })
             .collect::<Result<_, _>>()?;
         let anchor_state = ssz_decode_state(&path.join("anchor_state.ssz_snappy"), spec)?;
@@ -359,6 +385,7 @@ impl<E: EthSpec> Case for ForkChoiceTest<E> {
                         proposer_boost_root,
                         get_proposer_head,
                         should_override_forkchoice_update: should_override_fcu,
+                        head_payload_status,
                     } = checks.as_ref();
 
                     if let Some(expected_head) = head {
@@ -405,6 +432,10 @@ impl<E: EthSpec> Case for ForkChoiceTest<E> {
                     if let Some(expected_proposer_head) = get_proposer_head {
                         tester.check_expected_proposer_head(*expected_proposer_head)?;
                     }
+
+                    if let Some(expected_status) = head_payload_status {
+                        tester.check_head_payload_status(*expected_status)?;
+                    }
                 }
 
                 Step::MaybeValidBlockAndColumns {
@@ -414,6 +445,13 @@ impl<E: EthSpec> Case for ForkChoiceTest<E> {
                 } => {
                     tester.process_block_and_columns(block.clone(), columns.clone(), *valid)?;
                 }
+                Step::OnExecutionPayload {
+                    execution_payload,
+                    valid,
+                } => {
+                    tester
+                        .process_execution_payload(execution_payload.beacon_block_root(), *valid)?;
+                }
             }
         }
 
@@ -584,6 +622,18 @@ impl<E: EthSpec> Tester<E> {
             self.apply_invalid_block(&block)?;
         }
 
+        // Per spec test runner: an on_block step implies receiving block's attestations
+        // and attester slashings.
+        if success {
+            for attestation in block.message().body().attestations() {
+                let att = attestation.clone_as_attestation();
+                let _ = self.process_attestation(&att);
+            }
+            for attester_slashing in block.message().body().attester_slashings() {
+                self.process_attester_slashing(attester_slashing);
+            }
+        }
+
         Ok(())
     }
 
@@ -674,6 +724,18 @@ impl<E: EthSpec> Tester<E> {
             self.apply_invalid_block(&block)?;
         }
 
+        // Per spec test runner: an on_block step implies receiving block's attestations
+        // and attester slashings.
+        if success {
+            for attestation in block.message().body().attestations() {
+                let att = attestation.clone_as_attestation();
+                let _ = self.process_attestation(&att);
+            }
+            for attester_slashing in block.message().body().attester_slashings() {
+                self.process_attester_slashing(attester_slashing);
+            }
+        }
+
         Ok(())
     }
 
@@ -923,7 +985,7 @@ impl<E: EthSpec> Tester<E> {
             DEFAULT_RE_ORG_MAX_EPOCHS_SINCE_FINALIZATION,
         );
         let proposer_head = match proposer_head_result {
-            Ok(head) => head.parent_node.root,
+            Ok(head) => head.parent_node.root(),
             Err(ProposerHeadError::DoNotReOrg(_)) => canonical_head,
             _ => panic!("Unexpected error in get proposer head"),
         };
@@ -931,6 +993,50 @@ impl<E: EthSpec> Tester<E> {
         check_equal("proposer_head", proposer_head, expected_proposer_head)
     }
 
+    pub fn process_execution_payload(&self, block_root: Hash256, valid: bool) -> Result<(), Error> {
+        let result = self
+            .harness
+            .chain
+            .canonical_head
+            .fork_choice_write_lock()
+            .on_execution_payload(block_root);
+
+        if valid {
+            result.map_err(|e| {
+                Error::InternalError(format!(
+                    "on_execution_payload for block root {} failed: {:?}",
+                    block_root, e
+                ))
+            })?;
+        } else if result.is_ok() {
+            return Err(Error::DidntFail(format!(
+                "on_execution_payload for block root {} should have failed",
+                block_root
+            )));
+        }
+
+        Ok(())
+    }
+
+    pub fn check_head_payload_status(&self, expected_status: u8) -> Result<(), Error> {
+        let head = self.find_head()?;
+        let head_root = head.head_block_root();
+        let current_slot = self.harness.chain.slot().map_err(|e| {
+            Error::InternalError(format!("reading current slot failed with {:?}", e))
+        })?;
+        let fc = self.harness.chain.canonical_head.fork_choice_read_lock();
+        let actual_status = fc
+            .proto_array()
+            .head_payload_status::<E>(&head_root, current_slot)
+            .ok_or_else(|| {
+                Error::InternalError(format!(
+                    "head_payload_status not found for head root {}",
+                    head_root
+                ))
+            })?;
+        check_equal("head_payload_status", actual_status as u8, expected_status)
+    }
+
     pub fn check_should_override_fcu(
         &self,
         expected_should_override_fcu: ShouldOverrideFcu,
diff --git a/testing/ef_tests/src/handler.rs b/testing/ef_tests/src/handler.rs
index f8c16aec0be..4373d6b7d19 100644
--- a/testing/ef_tests/src/handler.rs
+++ b/testing/ef_tests/src/handler.rs
@@ -704,15 +704,27 @@ impl<E: EthSpec + TypeName> Handler for ForkChoiceHandler<E> {
             return false;
         }
 
-        // No FCU override tests prior to bellatrix.
+        // No FCU override tests prior to bellatrix, and removed in Gloas.
         if self.handler_name == "should_override_forkchoice_update"
-            && !fork_name.bellatrix_enabled()
+            && (!fork_name.bellatrix_enabled() || fork_name.gloas_enabled())
         {
             return false;
         }
 
-        // Deposit tests exist only after Electra.
-        if self.handler_name == "deposit_with_reorg" && !fork_name.electra_enabled() {
+        // Deposit tests exist only for Electra and Fulu (not Gloas).
+        if self.handler_name == "deposit_with_reorg"
+            && (!fork_name.electra_enabled() || fork_name.gloas_enabled())
+        {
+            return false;
+        }
+
+        // Proposer head tests removed in Gloas.
+        if self.handler_name == "get_proposer_head" && fork_name.gloas_enabled() {
+            return false;
+        }
+
+        // on_execution_payload tests exist only for Gloas.
+        if self.handler_name == "on_execution_payload" && !fork_name.gloas_enabled() {
             return false;
         }
 
@@ -722,8 +734,7 @@ impl<E: EthSpec + TypeName> Handler for ForkChoiceHandler<E> {
     }
 
     fn disabled_forks(&self) -> Vec<ForkName> {
-        // TODO(gloas): remove once we have Gloas fork choice tests
-        vec![ForkName::Gloas]
+        vec![]
     }
 }
 
diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs
index 3893df2ef74..cb4abed90ab 100644
--- a/testing/ef_tests/tests/tests.rs
+++ b/testing/ef_tests/tests/tests.rs
@@ -1032,6 +1032,12 @@ fn fork_choice_deposit_with_reorg() {
     // There is no mainnet variant for this test.
 }
 
+#[test]
+fn fork_choice_on_execution_payload() {
+    ForkChoiceHandler::<MinimalEthSpec>::new("on_execution_payload").run();
+    ForkChoiceHandler::<MainnetEthSpec>::new("on_execution_payload").run();
+}
+
 #[test]
 fn optimistic_sync() {
     OptimisticSyncHandler::<MinimalEthSpec>::default().run();