diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index d8be9d6ac2..d276fbc15e 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -4324,7 +4324,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         };
 
         // Read the cached head prior to taking the fork choice lock to avoid potential deadlocks.
-        let old_head_slot = self.canonical_head.cached_head().head_slot();
+        let cached_head = self.canonical_head.cached_head();
+        let old_head_slot = cached_head.head_slot();
+
+        // Compute the expected proposer for `current_slot` on the canonical chain. This is used by
+        // `on_block` to gate proposer boost on the block's proposer matching the canonical proposer
+        // (per spec `update_proposer_boost_root` added in v1.7.0-alpha.5).
+        let canonical_head_proposer_index =
+            self.canonical_head_proposer_index(current_slot, &cached_head)?;
 
         // Take an upgradable read lock on fork choice so we can check if this block has already
         // been imported. We don't want to repeat work importing a block that is already imported.
@@ -4357,6 +4364,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     block_delay,
                     &state,
                     payload_verification_status,
+                    canonical_head_proposer_index,
                     &self.spec,
                 )
                 .map_err(|e| BlockError::BeaconChainError(Box::new(e.into())))?;
@@ -5099,6 +5107,42 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         }))
     }
 
+    /// Compute the expected beacon proposer for `slot` on the canonical chain extending `cached_head`.
+    ///
+    /// Uses the beacon proposer cache to avoid recomputing the shuffling on every block import.
+    ///
+    /// This is used by `update_proposer_boost_root` to gate proposer boost on the block's proposer
+    /// matching the canonical proposer, per consensus-specs v1.7.0-alpha.5.
+    ///
+    /// This function should never error unless there is some corruption of the head state. If a
+    /// state advance is needed, it will be handled by the proposer cache.
+    pub fn canonical_head_proposer_index(
+        &self,
+        slot: Slot,
+        cached_head: &CachedHead<T::EthSpec>,
+    ) -> Result<u64, Error> {
+        let proposal_epoch = slot.epoch(T::EthSpec::slots_per_epoch());
+        let head_block_root = cached_head.head_block_root();
+        let head_state = &cached_head.snapshot.beacon_state;
+
+        let shuffling_decision_root = head_state.proposer_shuffling_decision_root_at_epoch(
+            proposal_epoch,
+            head_block_root,
+            &self.spec,
+        )?;
+
+        self.with_proposer_cache::<_, Error>(
+            shuffling_decision_root,
+            proposal_epoch,
+            |proposers| {
+                proposers
+                    .get_slot::<T::EthSpec>(slot)
+                    .map(|p| p.index as u64)
+            },
+            || Ok((cached_head.head_state_root(), head_state.clone())),
+        )
+    }
+
     pub fn get_expected_withdrawals(
         &self,
         forkchoice_update_params: &ForkchoiceUpdateParameters,
@@ -5172,11 +5216,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             }
             .ok_or(Error::MissingExecutionPayloadEnvelope(parent_block_root))?;
 
-            let parent_bid = advanced_state.latest_execution_payload_bid()?.clone();
-
             apply_parent_execution_payload(
                 &mut advanced_state,
-                &parent_bid,
                 &envelope.message.execution_requests,
                 &self.spec,
             )
diff --git a/beacon_node/beacon_chain/src/block_production/gloas.rs b/beacon_node/beacon_chain/src/block_production/gloas.rs
index 79ea78ce4a..6510c20ba7 100644
--- a/beacon_node/beacon_chain/src/block_production/gloas.rs
+++ b/beacon_node/beacon_chain/src/block_production/gloas.rs
@@ -78,6 +78,16 @@ pub struct ExecutionPayloadData<E: types::EthSpec> {
     pub blobs_and_proofs: (types::BlobsList<E>, types::KzgProofs<E>),
 }
 
+/// The result of a local payload build, used to decide whether to include a builder bid
+/// from the gossip cache or fall back to self-build.
+pub struct LocalBuildResult<E: EthSpec> {
+    pub payload_data: ExecutionPayloadData<E>,
+    /// EL block value (in wei) of the locally-built payload.
+    pub payload_value: types::Uint256,
+    /// `true` if the EL signaled `engine_getPayload`'s `shouldOverrideBuilder` flag.
+    pub should_override_builder: bool,
+}
+
 impl<T: BeaconChainTypes> BeaconChain<T> {
     pub async fn produce_block_with_verification_gloas(
         self: &Arc<Self>,
@@ -85,7 +95,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         slot: Slot,
         graffiti_settings: GraffitiSettings,
         verification: ProduceBlockVerification,
-        _builder_boost_factor: Option<u64>,
+        builder_boost_factor: Option<u64>,
     ) -> Result<BlockProductionResult<T::EthSpec>, BlockProductionError> {
         metrics::inc_counter(&metrics::BLOCK_PRODUCTION_REQUESTS);
         let _complete_timer = metrics::start_timer(&metrics::BLOCK_PRODUCTION_TIMES);
@@ -121,11 +131,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             randao_reveal,
             graffiti_settings,
             verification,
+            builder_boost_factor,
         )
         .await
     }
 
-    // TODO(gloas) need to implement builder boost factor logic
     #[instrument(level = "debug", skip_all)]
     #[allow(clippy::too_many_arguments)]
     pub async fn produce_block_on_state_gloas(
@@ -138,6 +148,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         randao_reveal: Signature,
         graffiti_settings: GraffitiSettings,
         verification: ProduceBlockVerification,
+        builder_boost_factor: Option<u64>,
     ) -> Result<BlockProductionResult<T::EthSpec>, BlockProductionError> {
         // Extract the parent's execution requests from the envelope (if parent was full).
         let parent_execution_requests = if parent_payload_status == PayloadStatus::Full {
@@ -179,10 +190,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         // Part 2/3 (async)
         //
-        // Produce the execution payload bid.
-        // TODO(gloas) this is strictly for building local bids
-        // We'll need to build out trustless/trusted bid paths.
-        let (execution_payload_bid, state, payload_data) = self
+        // Produce a local execution payload bid, then select between it and any cached
+        // gossip-verified builder bid using `builder_boost_factor`.
+        // TODO(gloas) build out trustless/trusted bid paths.
+        let (local_signed_bid, state, local_build) = self
             .clone()
             .produce_execution_payload_bid(
                 state,
@@ -194,6 +205,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             )
             .await?;
 
+        let (execution_payload_bid, payload_data) =
+            self.select_payload_bid(local_signed_bid, local_build, builder_boost_factor);
+
         // Part 3/3 (blocking)
         //
         // Complete the block with the execution payload bid.
@@ -623,11 +637,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // For trustless building, the builder will provide the envelope separately.
         if let Some(payload_data) = payload_data {
             let beacon_block_root = block.tree_hash_root();
+            let parent_beacon_block_root = block.parent_root();
             let execution_payload_envelope = ExecutionPayloadEnvelope {
                 payload: payload_data.payload,
                 execution_requests: payload_data.execution_requests,
                 builder_index: payload_data.builder_index,
                 beacon_block_root,
+                parent_beacon_block_root,
             };
 
             let signed_envelope = SignedExecutionPayloadEnvelope {
@@ -677,16 +693,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         Ok((block, state, consensus_block_value))
     }
 
-    // TODO(gloas) introduce `ProposerPreferences` so we can build out trustless
-    // bid building. Right now this only works for local building.
-    /// Produce an `ExecutionPayloadBid` for some `slot` upon the given `state`.
+    /// Produce a self-build `ExecutionPayloadBid` for some `slot` upon the given `state`.
     /// This function assumes we've already advanced `state`.
     ///
-    /// Returns the signed bid, the state, and optionally the payload data needed to construct
-    /// the `ExecutionPayloadEnvelope` after the beacon block is created.
-    ///
-    /// For local building, payload data is always returned (`Some`).
-    /// For trustless building, the builder provides the envelope separately, so `None` is returned.
+    /// Returns the signed bid, the state, and a `LocalBuildResult` carrying the payload
+    /// data needed to construct the `ExecutionPayloadEnvelope` after the beacon block is
+    /// created, plus the EL block value and `should_override_builder` flag used by the
+    /// caller to compare against any cached p2p builder bid.
     #[allow(clippy::type_complexity)]
     #[instrument(level = "debug", skip_all)]
     pub async fn produce_execution_payload_bid(
@@ -701,7 +714,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         (
             SignedExecutionPayloadBid<T::EthSpec>,
             BeaconState<T::EthSpec>,
-            Option<ExecutionPayloadData<T::EthSpec>>,
+            LocalBuildResult<T::EthSpec>,
         ),
         BlockProductionError,
     > {
@@ -773,10 +786,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         let BlockProposalContentsGloas {
             payload,
-            payload_value: _,
+            payload_value,
             execution_requests,
             blob_kzg_commitments,
             blobs_and_proofs,
+            should_override_builder,
         } = block_proposal_contents;
 
         // TODO(gloas) since we are defaulting to local building, execution payment is 0
@@ -805,19 +819,115 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             blobs_and_proofs,
         };
 
-        // TODO(gloas) this is only local building
-        // we'll need to implement builder signature for the trustless path
         Ok((
             SignedExecutionPayloadBid {
                 message: bid,
                 signature: Signature::infinity().map_err(BlockProductionError::BlsError)?,
             },
             state,
-            // Local building always returns payload data.
-            // Trustless building would return None here.
-            Some(payload_data),
+            LocalBuildResult {
+                payload_data,
+                payload_value,
+                should_override_builder,
+            },
         ))
     }
+
+    /// Look up the highest gossip-verified bid for the `(slot, parent_block_hash,
+    /// parent_block_root)` of the local bid, then choose the winner.
+    fn select_payload_bid(
+        &self,
+        local_signed_bid: SignedExecutionPayloadBid<T::EthSpec>,
+        local_build: LocalBuildResult<T::EthSpec>,
+        builder_boost_factor: Option<u64>,
+    ) -> (
+        SignedExecutionPayloadBid<T::EthSpec>,
+        Option<ExecutionPayloadData<T::EthSpec>>,
+    ) {
+        let cached_bid = self.gossip_verified_payload_bid_cache.get_highest_bid(
+            local_signed_bid.message.slot,
+            local_signed_bid.message.parent_block_hash,
+            local_signed_bid.message.parent_block_root,
+        );
+        select_payload_bid_pure(
+            local_signed_bid,
+            local_build,
+            cached_bid,
+            builder_boost_factor,
+        )
+    }
+}
+
+/// Pure local-vs-cached selection logic, factored out for unit testing.
+///
+/// Selection rule (mirrors the pre-Gloas builder/local race in `execution_layer`):
+///   - `boosted_bid = (cached_bid.value / 100) * builder_boost_factor`  (raw value when `None`)
+///   - if `local_value_wei >= boosted_bid_wei` → keep local
+///   - if the EL signaled `should_override_builder` → keep local
+///   - otherwise → use the cached builder bid and drop local payload data
+///     (the builder is responsible for revealing the envelope).
+///
+/// `cached_bid.value` is in gwei (`u64`); `payload_value` is in wei (`Uint256`); compared in wei.
+pub(crate) fn select_payload_bid_pure<E: EthSpec>(
+    local_signed_bid: SignedExecutionPayloadBid<E>,
+    local_build: LocalBuildResult<E>,
+    cached_bid: Option<Arc<SignedExecutionPayloadBid<E>>>,
+    builder_boost_factor: Option<u64>,
+) -> (
+    SignedExecutionPayloadBid<E>,
+    Option<ExecutionPayloadData<E>>,
+) {
+    let LocalBuildResult {
+        payload_data,
+        payload_value,
+        should_override_builder,
+    } = local_build;
+
+    let Some(cached_bid) = cached_bid else {
+        return (local_signed_bid, Some(payload_data));
+    };
+
+    let slot = local_signed_bid.message.slot;
+
+    if should_override_builder {
+        debug!(
+            %slot,
+            cached_bid_value = cached_bid.message.value,
+            "Using local payload because EL signaled shouldOverrideBuilder"
+        );
+        return (local_signed_bid, Some(payload_data));
+    }
+
+    // Convert bid value (gwei) to wei for comparison with `payload_value` (wei).
+    let bid_value_wei = types::Uint256::from(cached_bid.message.value)
+        .saturating_mul(types::Uint256::from(1_000_000_000u64));
+    let boosted_bid_wei = match builder_boost_factor {
+        Some(factor) => {
+            (bid_value_wei / types::Uint256::from(100)).saturating_mul(types::Uint256::from(factor))
+        }
+        None => bid_value_wei,
+    };
+
+    if payload_value >= boosted_bid_wei {
+        debug!(
+            %slot,
+            %payload_value,
+            cached_bid_value_gwei = cached_bid.message.value,
+            ?builder_boost_factor,
+            "Local payload is more profitable than cached builder bid"
+        );
+        (local_signed_bid, Some(payload_data))
+    } else {
+        debug!(
+            %slot,
+            %payload_value,
+            cached_bid_value_gwei = cached_bid.message.value,
+            cached_bid_builder_index = cached_bid.message.builder_index,
+            ?builder_boost_factor,
+            "Including cached builder bid"
+        );
+        ((*cached_bid).clone(), None)
+    }
 }
 
 /// Gets an execution payload for inclusion in a block.
@@ -854,7 +964,6 @@ fn get_execution_payload_gloas<T: BeaconChainTypes>(
             let mut withdrawals_state = state.clone();
             apply_parent_execution_payload(
                 &mut withdrawals_state,
-                parent_bid,
                 &envelope.message.execution_requests,
                 spec,
             )?;
@@ -1150,4 +1259,111 @@ mod tests {
 
         assert_eq!(exits.len(), 2);
     }
+
+    // ---- select_payload_bid_pure ----
+
+    const REMOTE_BUILDER: BuilderIndex = 999;
+
+    fn gwei(n: u64) -> types::Uint256 {
+        types::Uint256::from(n).saturating_mul(types::Uint256::from(1_000_000_000u64))
+    }
+
+    fn local_bid() -> SignedExecutionPayloadBid<TestSpec> {
+        SignedExecutionPayloadBid {
+            message: ExecutionPayloadBid {
+                builder_index: BUILDER_INDEX_SELF_BUILD,
+                ..Default::default()
+            },
+            signature: Signature::empty(),
+        }
+    }
+
+    fn cached_bid(value_gwei: u64) -> Arc<SignedExecutionPayloadBid<TestSpec>> {
+        Arc::new(SignedExecutionPayloadBid {
+            message: ExecutionPayloadBid {
+                builder_index: REMOTE_BUILDER,
+                value: value_gwei,
+                ..Default::default()
+            },
+            signature: Signature::empty(),
+        })
+    }
+
+    fn local_build(payload_gwei: u64, should_override_builder: bool) -> LocalBuildResult<TestSpec> {
+        LocalBuildResult {
+            payload_data: ExecutionPayloadData {
+                payload: types::ExecutionPayloadGloas::default(),
+                execution_requests: ExecutionRequests::default(),
+                builder_index: BUILDER_INDEX_SELF_BUILD,
+                slot: Slot::new(0),
+                blobs_and_proofs: (VariableList::empty(), VariableList::empty()),
+            },
+            payload_value: gwei(payload_gwei),
+            should_override_builder,
+        }
+    }
+
+    const LOCAL: BuilderIndex = BUILDER_INDEX_SELF_BUILD;
+    const REMOTE: BuilderIndex = REMOTE_BUILDER;
+
+    /// Run `select_payload_bid_pure` and return `(winning_builder_index, has_payload_data)`.
+    ///
+    /// Args (positional, mirror `select_payload_bid_pure`):
+    ///   - `local_payload_gwei`: local payload value, in gwei.
+    ///   - `should_override`:    EL's `shouldOverrideBuilder` flag.
+    ///   - `cached_gwei`:        `Some(g)` ⇒ seed the cache with a bid of `g` gwei.
+    ///   - `boost`:              `None` = neutral, `Some(0)` = always local, `Some(>100)` = boost bid.
+    fn pick(
+        local_payload_gwei: u64,
+        should_override: bool,
+        cached_gwei: Option<u64>,
+        boost: Option<u64>,
+    ) -> (BuilderIndex, bool) {
+        let build = local_build(local_payload_gwei, should_override);
+        let cache = cached_gwei.map(cached_bid);
+        let (out, data) = select_payload_bid_pure::<TestSpec>(local_bid(), build, cache, boost);
+        (out.message.builder_index, data.is_some())
+    }
+
+    #[test]
+    fn select_empty_cache_keeps_local() {
+        assert_eq!(pick(0, false, None, Some(u64::MAX)), (LOCAL, true));
+    }
+
+    #[test]
+    fn select_el_override_beats_any_cached_bid() {
+        // `shouldOverrideBuilder` short-circuits regardless of cache or boost.
+        assert_eq!(pick(0, true, Some(u64::MAX), Some(u64::MAX)), (LOCAL, true));
+    }
+
+    #[test]
+    fn select_boost_zero_always_keeps_local() {
+        // boost=0 deflates the bid to 0 ⇒ local always wins.
+        assert_eq!(pick(0, false, Some(u64::MAX), Some(0)), (LOCAL, true));
+    }
+
+    #[test]
+    fn select_neutral_boost_picks_higher_bid() {
+        // 5 gwei bid > 1 gwei local, neutral compare ⇒ bid.
+        assert_eq!(pick(1, false, Some(5), None), (REMOTE, false));
+    }
+
+    #[test]
+    fn select_local_strictly_higher_keeps_local() {
+        assert_eq!(pick(10, false, Some(5), None), (LOCAL, true));
+    }
+
+    #[test]
+    fn select_tie_goes_to_local() {
+        // `>=` ⇒ local wins ties.
+        assert_eq!(pick(5, false, Some(5), None), (LOCAL, true));
+    }
+
+    #[test]
+    fn select_boost_factor_amplifies_bid() {
+        // 5 gwei local vs 3 gwei bid: raw ⇒ local.
+        assert_eq!(pick(5, false, Some(3), None), (LOCAL, true));
+        // boost=200 ⇒ bid scaled to 6 gwei ⇒ bid wins.
+        assert_eq!(pick(5, false, Some(3), Some(200)), (REMOTE, false));
+    }
 }
diff --git a/beacon_node/beacon_chain/src/payload_bid_verification/tests.rs b/beacon_node/beacon_chain/src/payload_bid_verification/tests.rs
index 98863a49d5..b7b77d5d2a 100644
--- a/beacon_node/beacon_chain/src/payload_bid_verification/tests.rs
+++ b/beacon_node/beacon_chain/src/payload_bid_verification/tests.rs
@@ -256,6 +256,7 @@ fn make_signed_preferences(
             validator_index,
             fee_recipient,
             gas_limit,
+            ..ProposerPreferences::default()
         },
         signature: Signature::empty(),
     })
diff --git a/beacon_node/beacon_chain/src/payload_envelope_streamer/tests.rs b/beacon_node/beacon_chain/src/payload_envelope_streamer/tests.rs
index be3dbf33ce..be763b4ee2 100644
--- a/beacon_node/beacon_chain/src/payload_envelope_streamer/tests.rs
+++ b/beacon_node/beacon_chain/src/payload_envelope_streamer/tests.rs
@@ -72,6 +72,7 @@ fn build_chain(
                     execution_requests: Default::default(),
                     builder_index: 0,
                     beacon_block_root: block_root,
+                    parent_beacon_block_root: Hash256::ZERO,
                 },
                 signature: Signature::empty(),
             })
diff --git a/beacon_node/beacon_chain/src/payload_envelope_verification/gossip_verified_envelope.rs b/beacon_node/beacon_chain/src/payload_envelope_verification/gossip_verified_envelope.rs
index 80724e2b00..a20963302b 100644
--- a/beacon_node/beacon_chain/src/payload_envelope_verification/gossip_verified_envelope.rs
+++ b/beacon_node/beacon_chain/src/payload_envelope_verification/gossip_verified_envelope.rs
@@ -339,6 +339,7 @@ mod tests {
             execution_requests: ExecutionRequests::default(),
             builder_index,
             beacon_block_root: Hash256::ZERO,
+            parent_beacon_block_root: Hash256::ZERO,
         }
     }
 
diff --git a/beacon_node/beacon_chain/src/payload_envelope_verification/payload_notifier.rs b/beacon_node/beacon_chain/src/payload_envelope_verification/payload_notifier.rs
index df21d33493..eb5e13b0cc 100644
--- a/beacon_node/beacon_chain/src/payload_envelope_verification/payload_notifier.rs
+++ b/beacon_node/beacon_chain/src/payload_envelope_verification/payload_notifier.rs
@@ -87,7 +87,7 @@ impl<T: BeaconChainTypes> PayloadNotifier<T> {
         Ok(NewPayloadRequest::Gloas(NewPayloadRequestGloas {
             execution_payload: &envelope.message.payload,
             versioned_hashes,
-            parent_beacon_block_root: block.message().parent_root(),
+            parent_beacon_block_root: envelope.message.parent_beacon_block_root,
             execution_requests: &envelope.message.execution_requests,
         }))
     }
diff --git a/beacon_node/beacon_chain/src/pending_payload_envelopes.rs b/beacon_node/beacon_chain/src/pending_payload_envelopes.rs
index 293553ef54..8f7568d017 100644
--- a/beacon_node/beacon_chain/src/pending_payload_envelopes.rs
+++ b/beacon_node/beacon_chain/src/pending_payload_envelopes.rs
@@ -105,6 +105,7 @@ mod tests {
                 execution_requests: ExecutionRequests::default(),
                 builder_index: 0,
                 beacon_block_root: Hash256::ZERO,
+                parent_beacon_block_root: Hash256::ZERO,
             },
             blobs: None,
         }
diff --git a/beacon_node/beacon_chain/src/proposer_preferences_verification/gossip_verified_proposer_preferences.rs b/beacon_node/beacon_chain/src/proposer_preferences_verification/gossip_verified_proposer_preferences.rs
index 8ea095743f..e97dab56d7 100644
--- a/beacon_node/beacon_chain/src/proposer_preferences_verification/gossip_verified_proposer_preferences.rs
+++ b/beacon_node/beacon_chain/src/proposer_preferences_verification/gossip_verified_proposer_preferences.rs
@@ -64,6 +64,7 @@ impl GossipVerifiedProposerPreferences {
         ctx: &GossipVerificationContext<'_, T>,
     ) -> Result<Self, ProposerPreferencesError> {
         let proposal_slot = signed_preferences.message.proposal_slot;
+        let checkpoint_root = signed_preferences.message.checkpoint_root;
         let validator_index = signed_preferences.message.validator_index;
         let cached_head = ctx.canonical_head.cached_head();
         let current_slot = ctx
@@ -74,7 +75,7 @@ impl GossipVerifiedProposerPreferences {
 
         if ctx
             .gossip_verified_proposer_preferences_cache
-            .get_seen_validator(&proposal_slot, validator_index)
+            .get_seen_validator(&proposal_slot, checkpoint_root, validator_index)
         {
             return Err(ProposerPreferencesError::AlreadySeen {
                 validator_index,
@@ -162,6 +163,7 @@ mod tests {
 
     fn make_preferences(proposal_slot: Slot, validator_index: u64) -> ProposerPreferences {
         ProposerPreferences {
+            checkpoint_root: types::Hash256::ZERO,
             proposal_slot,
             validator_index,
             fee_recipient: Address::ZERO,
diff --git a/beacon_node/beacon_chain/src/proposer_preferences_verification/proposer_preference_cache.rs b/beacon_node/beacon_chain/src/proposer_preferences_verification/proposer_preference_cache.rs
index 69337f2a83..e2b0c40fb5 100644
--- a/beacon_node/beacon_chain/src/proposer_preferences_verification/proposer_preference_cache.rs
+++ b/beacon_node/beacon_chain/src/proposer_preferences_verification/proposer_preference_cache.rs
@@ -5,11 +5,11 @@ use std::{
 
 use crate::proposer_preferences_verification::gossip_verified_proposer_preferences::GossipVerifiedProposerPreferences;
 use parking_lot::RwLock;
-use types::{SignedProposerPreferences, Slot};
+use types::{Hash256, SignedProposerPreferences, Slot};
 
 pub struct GossipVerifiedProposerPreferenceCache {
     preferences: RwLock<BTreeMap<Slot, GossipVerifiedProposerPreferences>>,
-    seen: RwLock<BTreeMap<Slot, HashSet<u64>>>,
+    seen: RwLock<BTreeMap<Slot, HashSet<(Hash256, u64)>>>,
 }
 
 impl Default for GossipVerifiedProposerPreferenceCache {
@@ -34,21 +34,27 @@ impl GossipVerifiedProposerPreferenceCache {
         self.preferences.write().insert(slot, preferences);
     }
 
-    pub fn get_seen_validator(&self, slot: &Slot, validator_index: u64) -> bool {
+    pub fn get_seen_validator(
+        &self,
+        slot: &Slot,
+        checkpoint_root: Hash256,
+        validator_index: u64,
+    ) -> bool {
         self.seen
             .read()
             .get(slot)
-            .is_some_and(|seen| seen.contains(&validator_index))
+            .is_some_and(|seen| seen.contains(&(checkpoint_root, validator_index)))
     }
 
     pub fn insert_seen_validator(&self, preferences: &GossipVerifiedProposerPreferences) {
         let slot = preferences.signed_preferences.message.proposal_slot;
+        let checkpoint_root = preferences.signed_preferences.message.checkpoint_root;
         let validator_index = preferences.signed_preferences.message.validator_index;
         self.seen
             .write()
             .entry(slot)
             .or_default()
-            .insert(validator_index);
+            .insert((checkpoint_root, validator_index));
     }
 
     pub fn prune(&self, current_slot: Slot) {
@@ -77,6 +83,7 @@ mod tests {
                     validator_index,
                     fee_recipient: Address::ZERO,
                     gas_limit: 30_000_000,
+                    ..ProposerPreferences::default()
                 },
                 signature: Signature::empty(),
             }),
@@ -97,11 +104,11 @@ mod tests {
 
         for slot in [1, 2, 3, 7] {
             assert!(cache.get_preferences(&Slot::new(slot)).is_none());
-            assert!(!cache.get_seen_validator(&Slot::new(slot), slot));
+            assert!(!cache.get_seen_validator(&Slot::new(slot), types::Hash256::ZERO, slot));
         }
         for slot in [8, 9, 10] {
             assert!(cache.get_preferences(&Slot::new(slot)).is_some());
-            assert!(cache.get_seen_validator(&Slot::new(slot), slot));
+            assert!(cache.get_seen_validator(&Slot::new(slot), types::Hash256::ZERO, slot));
         }
     }
 }
diff --git a/beacon_node/beacon_chain/src/proposer_preferences_verification/tests.rs b/beacon_node/beacon_chain/src/proposer_preferences_verification/tests.rs
index 2f1b24fcbb..d3974baa8b 100644
--- a/beacon_node/beacon_chain/src/proposer_preferences_verification/tests.rs
+++ b/beacon_node/beacon_chain/src/proposer_preferences_verification/tests.rs
@@ -131,6 +131,7 @@ fn make_signed_preferences(
             validator_index,
             fee_recipient: Address::ZERO,
             gas_limit: 30_000_000,
+            ..ProposerPreferences::default()
         },
         signature: Signature::empty(),
     })
@@ -230,10 +231,11 @@ fn correct_proposer_bad_signature() {
         result,
         Err(ProposerPreferencesError::BadSignature)
     ));
-    assert!(
-        !ctx.preferences_cache
-            .get_seen_validator(&slot, actual_proposer)
-    );
+    assert!(!ctx.preferences_cache.get_seen_validator(
+        &slot,
+        types::Hash256::ZERO,
+        actual_proposer
+    ));
     assert!(ctx.preferences_cache.get_preferences(&slot).is_none());
 }
 
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index c3db26e95c..73c4af4e11 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -1186,6 +1186,7 @@ where
                     randao_reveal,
                     graffiti_settings,
                     ProduceBlockVerification::VerifyRandao,
+                    None,
                 )
                 .await
                 .unwrap();
diff --git a/beacon_node/beacon_chain/tests/payload_invalidation.rs b/beacon_node/beacon_chain/tests/payload_invalidation.rs
index 38d4f4c47e..be85fc2245 100644
--- a/beacon_node/beacon_chain/tests/payload_invalidation.rs
+++ b/beacon_node/beacon_chain/tests/payload_invalidation.rs
@@ -1093,6 +1093,7 @@ async fn invalid_parent() {
             Duration::from_secs(0),
             &state,
             PayloadVerificationStatus::Optimistic,
+            block.message().proposer_index(),
             &rig.harness.chain.spec,
         ),
         Err(ForkChoiceError::ProtoArrayStringError(message))
diff --git a/beacon_node/beacon_chain/tests/prepare_payload.rs b/beacon_node/beacon_chain/tests/prepare_payload.rs
index 1d23990b80..47dd1ef517 100644
--- a/beacon_node/beacon_chain/tests/prepare_payload.rs
+++ b/beacon_node/beacon_chain/tests/prepare_payload.rs
@@ -229,9 +229,6 @@ async fn prepare_payload_generic(
     // `apply_parent_execution_payload`.
     let cached_head = harness.chain.canonical_head.cached_head();
     let unadvanced_empty_state = &cached_head.snapshot.beacon_state;
-    let parent_bid = unadvanced_empty_state
-        .latest_execution_payload_bid()
-        .unwrap();
 
     let mut advanced_empty_state = unadvanced_empty_state.clone();
     complete_state_advance(&mut advanced_empty_state, None, prepare_slot, &spec).unwrap();
@@ -239,7 +236,6 @@ async fn prepare_payload_generic(
     let mut unadvanced_full_state = unadvanced_empty_state.clone();
     apply_parent_execution_payload(
         &mut unadvanced_full_state,
-        parent_bid,
         &envelope.message.execution_requests,
         &spec,
     )
@@ -248,7 +244,6 @@ async fn prepare_payload_generic(
     let mut advanced_full_state = advanced_empty_state.clone();
     apply_parent_execution_payload(
         &mut advanced_full_state,
-        parent_bid,
         &envelope.message.execution_requests,
         &spec,
     )
@@ -637,6 +632,7 @@ async fn gloas_block_production_caches_blobs_for_column_publishing() {
             randao_reveal,
             graffiti_settings,
             ProduceBlockVerification::VerifyRandao,
+            None,
         )
         .await
         .unwrap();
diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs
index 4146543fd5..b2dabb7c01 100644
--- a/beacon_node/execution_layer/src/lib.rs
+++ b/beacon_node/execution_layer/src/lib.rs
@@ -205,6 +205,7 @@ pub struct BlockProposalContentsGloas<E: EthSpec> {
     pub blob_kzg_commitments: KzgCommitments<E>,
     pub blobs_and_proofs: (BlobsList<E>, KzgProofs<E>),
     pub execution_requests: ExecutionRequests<E>,
+    pub should_override_builder: bool,
 }
 
 impl<E: EthSpec> From<GetPayloadResponseGloas<E>> for BlockProposalContentsGloas<E> {
@@ -215,6 +216,7 @@ impl<E: EthSpec> From<GetPayloadResponseGloas<E>> for BlockProposalContentsGloas
             blob_kzg_commitments: response.blobs_bundle.commitments,
             blobs_and_proofs: (response.blobs_bundle.blobs, response.blobs_bundle.proofs),
             execution_requests: response.requests,
+            should_override_builder: response.should_override_builder,
         }
     }
 }
diff --git a/beacon_node/http_api/src/beacon/execution_payload_envelope.rs b/beacon_node/http_api/src/beacon/execution_payload_envelope.rs
index 06a5915c08..65e1a83840 100644
--- a/beacon_node/http_api/src/beacon/execution_payload_envelope.rs
+++ b/beacon_node/http_api/src/beacon/execution_payload_envelope.rs
@@ -7,7 +7,7 @@ use crate::version::{
     execution_optimistic_finalized_beacon_response,
 };
 use beacon_chain::data_column_verification::{GossipDataColumnError, GossipVerifiedDataColumn};
-use beacon_chain::{BeaconChain, BeaconChainTypes};
+use beacon_chain::{BeaconChain, BeaconChainTypes, NotifyExecutionLayer};
 use bytes::Bytes;
 use eth2::types as api_types;
 use eth2::{CONTENT_TYPE_HEADER, SSZ_CONTENT_TYPE_HEADER};
@@ -18,7 +18,7 @@ use std::future::Future;
 use std::sync::Arc;
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::{debug, error, info, warn};
-use types::{EthSpec, SignedExecutionPayloadEnvelope};
+use types::{BlockImportSource, EthSpec, SignedExecutionPayloadEnvelope};
 use warp::{
     Filter, Rejection, Reply,
     hyper::{Body, Response},
@@ -99,14 +99,12 @@ pub async fn publish_execution_payload_envelope<T: BeaconChainTypes>(
     let slot = envelope.slot();
     let beacon_block_root = envelope.message.beacon_block_root;
 
-    // TODO(gloas): Replace this check once we have gossip validation.
     if !chain.spec.is_gloas_scheduled() {
         return Err(warp_utils::reject::custom_bad_request(
             "Execution payload envelopes are not supported before the Gloas fork".into(),
         ));
     }
 
-    // TODO(gloas): We should probably add validation here i.e. BroadcastValidation::Gossip
     info!(
         %slot,
         %beacon_block_root,
@@ -118,7 +116,7 @@ pub async fn publish_execution_payload_envelope<T: BeaconChainTypes>(
 
     // Spawn the column-build task (CPU-bound KZG cell-and-proof computation) before
     // publishing the envelope so it runs in parallel with envelope gossip, narrowing
-    // the window in which peers see envelope-without-columns. If envelope publication
+    // the window in which peers see envelope-without-columns. If envelope import
     // fails below, dropping this future drops the spawned `JoinHandle` (the running
     // closure on the blocking pool finishes and is then discarded — no work cancellation).
     let column_build_future = match blobs_and_proofs {
@@ -131,17 +129,47 @@ pub async fn publish_execution_payload_envelope<T: BeaconChainTypes>(
         _ => None,
     };
 
-    // Publish the envelope to the network.
-    crate::utils::publish_pubsub_message(
-        network_tx,
-        PubsubMessage::ExecutionPayload(Box::new(envelope)),
-    )
-    .map_err(|_| {
-        warn!(%slot, "Failed to publish execution payload envelope to network");
-        warp_utils::reject::custom_server_error(
-            "Unable to publish execution payload envelope to network".into(),
+    // Gossip-verify the envelope before publishing.
+    let gossip_verified = chain
+        .verify_envelope_for_gossip(Arc::new(envelope))
+        .await
+        .map_err(|e| {
+            warn!(%slot, error = ?e, "Execution payload envelope failed gossip verification");
+            warp_utils::reject::custom_bad_request(format!(
+                "envelope failed gossip verification: {e}"
+            ))
+        })?;
+
+    let network_tx_clone = network_tx.clone();
+    let envelope_for_gossip = gossip_verified.signed_envelope.as_ref().clone();
+    let publish_fn = || {
+        crate::utils::publish_pubsub_message(
+            &network_tx_clone,
+            PubsubMessage::ExecutionPayload(Box::new(envelope_for_gossip)),
         )
-    })?;
+        .map_err(|_| {
+            beacon_chain::payload_envelope_verification::EnvelopeError::BeaconChainError(Arc::new(
+                beacon_chain::BeaconChainError::UnableToPublish,
+            ))
+        })
+    };
+
+    let import_result = chain
+        .process_execution_payload_envelope(
+            beacon_block_root,
+            gossip_verified,
+            NotifyExecutionLayer::Yes,
+            BlockImportSource::HttpApi,
+            publish_fn,
+        )
+        .await;
+
+    if let Err(e) = import_result {
+        warn!(%slot, error = ?e, "Failed to import execution payload envelope");
+        return Err(warp_utils::reject::custom_server_error(format!(
+            "envelope import failed: {e}"
+        )));
+    }
 
     // From here on the envelope is on the wire. `take_blobs` already consumed the cache
     // entry, so a retry would not republish columns; returning Err would mislead the
diff --git a/beacon_node/http_api/tests/tests.rs b/beacon_node/http_api/tests/tests.rs
index b8326f4495..01a77ad4d7 100644
--- a/beacon_node/http_api/tests/tests.rs
+++ b/beacon_node/http_api/tests/tests.rs
@@ -3450,17 +3450,20 @@ impl ApiTester {
                 .unwrap()
                 .unwrap_or(self.chain.head_beacon_block_root());
 
-            // Presently, the beacon chain harness never runs the code that primes the proposer
-            // cache. If this changes in the future then we'll need some smarter logic here, but
-            // this is succinct and effective for the time being.
-            assert!(
-                self.chain
-                    .beacon_proposer_cache
-                    .lock()
-                    .get_epoch::<E>(dependent_root, epoch)
-                    .is_none(),
-                "the proposer cache should miss initially"
-            );
+            // Block import primes the proposer cache for each epoch it runs through (to gate
+            // proposer boost), so epochs `<= current_epoch` are already cached. The only epoch
+            // for which we can observe the endpoint's own caching behaviour is
+            // `current_epoch + 1`, which no block import has touched yet.
+            if epoch == current_epoch + 1 {
+                assert!(
+                    self.chain
+                        .beacon_proposer_cache
+                        .lock()
+                        .get_epoch::<E>(dependent_root, epoch)
+                        .is_none(),
+                    "the proposer cache should miss initially for the next epoch"
+                );
+            }
 
             let result = self
                 .client
@@ -3468,8 +3471,9 @@ impl ApiTester {
                 .await
                 .unwrap();
 
-            // Check that current-epoch requests prime the proposer cache, whilst non-current
-            // requests don't.
+            // A current-epoch request should leave the cache primed (block import already did so,
+            // but this is still a useful end-to-end check). A request for `current_epoch + 1`
+            // should not prime the cache.
             if epoch == current_epoch {
                 assert!(
                     self.chain
@@ -3477,16 +3481,16 @@ impl ApiTester {
                         .lock()
                         .get_epoch::<E>(dependent_root, epoch)
                         .is_some(),
-                    "a current-epoch request should prime the proposer cache"
+                    "the proposer cache should be primed for the current epoch"
                 );
-            } else {
+            } else if epoch == current_epoch + 1 {
                 assert!(
                     self.chain
                         .beacon_proposer_cache
                         .lock()
                         .get_epoch::<E>(dependent_root, epoch)
                         .is_none(),
-                    "a non-current-epoch request should not prime the proposer cache"
+                    "a request for the next epoch should not prime the proposer cache"
                 );
             }
 
@@ -4640,6 +4644,86 @@ impl ApiTester {
         self
     }
 
+    /// Regression test: publishing an envelope via the HTTP API must import it locally so
+    /// that `produce_payload_attestation_data` returns `payload_present = true`. Without
+    /// local import, the `envelope_times_cache` is never populated and PTC voters on the
+    /// same node incorrectly vote MISSING for their own payload.
+    pub async fn test_payload_attestation_present_after_envelope_publish(self) -> Self {
+        if !self.chain.spec.is_gloas_scheduled() {
+            return self;
+        }
+
+        let fork = self.chain.canonical_head.cached_head().head_fork();
+        let genesis_validators_root = self.chain.genesis_validators_root;
+
+        for _ in 0..E::slots_per_epoch() * 3 {
+            let slot = self.chain.slot().unwrap();
+            let epoch = self.chain.epoch().unwrap();
+            let fork_name = self.chain.spec.fork_name_at_slot::<E>(slot);
+
+            if !fork_name.gloas_enabled() {
+                self.chain.slot_clock.set_slot(slot.as_u64() + 1);
+                continue;
+            }
+
+            let (sk, randao_reveal) = self
+                .proposer_setup(slot, epoch, &fork, genesis_validators_root)
+                .await;
+
+            // Produce and publish a block.
+            let (response, _metadata) = self
+                .client
+                .get_validator_blocks_v4::<E>(slot, &randao_reveal, None, None, None)
+                .await
+                .unwrap();
+            let block = response.data;
+            let block_root = block.tree_hash_root();
+
+            let signed_block = block.sign(&sk, &fork, genesis_validators_root, &self.chain.spec);
+            let signed_block_request =
+                PublishBlockRequest::try_from(Arc::new(signed_block)).unwrap();
+            self.client
+                .post_beacon_blocks_v2(&signed_block_request, None)
+                .await
+                .unwrap();
+
+            // Retrieve and publish the envelope.
+            let envelope = self
+                .client
+                .get_validator_execution_payload_envelope::<E>(slot, BUILDER_INDEX_SELF_BUILD)
+                .await
+                .unwrap()
+                .data;
+
+            let signed_envelope =
+                self.sign_envelope(envelope, &sk, epoch, &fork, genesis_validators_root);
+            self.client
+                .post_beacon_execution_payload_envelope(&signed_envelope, fork_name)
+                .await
+                .unwrap();
+
+            // The payload attestation data endpoint must now report the payload as present.
+            let pa_data = self
+                .client
+                .get_validator_payload_attestation_data(slot)
+                .await
+                .unwrap()
+                .into_data();
+
+            assert_eq!(pa_data.beacon_block_root, block_root);
+            assert_eq!(pa_data.slot, slot);
+            assert!(
+                pa_data.payload_present,
+                "payload attestation should report payload_present=true after publishing \
+                 the envelope via the HTTP API (slot {slot})"
+            );
+
+            self.chain.slot_clock.set_slot(slot.as_u64() + 1);
+        }
+
+        self
+    }
+
     pub async fn test_get_validator_payload_attestation_data_pre_gloas(self) -> Self {
         let slot = self.chain.slot().unwrap();
 
@@ -8329,6 +8413,14 @@ async fn get_validator_payload_attestation_data_pre_gloas() {
         .await;
 }
 
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn payload_attestation_present_after_envelope_publish() {
+    ApiTester::new_with_hard_forks()
+        .await
+        .test_payload_attestation_present_after_envelope_publish()
+        .await;
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn post_beacon_pool_payload_attestations_valid() {
     if !fork_name_from_env().is_some_and(|f| f.gloas_enabled()) {
diff --git a/beacon_node/network/src/network_beacon_processor/tests.rs b/beacon_node/network/src/network_beacon_processor/tests.rs
index 0ff9200737..75d08eb965 100644
--- a/beacon_node/network/src/network_beacon_processor/tests.rs
+++ b/beacon_node/network/src/network_beacon_processor/tests.rs
@@ -2131,6 +2131,7 @@ fn make_test_payload_envelope(
             execution_requests: ExecutionRequests::default(),
             builder_index: 0,
             beacon_block_root,
+            parent_beacon_block_root: Hash256::ZERO,
         },
         signature: Signature::empty(),
     }
diff --git a/consensus/fork_choice/src/fork_choice.rs b/consensus/fork_choice/src/fork_choice.rs
index a9e62dbe94..477d1fa3b4 100644
--- a/consensus/fork_choice/src/fork_choice.rs
+++ b/consensus/fork_choice/src/fork_choice.rs
@@ -756,6 +756,7 @@ where
         block_delay: Duration,
         state: &BeaconState<E>,
         payload_verification_status: PayloadVerificationStatus,
+        canonical_head_proposer_index: u64,
         spec: &ChainSpec,
     ) -> Result<(), Error<T::Error>> {
         let _timer = metrics::start_timer(&metrics::FORK_CHOICE_ON_BLOCK_TIMES);
@@ -820,16 +821,18 @@ where
 
         let attestation_threshold = spec.get_attestation_due::<E>(block.slot());
 
-        // Add proposer score boost if the block is timely.
-        // TODO(gloas): the spec's `update_proposer_boost_root` additionally checks that
-        // `block.proposer_index == get_beacon_proposer_index(head_state)` — i.e. that
-        // the block's proposer matches the expected proposer on the canonical chain.
-        // This requires calling `get_head` and advancing the head state to the current
-        // slot, which is expensive. Implement once we have a cached proposer index.
+        // Add proposer score boost if the block is the first timely block for this slot and its
+        // proposer matches the expected proposer on the canonical chain (per spec
+        // `update_proposer_boost_root`, introduced in v1.7.0-alpha.5).
         let is_before_attesting_interval = block_delay < attestation_threshold;
 
         let is_first_block = self.fc_store.proposer_boost_root().is_zero();
-        if current_slot == block.slot() && is_before_attesting_interval && is_first_block {
+        let is_canonical_proposer = block.proposer_index() == canonical_head_proposer_index;
+        if current_slot == block.slot()
+            && is_before_attesting_interval
+            && is_first_block
+            && is_canonical_proposer
+        {
             self.fc_store.set_proposer_boost_root(block_root);
         }
 
diff --git a/consensus/fork_choice/tests/tests.rs b/consensus/fork_choice/tests/tests.rs
index d6f937c0ca..353893026b 100644
--- a/consensus/fork_choice/tests/tests.rs
+++ b/consensus/fork_choice/tests/tests.rs
@@ -316,6 +316,7 @@ impl ForkChoiceTest {
                 Duration::from_secs(0),
                 &state,
                 PayloadVerificationStatus::Verified,
+                block.message().proposer_index(),
                 &self.harness.chain.spec,
             )
             .unwrap();
@@ -359,6 +360,7 @@ impl ForkChoiceTest {
                 Duration::from_secs(0),
                 &state,
                 PayloadVerificationStatus::Verified,
+                block.message().proposer_index(),
                 &self.harness.chain.spec,
             )
             .expect_err("on_block did not return an error");
diff --git a/consensus/proto_array/src/proto_array.rs b/consensus/proto_array/src/proto_array.rs
index 8548974054..78f5026689 100644
--- a/consensus/proto_array/src/proto_array.rs
+++ b/consensus/proto_array/src/proto_array.rs
@@ -23,14 +23,6 @@ use types::{
 four_byte_option_impl!(four_byte_option_usize, usize);
 four_byte_option_impl!(four_byte_option_checkpoint, Checkpoint);
 
-fn all_true_bitvector<N: typenum::Unsigned + Clone>() -> BitVector<N> {
-    let mut bv = BitVector::new();
-    for i in 0..bv.len() {
-        let _ = bv.set(i, true);
-    }
-    bv
-}
-
 /// Defines an operation which may invalidate the `execution_status` of some nodes.
 #[derive(Clone, Debug)]
 pub enum InvalidationOperation {
@@ -568,10 +560,8 @@ impl ProtoArray {
                         ProtoNode::V29(v29) => {
                             // Both parent and child are Gloas blocks. The parent is full if the
                             // block hash in the parent node matches the parent block hash in the
-                            // child bid and the parent block isn't the genesis block.
-                            if v29.execution_payload_block_hash != ExecutionBlockHash::zero()
-                                && execution_payload_parent_hash == v29.execution_payload_block_hash
-                            {
+                            // child bid.
+                            if execution_payload_parent_hash == v29.execution_payload_block_hash {
                                 PayloadStatus::Full
                             } else {
                                 PayloadStatus::Empty
@@ -613,18 +603,8 @@ impl ProtoArray {
                 full_payload_weight: 0,
                 execution_payload_block_hash,
                 execution_payload_parent_hash,
-                // Per spec `get_forkchoice_store`: the anchor block's PTC votes are
-                // initialized to all-True.
-                payload_timeliness_votes: if is_anchor {
-                    all_true_bitvector()
-                } else {
-                    BitVector::default()
-                },
-                payload_data_availability_votes: if is_anchor {
-                    all_true_bitvector()
-                } else {
-                    BitVector::default()
-                },
+                payload_timeliness_votes: BitVector::default(),
+                payload_data_availability_votes: BitVector::default(),
                 payload_received: false,
                 proposer_index,
                 // Spec: `record_block_timeliness` + `get_forkchoice_store`.
diff --git a/consensus/state_processing/src/envelope_processing.rs b/consensus/state_processing/src/envelope_processing.rs
index 8ea96390e3..3da4d1e9d6 100644
--- a/consensus/state_processing/src/envelope_processing.rs
+++ b/consensus/state_processing/src/envelope_processing.rs
@@ -26,6 +26,12 @@ pub enum EnvelopeProcessingError {
         envelope_root: Hash256,
         block_header_root: Hash256,
     },
+    /// Envelope's `parent_beacon_block_root` doesn't match the parent root of the latest
+    /// block header.
+    ParentBeaconBlockRootMismatch {
+        envelope: Hash256,
+        state: Hash256,
+    },
     /// Envelope doesn't match latest beacon block slot
     SlotMismatch {
         envelope_slot: Slot,
@@ -126,6 +132,13 @@ pub fn verify_execution_payload_envelope<E: EthSpec>(
             block_header_root: latest_block_header_root,
         }
     );
+    envelope_verify!(
+        envelope.parent_beacon_block_root == state.latest_block_header().parent_root,
+        EnvelopeProcessingError::ParentBeaconBlockRootMismatch {
+            envelope: envelope.parent_beacon_block_root,
+            state: state.latest_block_header().parent_root,
+        }
+    );
     envelope_verify!(
         envelope.slot() == state.slot(),
         EnvelopeProcessingError::SlotMismatch {
diff --git a/consensus/state_processing/src/genesis.rs b/consensus/state_processing/src/genesis.rs
index 9dfbc87b48..c643ad56e3 100644
--- a/consensus/state_processing/src/genesis.rs
+++ b/consensus/state_processing/src/genesis.rs
@@ -175,13 +175,11 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
         bid.parent_block_hash = el_genesis_hash;
         bid.block_hash = ExecutionBlockHash::default();
 
-        // Update latest_block_header to reflect the Gloas genesis block body which contains
-        // the EL genesis hash in the signed_execution_payload_bid. This is needed because
-        // BeaconState::new() created the header from BeaconBlock::empty() which has zero bid
-        // fields, but the spec requires the genesis block's bid to contain the EL block hash
-        // and the tree hash root of empty ExecutionRequests.
-        let block = genesis_block(&state, spec)?;
-        state.latest_block_header_mut().body_root = block.body_root();
+        // Update the `latest_block_header.body_root` so that it matches the body of the
+        // Gloas genesis block, which embeds `state.latest_execution_payload_bid` in its
+        // `signed_execution_payload_bid` field (see `genesis_block`).
+        let genesis_body_root = genesis_block(&state, spec)?.body_root();
+        state.latest_block_header_mut().body_root = genesis_body_root;
     }
 
     // Now that we have our validators, initialize the caches (including the committees)
@@ -193,24 +191,23 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
     Ok(state)
 }
 
-/// Create an unsigned genesis `BeaconBlock` whose body matches the genesis state.
+/// Create an unsigned genesis `BeaconBlock`.
 ///
-/// For Gloas, the block's `signed_execution_payload_bid` is populated from the state's
-/// `latest_execution_payload_bid` so that the body root is consistent with
-/// `state.latest_block_header.body_root`.
+/// Per spec, the genesis block body is empty (all default fields) except for Gloas,
+/// where `body.signed_execution_payload_bid.message` is initialised from
+/// `state.latest_execution_payload_bid` so that the first post-genesis proposer can
+/// build on the correct execution layer head.
 ///
-/// The returned block has `state_root == Hash256::ZERO`; callers that need the real
-/// state root should set it themselves.
+/// `state.latest_block_header.body_root` is set from this same block's body, so the
+/// two must stay in sync.
 pub fn genesis_block<E: EthSpec>(
-    genesis_state: &BeaconState<E>,
+    state: &BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<BeaconBlock<E>, BeaconStateError> {
     let mut block = BeaconBlock::empty(spec);
-    if let Ok(block) = block.as_gloas_mut() {
-        let state_bid = genesis_state.latest_execution_payload_bid()?;
-        let bid = &mut block.body.signed_execution_payload_bid.message;
-        bid.block_hash = state_bid.block_hash;
-        bid.execution_requests_root = state_bid.execution_requests_root;
+    if let BeaconBlock::Gloas(ref mut gloas_block) = block {
+        let bid = state.latest_execution_payload_bid()?.clone();
+        gloas_block.body.signed_execution_payload_bid.message = bid;
     }
     Ok(block)
 }
diff --git a/consensus/state_processing/src/per_block_processing.rs b/consensus/state_processing/src/per_block_processing.rs
index 71ad394ee6..f13f2a339b 100644
--- a/consensus/state_processing/src/per_block_processing.rs
+++ b/consensus/state_processing/src/per_block_processing.rs
@@ -555,13 +555,10 @@ pub fn process_parent_execution_payload<E: EthSpec, Payload: AbstractExecPayload
         .signed_execution_payload_bid()?
         .message
         .parent_block_hash;
-    let parent_bid = state.latest_execution_payload_bid()?.clone();
+    let parent_bid = state.latest_execution_payload_bid()?;
     let requests = block.body().parent_execution_requests()?;
 
-    let is_genesis_block = parent_bid.block_hash == ExecutionBlockHash::zero();
-    let is_parent_block_empty = bid_parent_block_hash != parent_bid.block_hash;
-
-    if is_genesis_block || is_parent_block_empty {
+    if bid_parent_block_hash != parent_bid.block_hash {
         // Parent was EMPTY -- no execution requests expected
         block_verify!(
             *requests == ExecutionRequests::default(),
@@ -580,7 +577,7 @@ pub fn process_parent_execution_payload<E: EthSpec, Payload: AbstractExecPayload
         }
     );
 
-    apply_parent_execution_payload(state, &parent_bid, requests, spec)
+    apply_parent_execution_payload(state, requests, spec)
 }
 
 /// Apply the parent execution payload's deferred effects to the state.
@@ -591,10 +588,10 @@ pub fn process_parent_execution_payload<E: EthSpec, Payload: AbstractExecPayload
 /// 3. Updates `execution_payload_availability` and `latest_block_hash`
 pub fn apply_parent_execution_payload<E: EthSpec>(
     state: &mut BeaconState<E>,
-    parent_bid: &ExecutionPayloadBid<E>,
     requests: &ExecutionRequests<E>,
     spec: &ChainSpec,
 ) -> Result<(), BlockProcessingError> {
+    let parent_bid = state.latest_execution_payload_bid()?.clone();
     let parent_slot = parent_bid.slot;
     let parent_epoch = parent_slot.epoch(E::slots_per_epoch());
 
diff --git a/consensus/state_processing/src/per_block_processing/withdrawals.rs b/consensus/state_processing/src/per_block_processing/withdrawals.rs
index 3b14e904c4..8a09e35cdf 100644
--- a/consensus/state_processing/src/per_block_processing/withdrawals.rs
+++ b/consensus/state_processing/src/per_block_processing/withdrawals.rs
@@ -9,8 +9,8 @@ use safe_arith::{SafeArith, SafeArithIter};
 use tree_hash::TreeHash;
 use types::{
     AbstractExecPayload, BeaconState, BeaconStateError, ChainSpec, EthSpec, ExecPayload,
-    ExecutionBlockHash, ExpectedWithdrawals, ExpectedWithdrawalsCapella,
-    ExpectedWithdrawalsElectra, ExpectedWithdrawalsGloas, Validator, Withdrawal, Withdrawals,
+    ExpectedWithdrawals, ExpectedWithdrawalsCapella, ExpectedWithdrawalsElectra,
+    ExpectedWithdrawalsGloas, Validator, Withdrawal, Withdrawals,
 };
 
 /// Compute the next batch of withdrawals which should be included in a block.
@@ -495,10 +495,7 @@ pub mod gloas {
         spec: &ChainSpec,
     ) -> Result<(), BlockProcessingError> {
         // Return early if the parent block is empty.
-        let is_genesis_block = *state.latest_block_hash()? == ExecutionBlockHash::default();
-        let is_parent_block_empty =
-            *state.latest_block_hash()? != state.latest_execution_payload_bid()?.block_hash;
-        if is_genesis_block || is_parent_block_empty {
+        if *state.latest_block_hash()? != state.latest_execution_payload_bid()?.block_hash {
             return Ok(());
         }
 
diff --git a/consensus/state_processing/src/per_epoch_processing/single_pass.rs b/consensus/state_processing/src/per_epoch_processing/single_pass.rs
index 976607aa76..881e6bb16c 100644
--- a/consensus/state_processing/src/per_epoch_processing/single_pass.rs
+++ b/consensus/state_processing/src/per_epoch_processing/single_pass.rs
@@ -962,7 +962,11 @@ fn compute_exit_epoch_and_update_churn(
         spec.compute_activation_exit_epoch(state_ctxt.current_epoch)?,
     );
 
-    let per_epoch_churn = get_activation_exit_churn_limit(state_ctxt, spec)?;
+    let per_epoch_churn = if state_ctxt.fork_name.gloas_enabled() {
+        get_balance_churn_limit(state_ctxt, spec)?
+    } else {
+        get_activation_exit_churn_limit(state_ctxt, spec)?
+    };
     // New epoch for exits
     let mut exit_balance_to_consume = if *earliest_exit_epoch_state < earliest_exit_epoch {
         per_epoch_churn
@@ -991,17 +995,27 @@ fn get_activation_exit_churn_limit(
     state_ctxt: &StateContext,
     spec: &ChainSpec,
 ) -> Result<u64, Error> {
+    let max_limit = if state_ctxt.fork_name.gloas_enabled() {
+        spec.max_per_epoch_activation_churn_limit_gloas
+    } else {
+        spec.max_per_epoch_activation_exit_churn_limit
+    };
     Ok(std::cmp::min(
-        spec.max_per_epoch_activation_exit_churn_limit,
+        max_limit,
         get_balance_churn_limit(state_ctxt, spec)?,
     ))
 }
 
 fn get_balance_churn_limit(state_ctxt: &StateContext, spec: &ChainSpec) -> Result<u64, Error> {
     let total_active_balance = state_ctxt.total_active_balance;
+    let quotient = if state_ctxt.fork_name.gloas_enabled() {
+        spec.churn_limit_quotient_gloas
+    } else {
+        spec.churn_limit_quotient
+    };
     let churn = std::cmp::max(
         spec.min_per_epoch_churn_limit_electra,
-        total_active_balance.safe_div(spec.churn_limit_quotient)?,
+        total_active_balance.safe_div(quotient)?,
     );
 
     Ok(churn.safe_sub(churn.safe_rem(spec.effective_balance_increment)?)?)
diff --git a/consensus/types/configs/mainnet.yaml b/consensus/types/configs/mainnet.yaml
index ab85bd9e71..25bf872a7a 100644
--- a/consensus/types/configs/mainnet.yaml
+++ b/consensus/types/configs/mainnet.yaml
@@ -105,12 +105,8 @@ CONTRIBUTION_DUE_BPS_GLOAS: 5000
 PAYLOAD_ATTESTATION_DUE_BPS: 7500
 
 # Heze
-# 7500 basis points, 75% of SLOT_DURATION_MS
-VIEW_FREEZE_CUTOFF_BPS: 7500
 # 6667 basis points, ~67% of SLOT_DURATION_MS
-INCLUSION_LIST_SUBMISSION_DUE_BPS: 6667
-# 9167 basis points, ~92% of SLOT_DURATION_MS
-PROPOSER_INCLUSION_LIST_CUTOFF_BPS: 9167
+INCLUSION_LIST_DUE_BPS: 6667
 
 # Validator cycle
 # ---------------------------------------------------------------
@@ -135,6 +131,14 @@ MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 128000000000
 # 2**8 * 10**9 (= 256,000,000,000) Gwei
 MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 256000000000
 
+# Gloas
+# 2**15 (= 32,768)
+CHURN_LIMIT_QUOTIENT_GLOAS: 32768
+# 2**16 (= 65,536)
+CONSOLIDATION_CHURN_LIMIT_QUOTIENT: 65536
+# 2**8 * 10**9 (= 256,000,000,000) Gwei
+MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS: 256000000000
+
 # Fork choice
 # ---------------------------------------------------------------
 # 40%
diff --git a/consensus/types/configs/minimal.yaml b/consensus/types/configs/minimal.yaml
index 8c0d7254fe..7251efc762 100644
--- a/consensus/types/configs/minimal.yaml
+++ b/consensus/types/configs/minimal.yaml
@@ -101,12 +101,8 @@ CONTRIBUTION_DUE_BPS_GLOAS: 5000
 PAYLOAD_ATTESTATION_DUE_BPS: 7500
 
 # Heze
-# 7500 basis points, 75% of SLOT_DURATION_MS
-VIEW_FREEZE_CUTOFF_BPS: 7500
 # 6667 basis points, ~67% of SLOT_DURATION_MS
-INCLUSION_LIST_SUBMISSION_DUE_BPS: 6667
-# 9167 basis points, ~92% of SLOT_DURATION_MS
-PROPOSER_INCLUSION_LIST_CUTOFF_BPS: 9167
+INCLUSION_LIST_DUE_BPS: 6667
 
 # Validator cycle
 # ---------------------------------------------------------------
@@ -131,6 +127,14 @@ MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA: 64000000000
 # [customized] 2**7 * 10**9 (= 128,000,000,000) Gwei
 MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT: 128000000000
 
+# Gloas
+# [customized] 2**4 (= 16)
+CHURN_LIMIT_QUOTIENT_GLOAS: 16
+# [customized] 2**5 (= 32)
+CONSOLIDATION_CHURN_LIMIT_QUOTIENT: 32
+# [customized] 2**7 * 10**9 (= 128,000,000,000) Gwei
+MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT_GLOAS: 128000000000
+
 # Fork choice
 # ---------------------------------------------------------------
 # 40%
diff --git a/consensus/types/presets/minimal/gloas.yaml b/consensus/types/presets/minimal/gloas.yaml
index 7ae61ddf97..559c2d46df 100644
--- a/consensus/types/presets/minimal/gloas.yaml
+++ b/consensus/types/presets/minimal/gloas.yaml
@@ -2,8 +2,8 @@
 
 # Misc
 # ---------------------------------------------------------------
-# [customized] 2**1 (= 2) validators
-PTC_SIZE: 2
+# [customized] 2**4 (= 16) validators
+PTC_SIZE: 16
 
 # Max operations per block
 # ---------------------------------------------------------------
diff --git a/consensus/types/src/block/signed_beacon_block.rs b/consensus/types/src/block/signed_beacon_block.rs
index e901901599..b4bbc1a6f7 100644
--- a/consensus/types/src/block/signed_beacon_block.rs
+++ b/consensus/types/src/block/signed_beacon_block.rs
@@ -400,15 +400,13 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> SignedBeaconBlock<E, Payload>
     /// `block_hash` from the parent beacon block's bid. If the parent beacon state is available
     /// this can alternatively be fetched from `state.latest_payload_bid`.
     ///
-    /// This function returns `false` for all blocks prior to Gloas and for the zero
-    /// `parent_block_hash`.
+    /// This function returns `false` for all blocks prior to Gloas.
     pub fn is_parent_block_full(&self, parent_block_hash: ExecutionBlockHash) -> bool {
         let Ok(signed_payload_bid) = self.message().body().signed_execution_payload_bid() else {
             // Prior to Gloas.
             return false;
         };
-        parent_block_hash != ExecutionBlockHash::zero()
-            && signed_payload_bid.message.parent_block_hash == parent_block_hash
+        signed_payload_bid.message.parent_block_hash == parent_block_hash
     }
 }
 
diff --git a/consensus/types/src/builder/proposer_preferences.rs b/consensus/types/src/builder/proposer_preferences.rs
index 46dffdf3b7..0d2ba760d4 100644
--- a/consensus/types/src/builder/proposer_preferences.rs
+++ b/consensus/types/src/builder/proposer_preferences.rs
@@ -1,5 +1,5 @@
 use crate::test_utils::TestRandom;
-use crate::{Address, ForkName, SignedRoot, Slot};
+use crate::{Address, ForkName, Hash256, SignedRoot, Slot};
 use bls::Signature;
 use context_deserialize::context_deserialize;
 use educe::Educe;
@@ -16,6 +16,7 @@ use tree_hash_derive::TreeHash;
 #[context_deserialize(ForkName)]
 // https://github.com/ethereum/consensus-specs/blob/master/specs/gloas/p2p-interface.md#new-proposerpreferences
 pub struct ProposerPreferences {
+    pub checkpoint_root: Hash256,
     pub proposal_slot: Slot,
     pub validator_index: u64,
     pub fee_recipient: Address,
diff --git a/consensus/types/src/core/chain_spec.rs b/consensus/types/src/core/chain_spec.rs
index 516ca2288e..c54d032891 100644
--- a/consensus/types/src/core/chain_spec.rs
+++ b/consensus/types/src/core/chain_spec.rs
@@ -251,6 +251,9 @@ pub struct ChainSpec {
     pub builder_payment_threshold_numerator: u64,
     pub builder_payment_threshold_denominator: u64,
     pub min_builder_withdrawability_delay: Epoch,
+    pub churn_limit_quotient_gloas: u64,
+    pub consolidation_churn_limit_quotient: u64,
+    pub max_per_epoch_activation_churn_limit_gloas: u64,
 
     /*
      * Networking
@@ -1268,6 +1271,14 @@ impl ChainSpec {
             builder_payment_threshold_numerator: 6,
             builder_payment_threshold_denominator: 10,
             min_builder_withdrawability_delay: Epoch::new(64),
+            churn_limit_quotient_gloas: option_wrapper(|| u64::checked_pow(2, 15))
+                .expect("calculation does not overflow"),
+            consolidation_churn_limit_quotient: option_wrapper(|| u64::checked_pow(2, 16))
+                .expect("calculation does not overflow"),
+            max_per_epoch_activation_churn_limit_gloas: option_wrapper(|| {
+                u64::checked_pow(2, 8)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
             max_request_payloads: 128,
 
             /*
@@ -1414,6 +1425,14 @@ impl ChainSpec {
             gloas_fork_version: [0x07, 0x00, 0x00, 0x01],
             gloas_fork_epoch: None,
             min_builder_withdrawability_delay: Epoch::new(2),
+            churn_limit_quotient_gloas: option_wrapper(|| u64::checked_pow(2, 4))
+                .expect("calculation does not overflow"),
+            consolidation_churn_limit_quotient: option_wrapper(|| u64::checked_pow(2, 5))
+                .expect("calculation does not overflow"),
+            max_per_epoch_activation_churn_limit_gloas: option_wrapper(|| {
+                u64::checked_pow(2, 7)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
 
             /*
              * Derived time values (set by `compute_derived_values()`)
@@ -1675,6 +1694,14 @@ impl ChainSpec {
             builder_payment_threshold_numerator: 6,
             builder_payment_threshold_denominator: 10,
             min_builder_withdrawability_delay: Epoch::new(64),
+            churn_limit_quotient_gloas: option_wrapper(|| u64::checked_pow(2, 15))
+                .expect("calculation does not overflow"),
+            consolidation_churn_limit_quotient: option_wrapper(|| u64::checked_pow(2, 16))
+                .expect("calculation does not overflow"),
+            max_per_epoch_activation_churn_limit_gloas: option_wrapper(|| {
+                u64::checked_pow(2, 8)?.checked_mul(u64::checked_pow(10, 9)?)
+            })
+            .expect("calculation does not overflow"),
             max_request_payloads: 128,
 
             /*
@@ -2125,6 +2152,16 @@ pub struct Config {
     #[serde(default = "default_min_builder_withdrawability_delay")]
     #[serde(with = "serde_utils::quoted_u64")]
     min_builder_withdrawability_delay: u64,
+
+    #[serde(default = "default_churn_limit_quotient_gloas")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    churn_limit_quotient_gloas: u64,
+    #[serde(default = "default_consolidation_churn_limit_quotient")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    consolidation_churn_limit_quotient: u64,
+    #[serde(default = "default_max_per_epoch_activation_churn_limit_gloas")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    max_per_epoch_activation_churn_limit_gloas: u64,
 }
 
 fn default_bellatrix_fork_version() -> [u8; 4] {
@@ -2362,6 +2399,18 @@ const fn default_min_builder_withdrawability_delay() -> u64 {
     64
 }
 
+const fn default_churn_limit_quotient_gloas() -> u64 {
+    32_768
+}
+
+const fn default_consolidation_churn_limit_quotient() -> u64 {
+    65_536
+}
+
+const fn default_max_per_epoch_activation_churn_limit_gloas() -> u64 {
+    256_000_000_000
+}
+
 fn max_blocks_by_root_request_common(max_request_blocks: u64) -> usize {
     let max_request_blocks = max_request_blocks as usize;
     RuntimeVariableList::<Hash256>::new(
@@ -2613,6 +2662,11 @@ impl Config {
             contribution_due_bps: spec.contribution_due_bps,
 
             min_builder_withdrawability_delay: spec.min_builder_withdrawability_delay.as_u64(),
+
+            churn_limit_quotient_gloas: spec.churn_limit_quotient_gloas,
+            consolidation_churn_limit_quotient: spec.consolidation_churn_limit_quotient,
+            max_per_epoch_activation_churn_limit_gloas: spec
+                .max_per_epoch_activation_churn_limit_gloas,
         }
     }
 
@@ -2710,6 +2764,9 @@ impl Config {
             sync_message_due_bps,
             contribution_due_bps,
             min_builder_withdrawability_delay,
+            churn_limit_quotient_gloas,
+            consolidation_churn_limit_quotient,
+            max_per_epoch_activation_churn_limit_gloas,
         } = self;
 
         if preset_base != E::spec_name().to_string().as_str() {
@@ -2817,6 +2874,10 @@ impl Config {
 
             min_builder_withdrawability_delay: Epoch::new(min_builder_withdrawability_delay),
 
+            churn_limit_quotient_gloas,
+            consolidation_churn_limit_quotient,
+            max_per_epoch_activation_churn_limit_gloas,
+
             ..chain_spec.clone()
         };
         Some(spec.compute_derived_values::<E>())
@@ -3719,9 +3780,7 @@ mod yaml_tests {
         "CONTRIBUTION_DUE_BPS_GLOAS",
         "MAX_REQUEST_PAYLOADS",
         // Heze networking
-        "VIEW_FREEZE_CUTOFF_BPS",
-        "INCLUSION_LIST_SUBMISSION_DUE_BPS",
-        "PROPOSER_INCLUSION_LIST_CUTOFF_BPS",
+        "INCLUSION_LIST_DUE_BPS",
         "MAX_REQUEST_INCLUSION_LIST",
         "MAX_BYTES_PER_INCLUSION_LIST",
     ];
diff --git a/consensus/types/src/core/eth_spec.rs b/consensus/types/src/core/eth_spec.rs
index 4159091f5d..5f296afb44 100644
--- a/consensus/types/src/core/eth_spec.rs
+++ b/consensus/types/src/core/eth_spec.rs
@@ -572,7 +572,7 @@ impl EthSpec for MinimalEthSpec {
     type NumberOfColumns = U128;
     type ProposerLookaheadSlots = U16; // Derived from (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH
     type BuilderPendingPaymentsLimit = U16; // 2 * SLOTS_PER_EPOCH = 2 * 8 = 16
-    type PTCSize = U2;
+    type PTCSize = U16;
     type PtcWindowLength = U24; // (2 + MIN_SEED_LOOKAHEAD) * SLOTS_PER_EPOCH
     type MaxBuildersPerWithdrawalsSweep = U16;
 
diff --git a/consensus/types/src/execution/execution_payload_envelope.rs b/consensus/types/src/execution/execution_payload_envelope.rs
index 028423d681..a6d123bd21 100644
--- a/consensus/types/src/execution/execution_payload_envelope.rs
+++ b/consensus/types/src/execution/execution_payload_envelope.rs
@@ -20,6 +20,7 @@ pub struct ExecutionPayloadEnvelope<E: EthSpec> {
     #[serde(with = "serde_utils::quoted_u64")]
     pub builder_index: u64,
     pub beacon_block_root: Hash256,
+    pub parent_beacon_block_root: Hash256,
 }
 
 impl<E: EthSpec> ExecutionPayloadEnvelope<E> {
@@ -30,6 +31,7 @@ impl<E: EthSpec> ExecutionPayloadEnvelope<E> {
             execution_requests: ExecutionRequests::default(),
             builder_index: 0,
             beacon_block_root: Hash256::zero(),
+            parent_beacon_block_root: Hash256::zero(),
         }
     }
 
diff --git a/consensus/types/src/state/beacon_state.rs b/consensus/types/src/state/beacon_state.rs
index 7ed3121d6e..e821ca922b 100644
--- a/consensus/types/src/state/beacon_state.rs
+++ b/consensus/types/src/state/beacon_state.rs
@@ -2762,29 +2762,55 @@ impl<E: EthSpec> BeaconState<E> {
     /// Return the churn limit for the current epoch.
     pub fn get_balance_churn_limit(&self, spec: &ChainSpec) -> Result<u64, BeaconStateError> {
         let total_active_balance = self.get_total_active_balance()?;
+        let quotient = if self.fork_name_unchecked().gloas_enabled() {
+            spec.churn_limit_quotient_gloas
+        } else {
+            spec.churn_limit_quotient
+        };
         let churn = std::cmp::max(
             spec.min_per_epoch_churn_limit_electra,
-            total_active_balance.safe_div(spec.churn_limit_quotient)?,
+            total_active_balance.safe_div(quotient)?,
         );
 
         Ok(churn.safe_sub(churn.safe_rem(spec.effective_balance_increment)?)?)
     }
 
     /// Return the churn limit for the current epoch dedicated to activations and exits.
+    ///
+    /// From Gloas onwards this is the activation-only churn limit (EIP-8061); exits use
+    /// [`Self::get_exit_churn_limit`].
     pub fn get_activation_exit_churn_limit(
         &self,
         spec: &ChainSpec,
     ) -> Result<u64, BeaconStateError> {
+        let max_limit = if self.fork_name_unchecked().gloas_enabled() {
+            spec.max_per_epoch_activation_churn_limit_gloas
+        } else {
+            spec.max_per_epoch_activation_exit_churn_limit
+        };
         Ok(std::cmp::min(
-            spec.max_per_epoch_activation_exit_churn_limit,
+            max_limit,
             self.get_balance_churn_limit(spec)?,
         ))
     }
 
+    /// Return the Gloas (EIP-8061) exit churn limit for the current epoch.
+    ///
+    /// Unlike [`Self::get_activation_exit_churn_limit`], this is uncapped.
+    pub fn get_exit_churn_limit(&self, spec: &ChainSpec) -> Result<u64, BeaconStateError> {
+        self.get_balance_churn_limit(spec)
+    }
+
     pub fn get_consolidation_churn_limit(&self, spec: &ChainSpec) -> Result<u64, BeaconStateError> {
-        self.get_balance_churn_limit(spec)?
-            .safe_sub(self.get_activation_exit_churn_limit(spec)?)
-            .map_err(Into::into)
+        if self.fork_name_unchecked().gloas_enabled() {
+            let total_active_balance = self.get_total_active_balance()?;
+            let churn = total_active_balance.safe_div(spec.consolidation_churn_limit_quotient)?;
+            Ok(churn.safe_sub(churn.safe_rem(spec.effective_balance_increment)?)?)
+        } else {
+            self.get_balance_churn_limit(spec)?
+                .safe_sub(self.get_activation_exit_churn_limit(spec)?)
+                .map_err(Into::into)
+        }
     }
 
     pub fn get_pending_balance_to_withdraw(
@@ -2879,7 +2905,11 @@ impl<E: EthSpec> BeaconState<E> {
             self.compute_activation_exit_epoch(self.current_epoch(), spec)?,
         );
 
-        let per_epoch_churn = self.get_activation_exit_churn_limit(spec)?;
+        let per_epoch_churn = if self.fork_name_unchecked().gloas_enabled() {
+            self.get_exit_churn_limit(spec)?
+        } else {
+            self.get_activation_exit_churn_limit(spec)?
+        };
         // New epoch for exits
         let mut exit_balance_to_consume = if self.earliest_exit_epoch()? < earliest_exit_epoch {
             per_epoch_churn
@@ -3103,7 +3133,19 @@ impl<E: EthSpec> BeaconState<E> {
         let total_active_balance = self.get_total_active_balance()?;
         let fork_name = self.fork_name_unchecked();
 
-        if fork_name.electra_enabled() {
+        if fork_name.gloas_enabled() {
+            // [Modified in Gloas:EIP8061]
+            let exit_churn = self.get_exit_churn_limit(spec)?;
+            let activation_churn = self.get_activation_exit_churn_limit(spec)?;
+            let consolidation_churn = self.get_consolidation_churn_limit(spec)?;
+            compute_weak_subjectivity_period_gloas(
+                total_active_balance,
+                exit_churn,
+                activation_churn,
+                consolidation_churn,
+                spec,
+            )
+        } else if fork_name.electra_enabled() {
             let balance_churn_limit = self.get_balance_churn_limit(spec)?;
             compute_weak_subjectivity_period_electra(
                 total_active_balance,
@@ -3601,6 +3643,30 @@ pub fn compute_weak_subjectivity_period_electra(
     Ok(ws_period)
 }
 
+/// Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.6/specs/gloas/weak-subjectivity.md
+pub fn compute_weak_subjectivity_period_gloas(
+    total_active_balance: u64,
+    exit_churn_limit: u64,
+    activation_churn_limit: u64,
+    consolidation_churn_limit: u64,
+    spec: &ChainSpec,
+) -> Result<Epoch, BeaconStateError> {
+    // delta = 2 * exit_churn // 3 + activation_churn // 3 + consolidation_churn
+    let delta = exit_churn_limit
+        .safe_mul(2)?
+        .safe_div(3)?
+        .safe_add(activation_churn_limit.safe_div(3)?)?
+        .safe_add(consolidation_churn_limit)?;
+    let epochs_for_validator_set_churn = SAFETY_DECAY
+        .safe_mul(total_active_balance)?
+        .safe_div(delta.safe_mul(200)?)?;
+    let ws_period = spec
+        .min_validator_withdrawability_delay
+        .safe_add(epochs_for_validator_set_churn)?;
+
+    Ok(ws_period)
+}
+
 #[cfg(test)]
 mod weak_subjectivity_tests {
     use crate::state::beacon_state::compute_weak_subjectivity_period_electra;
diff --git a/testing/ef_tests/Makefile b/testing/ef_tests/Makefile
index facc8208d9..63d1907b96 100644
--- a/testing/ef_tests/Makefile
+++ b/testing/ef_tests/Makefile
@@ -1,6 +1,6 @@
 # To download/extract nightly tests, run:
 # CONSENSUS_SPECS_TEST_VERSION=nightly make
-CONSENSUS_SPECS_TEST_VERSION ?= v1.7.0-alpha.5
+CONSENSUS_SPECS_TEST_VERSION ?= v1.7.0-alpha.6
 REPO_NAME := consensus-spec-tests
 OUTPUT_DIR := ./$(REPO_NAME)
 
diff --git a/testing/ef_tests/check_all_files_accessed.py b/testing/ef_tests/check_all_files_accessed.py
index 5a54e150db..53fb626e7e 100755
--- a/testing/ef_tests/check_all_files_accessed.py
+++ b/testing/ef_tests/check_all_files_accessed.py
@@ -55,6 +55,7 @@ excluded_paths = [
     "tests/.*/.*/ssz_static/PartialDataColumn.*/.*",
     # TODO(gloas): Ignore Gloas light client stuff for now
     "tests/.*/gloas/ssz_static/LightClient.*/.*",
+    "tests/.*/gloas/light_client",
     # Execution payload header is irrelevant after Gloas, this type will probably be deleted.
     "tests/.*/gloas/ssz_static/ExecutionPayloadHeader/.*",
     # ForkChoiceNode is internal to fork choice and probably doesn't need SSZ tests.
diff --git a/testing/ef_tests/download_test_vectors.sh b/testing/ef_tests/download_test_vectors.sh
index f91b2d1c38..cb45aeb922 100755
--- a/testing/ef_tests/download_test_vectors.sh
+++ b/testing/ef_tests/download_test_vectors.sh
@@ -23,7 +23,7 @@ if [[ "$version" == "nightly" || "$version" =~ ^nightly-[0-9]+$ ]]; then
 
 	if [[ "$version" == "nightly" ]]; then
 		run_id=$(curl --fail -s -H "${auth_header}" \
-			"${api}/repos/${repo}/actions/workflows/nightly-reftests.yml/runs?branch=master&status=success&per_page=1" |
+			"${api}/repos/${repo}/actions/workflows/tests.yml/runs?branch=master&status=success&per_page=1" |
 			jq -r '.workflow_runs[0].id')
 	else
 		run_id="${version#nightly-}"
diff --git a/testing/ef_tests/src/cases/epoch_processing.rs b/testing/ef_tests/src/cases/epoch_processing.rs
index a032aa917f..ec243f05cc 100644
--- a/testing/ef_tests/src/cases/epoch_processing.rs
+++ b/testing/ef_tests/src/cases/epoch_processing.rs
@@ -58,6 +58,8 @@ pub struct Eth1DataReset;
 #[derive(Debug)]
 pub struct PendingBalanceDeposits;
 #[derive(Debug)]
+pub struct PendingDepositsChurn;
+#[derive(Debug)]
 pub struct PendingConsolidations;
 #[derive(Debug)]
 pub struct EffectiveBalanceUpdates;
@@ -93,6 +95,7 @@ type_name!(RegistryUpdates, "registry_updates");
 type_name!(Slashings, "slashings");
 type_name!(Eth1DataReset, "eth1_data_reset");
 type_name!(PendingBalanceDeposits, "pending_deposits");
+type_name!(PendingDepositsChurn, "pending_deposits_churn");
 type_name!(PendingConsolidations, "pending_consolidations");
 type_name!(EffectiveBalanceUpdates, "effective_balance_updates");
 type_name!(SlashingsReset, "slashings_reset");
@@ -191,6 +194,20 @@ impl<E: EthSpec> EpochTransition<E> for PendingBalanceDeposits {
     }
 }
 
+impl<E: EthSpec> EpochTransition<E> for PendingDepositsChurn {
+    fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
+        process_epoch_single_pass(
+            state,
+            spec,
+            SinglePassConfig {
+                pending_deposits: true,
+                ..SinglePassConfig::disable_all()
+            },
+        )
+        .map(|_| ())
+    }
+}
+
 impl<E: EthSpec> EpochTransition<E> for PendingConsolidations {
     fn run(state: &mut BeaconState<E>, spec: &ChainSpec) -> Result<(), EpochProcessingError> {
         initialize_epoch_cache(state, spec)?;
@@ -387,7 +404,9 @@ impl<E: EthSpec, T: EpochTransition<E>> Case for EpochProcessing<E, T> {
         }
 
         if !fork_name.gloas_enabled()
-            && (T::name() == "builder_pending_payments" || T::name() == "ptc_window")
+            && (T::name() == "builder_pending_payments"
+                || T::name() == "ptc_window"
+                || T::name() == "pending_deposits_churn")
         {
             return false;
         }
diff --git a/testing/ef_tests/src/cases/fork_choice.rs b/testing/ef_tests/src/cases/fork_choice.rs
index 2af205ee47..8b0b74d256 100644
--- a/testing/ef_tests/src/cases/fork_choice.rs
+++ b/testing/ef_tests/src/cases/fork_choice.rs
@@ -335,15 +335,6 @@ impl<E: EthSpec> Case for ForkChoiceTest<E> {
     }
 
     fn result(&self, _case_index: usize, fork_name: ForkName) -> Result<(), Error> {
-        // TODO(gloas): We have not implemented this change to fork choice/proposer boost yet.
-        // https://github.com/sigp/lighthouse/issues/8689
-        if self.description == "voting_source_beyond_two_epoch"
-            || self.description == "justified_update_not_realized_finality"
-            || self.description == "justified_update_always_if_better"
-        {
-            return Err(Error::SkippedKnownFailure);
-        }
-
         let tester = Tester::new(self, testing_spec::<E>(fork_name))?;
 
         for step in &self.steps {
@@ -791,6 +782,7 @@ impl<E: EthSpec> Tester<E> {
                     block_delay,
                     &state,
                     PayloadVerificationStatus::Irrelevant,
+                    block.message().proposer_index(),
                     &self.harness.chain.spec,
                 );
 
diff --git a/testing/ef_tests/src/cases/operations.rs b/testing/ef_tests/src/cases/operations.rs
index f90b6f2a6e..f5c999920d 100644
--- a/testing/ef_tests/src/cases/operations.rs
+++ b/testing/ef_tests/src/cases/operations.rs
@@ -53,6 +53,15 @@ pub struct WithdrawalsPayload<E: EthSpec> {
     payload: Option<ExecutionPayload<E>>,
 }
 
+/// Newtype for testing voluntary exit churn (Gloas+).
+///
+/// The test case applies the same `process_voluntary_exit` operation as the regular
+/// `voluntary_exit` test, but under the `voluntary_exit_churn` handler directory.
+#[derive(Debug, Clone)]
+pub struct VoluntaryExitChurn {
+    exit: SignedVoluntaryExit,
+}
+
 /// Newtype for testing execution payload bids.
 #[derive(Debug, Clone, Deserialize)]
 pub struct ExecutionPayloadBidBlock<E: EthSpec> {
@@ -265,6 +274,40 @@ impl<E: EthSpec> Operation<E> for SignedVoluntaryExit {
     }
 }
 
+impl<E: EthSpec> Operation<E> for VoluntaryExitChurn {
+    type Error = BlockProcessingError;
+
+    fn handler_name() -> String {
+        "voluntary_exit_churn".into()
+    }
+
+    fn filename() -> String {
+        "voluntary_exit.ssz_snappy".into()
+    }
+
+    fn is_enabled_for_fork(fork_name: ForkName) -> bool {
+        fork_name.gloas_enabled()
+    }
+
+    fn decode(path: &Path, _fork_name: ForkName, _spec: &ChainSpec) -> Result<Self, Error> {
+        ssz_decode_file(path).map(|exit| VoluntaryExitChurn { exit })
+    }
+
+    fn apply_to(
+        &self,
+        state: &mut BeaconState<E>,
+        spec: &ChainSpec,
+        _: &Operations<E, Self>,
+    ) -> Result<(), BlockProcessingError> {
+        process_exits(
+            state,
+            std::slice::from_ref(&self.exit),
+            VerifySignatures::True,
+            spec,
+        )
+    }
+}
+
 impl<E: EthSpec> Operation<E> for BeaconBlock<E> {
     type Error = BlockProcessingError;
 
diff --git a/testing/ef_tests/src/handler.rs b/testing/ef_tests/src/handler.rs
index 96798c910c..e380f51c0a 100644
--- a/testing/ef_tests/src/handler.rs
+++ b/testing/ef_tests/src/handler.rs
@@ -340,6 +340,10 @@ impl<T, E> SszStaticHandler<T, E> {
     pub fn pre_electra() -> Self {
         Self::for_forks(ForkName::list_all()[0..5].to_vec())
     }
+
+    pub fn pre_capella() -> Self {
+        Self::for_forks(ForkName::list_all()[0..3].to_vec())
+    }
 }
 
 /// Handler for SSZ types that implement `CachedTreeHash`.
diff --git a/testing/ef_tests/src/lib.rs b/testing/ef_tests/src/lib.rs
index 0ffedc7eb8..bead5825ed 100644
--- a/testing/ef_tests/src/lib.rs
+++ b/testing/ef_tests/src/lib.rs
@@ -3,9 +3,10 @@ pub use cases::{
     BuilderPendingPayments, Case, EffectiveBalanceUpdates, Eth1DataReset, ExecutionPayloadBidBlock,
     FeatureName, HistoricalRootsUpdate, HistoricalSummariesUpdate, InactivityUpdates,
     JustificationAndFinalization, ParentExecutionPayloadBlock, ParticipationFlagUpdates,
-    ParticipationRecordUpdates, PendingBalanceDeposits, PendingConsolidations, ProposerLookahead,
-    PtcWindow, RandaoMixesReset, RegistryUpdates, RewardsAndPenalties, Slashings, SlashingsReset,
-    SyncCommitteeUpdates, WithdrawalsPayload,
+    ParticipationRecordUpdates, PendingBalanceDeposits, PendingConsolidations,
+    PendingDepositsChurn, ProposerLookahead, PtcWindow, RandaoMixesReset, RegistryUpdates,
+    RewardsAndPenalties, Slashings, SlashingsReset, SyncCommitteeUpdates, VoluntaryExitChurn,
+    WithdrawalsPayload,
 };
 pub use decode::log_file_access;
 pub use error::Error;
diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs
index 79a02d7e80..ca383efdb0 100644
--- a/testing/ef_tests/tests/tests.rs
+++ b/testing/ef_tests/tests/tests.rs
@@ -142,6 +142,12 @@ fn operations_bls_to_execution_change() {
     OperationsHandler::<MainnetEthSpec, SignedBlsToExecutionChange>::default().run();
 }
 
+#[test]
+fn operations_voluntary_exit_churn() {
+    OperationsHandler::<MinimalEthSpec, VoluntaryExitChurn>::default().run();
+    OperationsHandler::<MainnetEthSpec, VoluntaryExitChurn>::default().run();
+}
+
 #[test]
 fn sanity_blocks() {
     SanityBlocksHandler::<MinimalEthSpec>::default().run();
@@ -285,8 +291,19 @@ mod ssz_static {
     ssz_static_test!(eth1_data, Eth1Data);
     ssz_static_test!(fork, Fork);
     ssz_static_test!(fork_data, ForkData);
-    ssz_static_test!(historical_batch, HistoricalBatch<_>);
-    ssz_static_test!(pending_attestation, PendingAttestation<_>);
+    // `HistoricalBatch` was removed in Capella, so test vectors only exist for Base,
+    // Altair and Bellatrix.
+    #[test]
+    fn historical_batch() {
+        SszStaticHandler::<HistoricalBatch<MinimalEthSpec>, MinimalEthSpec>::pre_capella().run();
+        SszStaticHandler::<HistoricalBatch<MainnetEthSpec>, MainnetEthSpec>::pre_capella().run();
+    }
+    // `PendingAttestation` was removed in Altair, so test vectors only exist for Base.
+    #[test]
+    fn pending_attestation() {
+        SszStaticHandler::<PendingAttestation<MinimalEthSpec>, MinimalEthSpec>::base_only().run();
+        SszStaticHandler::<PendingAttestation<MainnetEthSpec>, MainnetEthSpec>::base_only().run();
+    }
     ssz_static_test!(proposer_slashing, ProposerSlashing);
     ssz_static_test!(
         signed_beacon_block,
@@ -899,6 +916,12 @@ fn epoch_processing_pending_balance_deposits() {
     EpochProcessingHandler::<MainnetEthSpec, PendingBalanceDeposits>::default().run();
 }
 
+#[test]
+fn epoch_processing_pending_deposits_churn() {
+    EpochProcessingHandler::<MinimalEthSpec, PendingDepositsChurn>::default().run();
+    EpochProcessingHandler::<MainnetEthSpec, PendingDepositsChurn>::default().run();
+}
+
 #[test]
 fn epoch_processing_pending_consolidations() {
     EpochProcessingHandler::<MinimalEthSpec, PendingConsolidations>::default().run();