From aa95254fdaa1a48517f267f965cb5d2b4518e1ac Mon Sep 17 00:00:00 2001
From: Chen Kai <281165273grape@gmail.com>
Date: Fri, 1 May 2026 14:23:40 +0800
Subject: [PATCH 01/23] feat(fork-choice): expose getViableHeads() for
 compliance suite

The fork-choice compliance suite (consensus-specs#3831) introduces a
`viable_for_head_roots_and_weights` check that asserts the leaves and
weights of the internal `filter_block_tree(store, justified.root)`.
Head equivalence alone is too weak to catch filtered-tree regressions.

Add `IForkChoice.getViableHeads()` that returns the viable-for-head
leaves of the filtered tree paired with their weights:

- A node is a filter_block_tree leaf iff it is viable AND has no viable
  descendants. `maybeUpdateBestChildAndDescendant` only sets `bestChild`
  to a child that `nodeLeadsToViableHead`, so `bestChild === undefined`
  iff no viable descendant. Combined with `nodeIsViableForHead`, this
  matches the spec exactly. Same approach as Teku's
  `ForkChoiceStrategy.getChainHeads`.
- Weight is converted from internal increment units to Gwei on read
  (compliance fixtures expect Gwei). Note the proposer-boost score
  contribution is also stored in increments and may round down on
  minimal preset (102 vs 102.4 ETH); attestation weight is exact, the
  rounding only surfaces while boost is active. Mainnet boost values
  are integer ETH so this is a non-issue there.
---
 packages/fork-choice/src/forkChoice/forkChoice.ts |  4 ++++
 packages/fork-choice/src/forkChoice/interface.ts  |  1 +
 packages/fork-choice/src/protoArray/protoArray.ts | 13 ++++++++++++-
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/packages/fork-choice/src/forkChoice/forkChoice.ts b/packages/fork-choice/src/forkChoice/forkChoice.ts
index b4a1cd73c747..90fd669bf714 100644
--- a/packages/fork-choice/src/forkChoice/forkChoice.ts
+++ b/packages/fork-choice/src/forkChoice/forkChoice.ts
@@ -594,6 +594,10 @@ export class ForkChoice implements IForkChoice {
     return this.protoArray.nodes.filter((node) => node.bestChild === undefined);
   }
 
+  getViableHeads(): {root: RootHex; weight: number}[] {
+    return this.protoArray.getViableHeads(this.fcStore.currentSlot);
+  }
+
   /** This is for the debug API only */
   getAllNodes(): ProtoNode[] {
     return this.protoArray.nodes;
diff --git a/packages/fork-choice/src/forkChoice/interface.ts b/packages/fork-choice/src/forkChoice/interface.ts
index 40acc201652b..e182ae04d1f4 100644
--- a/packages/fork-choice/src/forkChoice/interface.ts
+++ b/packages/fork-choice/src/forkChoice/interface.ts
@@ -119,6 +119,7 @@ export interface IForkChoice {
    * Retrieves all possible chain heads (leaves of fork choice tree).
    */
   getHeads(): ProtoBlock[];
+  getViableHeads(): {root: RootHex; weight: number}[];
   /**
    * Retrieve all nodes for the debug API.
    */
diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index f2994998e4e8..a968e3a31eb6 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1,5 +1,5 @@
 import {BitArray} from "@chainsafe/ssz";
-import {GENESIS_EPOCH, PTC_SIZE} from "@lodestar/params";
+import {EFFECTIVE_BALANCE_INCREMENT, GENESIS_EPOCH, PTC_SIZE} from "@lodestar/params";
 import {DataAvailabilityStatus, computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, RootHex, Slot} from "@lodestar/types";
 import {bitCount, toRootHex} from "@lodestar/utils";
@@ -1541,6 +1541,17 @@ export class ProtoArray {
     return correctJustified && correctFinalized;
   }
 
+  /** Weight is converted from increment units to Gwei. */
+  getViableHeads(currentSlot: Slot): {root: RootHex; weight: number}[] {
+    const result: {root: RootHex; weight: number}[] = [];
+    for (const node of this.nodes) {
+      if (node.bestChild === undefined && this.nodeIsViableForHead(node, currentSlot)) {
+        result.push({root: node.blockRoot, weight: node.weight * EFFECTIVE_BALANCE_INCREMENT});
+      }
+    }
+    return result;
+  }
+
   /**
    * Return `true` if `node` is equal to or a descendant of the finalized node.
    * This function helps improve performance of nodeIsViableForHead a lot by avoiding

From 5df6c346a4617db75ea208ed8df7d3bc2f40bb37 Mon Sep 17 00:00:00 2001
From: Chen Kai <281165273grape@gmail.com>
Date: Fri, 1 May 2026 14:24:06 +0800
Subject: [PATCH 02/23] feat(beacon-node): integrate fork_choice_compliance
 spec runner
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wire the consensus-specs Fork Choice Compliance suite (#3831) into
the existing `forkChoiceTest` runner. The on-disk layout matches the
standard spec-test layout
(`tests/<preset>/<fork>/fork_choice_compliance/<handler>/<suite>/<case>/`),
so it slots in alongside `fork_choice` and `sync` runners.

Three test-only accommodations the compliance fixtures require:

1. `bls_setting: 2` — every compliance fixture uses placeholder
   signatures. Pass `validSignatures: testcase.meta?.bls_setting !==
   BigInt(1)` to `chain.processBlock` so verification short-circuits.
   Standard `fork_choice` fixtures use `bls_setting: 1` so behavior
   there is unchanged.

2. `BLOCK_ERROR_ALREADY_KNOWN` — compliance fixtures intentionally
   re-import the same block (`dup_shift` mutations in their
   `meta.yaml`). Spec semantics for `on_block(store, known_block)` is
   a no-op success. Production block import correctly rejects with
   ALREADY_KNOWN; this runner treats that case as success only when
   the step is `valid: true`.

3. Cross-epoch attestation shuffling — `on_attestation` decodes
   aggregation_bits using the state at the attestation's target
   checkpoint, not the head state. The runner now resolves the right
   shuffling via ShufflingCache + regen (mirroring the production
   validation path) instead of `headState.epochCtx.getIndexedAttestation`,
   which only worked when the attestation's epoch happened to be in
   the head's epoch cache (±1 epoch) and broke on cross-epoch fork
   attestations surfaced by the compliance suite.

Adds support for two compliance-only check fields:

- `viable_for_head_roots_and_weights` (consensus-specs#3831): compared
  via `getViableHeads()`. Both sides are sorted by root before
  comparison since the spec doesn't fix order.
- `head_payload_status` (gloas): mapped between our internal enum
  ordering (PENDING=0, EMPTY=1, FULL=2) and spec ordering (EMPTY=0,
  FULL=1, PENDING=2).

Pass rate against the latest comptests workflow `small.tar.gz` artifact:

  fulu/fork_choice_compliance: 253/1472 cases pass (17.2%)

Top remaining failures:
- ~80% `Invalid proposer boost root` — consensus-specs#4807 introduced
  a `block.proposer_index == get_beacon_proposer_index(head_state)`
  guard in `update_proposer_boost_root` that we do not yet implement;
  affects all forks (not just gloas equivocation handling). Tracked
  for follow-up alongside #9233.
- ~1% `Invalid viable heads` — proposer-boost rounding on minimal
  preset (see `getViableHeads()` weight note).
---
 .../test/spec/presets/fork_choice.test.ts     | 53 ++++++++++++++++---
 1 file changed, 45 insertions(+), 8 deletions(-)

diff --git a/packages/beacon-node/test/spec/presets/fork_choice.test.ts b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
index bdc72a6b4e61..29326a81d0e4 100644
--- a/packages/beacon-node/test/spec/presets/fork_choice.test.ts
+++ b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
@@ -15,6 +15,7 @@ import {
   ForkPreFulu,
   ForkPreGloas,
   ForkSeq,
+  SLOTS_PER_EPOCH,
 } from "@lodestar/params";
 import {InputType} from "@lodestar/spec-test-util";
 import {
@@ -25,6 +26,7 @@ import {
   createCachedBeaconState,
   createPubkeyCache,
   createSingleSignatureSetFromComponents,
+  getIndexedAttestation,
   getPayloadAttestationDataSigningRoot,
   isExecutionStateType,
   isGloasStateType,
@@ -57,9 +59,11 @@ import {
   verifyExecutionPayloadEnvelope,
   verifyExecutionPayloadEnvelopeSignature,
 } from "../../../src/chain/blocks/verifyExecutionPayloadEnvelope.js";
+import {BlockError, BlockErrorCode} from "../../../src/chain/errors/blockError.js";
 import {BeaconChain, ChainEvent} from "../../../src/chain/index.js";
 import {defaultChainOptions} from "../../../src/chain/options.js";
 import {RegenCaller} from "../../../src/chain/regen/index.js";
+import {getShufflingForAttestationVerification} from "../../../src/chain/validation/attestation.js";
 import {validateFuluBlockDataColumnSidecars} from "../../../src/chain/validation/dataColumnSidecar.js";
 import {ZERO_HASH_HEX} from "../../../src/constants/constants.js";
 import {ExecutionPayloadStatus} from "../../../src/execution/engine/interface.js";
@@ -187,12 +191,26 @@ const forkChoiceTest =
               logger.debug(`Step ${i}/${stepsLen} attestation`, {root: step.attestation, valid: isValid});
               const attestation = testcase.attestations.get(step.attestation);
               if (!attestation) throw Error(`No attestation ${step.attestation}`);
-              const headState = chain.getHeadState() as BeaconStateView;
               const attDataRootHex = toHexString(sszTypesFor(fork).AttestationData.hashTreeRoot(attestation.data));
-              const indexedAttestation = headState.cachedState.epochCtx.getIndexedAttestation(
-                ForkSeq[fork],
-                attestation
+
+              // `on_attestation` decodes aggregation_bits with the shuffling at the attestation's
+              // target checkpoint, not the head state — resolve it via ShufflingCache + regen so
+              // cross-epoch fork attestations (surfaced by the compliance suite) decode correctly.
+              const attHeadBlock = chain.forkChoice.getBlockHexDefaultStatus(toHex(attestation.data.beaconBlockRoot));
+              if (attHeadBlock === null) {
+                logger.debug(`Step ${i}/${stepsLen} skip attestation: head block unknown`, {
+                  blockRoot: toHex(attestation.data.beaconBlockRoot),
+                });
+                continue;
+              }
+              const attEpoch = Math.floor(attestation.data.slot / SLOTS_PER_EPOCH);
+              const shuffling = await getShufflingForAttestationVerification(
+                chain,
+                attEpoch,
+                attHeadBlock,
+                RegenCaller.validateGossipAttestation
               );
+              const indexedAttestation = getIndexedAttestation(shuffling, ForkSeq[fork], attestation);
               try {
                 chain.forkChoice.onAttestation(indexedAttestation, attDataRootHex);
                 if (!isValid) throw Error("Expect error since this is a negative test");
@@ -463,10 +481,19 @@ const forkChoiceTest =
                   seenTimestampSec: tickTime,
                   validBlobSidecars: BlobSidecarValidation.Full,
                   importAttestations: AttestationImportOpt.Force,
+                  validSignatures: testcase.meta?.bls_setting !== BigInt(1),
                 });
                 if (!isValid) throw Error("Expect error since this is a negative test");
               } catch (e) {
-                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
+                // Spec `on_block` is a no-op success on a known block; lodestar's production
+                // import path rejects with ALREADY_KNOWN. Treat as success in the spec runner.
+                if (isValid && e instanceof BlockError && e.type.code === BlockErrorCode.ALREADY_KNOWN) {
+                  logger.debug(`Step ${i}/${stepsLen} block already known — treating as no-op success`, {
+                    id: step.block,
+                  });
+                } else if (isValid || (e as Error).message === "Expect error since this is a negative test") {
+                  throw e;
+                }
               }
             }
 
@@ -597,15 +624,23 @@ const forkChoiceTest =
                 );
               }
               if (step.checks.head_payload_status !== undefined) {
-                // Map our PayloadStatus enum to spec's numbering:
-                // Spec: EMPTY=0, FULL=1, PENDING=2
-                // Ours: PENDING=0, EMPTY=1, FULL=2
+                // Spec: EMPTY=0, FULL=1, PENDING=2; Ours: PENDING=0, EMPTY=1, FULL=2
                 const payloadStatusToSpec: Record<number, number> = {0: 2, 1: 0, 2: 1};
                 expect(payloadStatusToSpec[head.payloadStatus]).toEqualWithMessage(
                   bnToNum(step.checks.head_payload_status),
                   `Invalid head payload status at step ${i}`
                 );
               }
+              if (step.checks.viable_for_head_roots_and_weights !== undefined) {
+                const expected = step.checks.viable_for_head_roots_and_weights
+                  .map((entry) => ({root: entry.root, weight: bnToNum(entry.weight)}))
+                  .sort((a, b) => a.root.localeCompare(b.root));
+                const actual = (chain.forkChoice as ForkChoice)
+                  .getViableHeads()
+                  .map(({root, weight}) => ({root, weight}))
+                  .sort((a, b) => a.root.localeCompare(b.root));
+                expect(actual).toEqualWithMessage(expected, `Invalid viable heads at step ${i}`);
+              }
               if (step.checks.should_override_forkchoice_update) {
                 const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
                 const result = chain.forkChoice.shouldOverrideForkChoiceUpdate(
@@ -856,6 +891,7 @@ type Checks = {
       block_root: RootHex;
       votes: (boolean | null)[];
     };
+    viable_for_head_roots_and_weights?: {root: RootHex; weight: bigint}[];
   };
 };
 
@@ -911,4 +947,5 @@ function isCheck(step: Step): step is Checks {
 specTestIterator(path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET), {
   fork_choice: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: false})},
   sync: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: true})},
+  fork_choice_compliance: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: false})},
 });

From 014ef47c850c78675552b0513f4a1a1ae74b5ebb Mon Sep 17 00:00:00 2001
From: Chen Kai <281165273grape@gmail.com>
Date: Wed, 1 Jul 2026 03:44:47 -0400
Subject: [PATCH 03/23] fix(fork-choice): restrict getViableHeads to justified
 subtree, dedupe gloas variants
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three corrections to the compliance-only getViableHeads getter, plus an
API-surface trim:

- Restrict leaves to descendants of the justified checkpoint block: the
  spec's get_filtered_block_tree is rooted at store.justified_checkpoint,
  so iterating all proto-array nodes over-included FFG-viable leaves
  hanging off the finalized checkpoint on branches not under the current
  justified checkpoint (~87 of 100 'Invalid viable heads' compliance
  failures were this, not proposer-boost rounding as previously assumed).
  The descendant walk follows parent links to the justified root — a
  slot-based getAncestor lookup returns the node itself for leaves whose
  own slot equals the justified epoch start slot — and stops early once
  it passes the justified block's slot (parent slots are non-increasing).

- Emit each block root at most once: gloas payload-status variants share
  a blockRoot and more than one can be a leaf (EMPTY and FULL are both
  parented under PENDING), which produced duplicate roots that broke the
  index-paired comparison in the compliance check. Which variant's weight
  the spec expects is part of the open gloas vote-attribution divergence;
  keep the heaviest qualifying variant deterministically.

- Drop getViableHeads from IForkChoice: it is compliance-test-only and
  its single caller accesses the ForkChoice class directly.

Verified against consensus-specs compliance vectors (run 28413328593,
minimal fulu): viable-head root-set failures 100 -> 0; standard minimal
fork_choice+sync spectests unaffected (397 passed).
---
 .../fork-choice/src/forkChoice/interface.ts   |  1 -
 .../fork-choice/src/protoArray/protoArray.ts  | 45 +++++++++++++++++--
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/packages/fork-choice/src/forkChoice/interface.ts b/packages/fork-choice/src/forkChoice/interface.ts
index e182ae04d1f4..40acc201652b 100644
--- a/packages/fork-choice/src/forkChoice/interface.ts
+++ b/packages/fork-choice/src/forkChoice/interface.ts
@@ -119,7 +119,6 @@ export interface IForkChoice {
    * Retrieves all possible chain heads (leaves of fork choice tree).
    */
   getHeads(): ProtoBlock[];
-  getViableHeads(): {root: RootHex; weight: number}[];
   /**
    * Retrieve all nodes for the debug API.
    */
diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index a968e3a31eb6..0c0ebe201f6b 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1543,13 +1543,50 @@ export class ProtoArray {
 
   /** Weight is converted from increment units to Gwei. */
   getViableHeads(currentSlot: Slot): {root: RootHex; weight: number}[] {
-    const result: {root: RootHex; weight: number}[] = [];
+    // Mirror the spec's `get_filtered_block_tree`, which is rooted at the store's justified
+    // checkpoint: a viable head is a leaf (no viable descendant, i.e. `bestChild === undefined`)
+    // that descends from the justified checkpoint block AND is itself viable for head. Iterating
+    // all nodes without the justified-descendant filter would wrongly include FFG-viable leaves
+    // that hang off the finalized checkpoint on a branch not under the current justified checkpoint.
+    const justifiedStatus = this.getDefaultVariant(this.justifiedRoot);
+    const justifiedSlot =
+      justifiedStatus !== undefined ? this.getNode(this.justifiedRoot, justifiedStatus)?.slot : undefined;
+    // Gloas payload-status variants share a blockRoot and more than one can be a leaf (EMPTY and
+    // FULL are both parented under PENDING); the spec's filtered tree is keyed by block root, so
+    // emit each root at most once. Which variant's weight the spec expects is an open gloas
+    // divergence — deterministically keep the heaviest qualifying variant.
+    const weightByRoot = new Map<RootHex, number>();
     for (const node of this.nodes) {
-      if (node.bestChild === undefined && this.nodeIsViableForHead(node, currentSlot)) {
-        result.push({root: node.blockRoot, weight: node.weight * EFFECTIVE_BALANCE_INCREMENT});
+      if (node.bestChild !== undefined || !this.nodeIsViableForHead(node, currentSlot)) {
+        continue;
+      }
+      if (this.justifiedEpoch !== GENESIS_EPOCH && !this.descendsFromJustified(node, justifiedSlot)) {
+        continue;
+      }
+      const prev = weightByRoot.get(node.blockRoot);
+      if (prev === undefined || node.weight > prev) {
+        weightByRoot.set(node.blockRoot, node.weight);
       }
     }
-    return result;
+    return Array.from(weightByRoot.entries()).map(([root, weight]) => ({
+      root,
+      weight: weight * EFFECTIVE_BALANCE_INCREMENT,
+    }));
+  }
+
+  /**
+   * True if `node` is the justified checkpoint block or one of its descendants.
+   * Parent slots are non-increasing, so the walk stops once it passes the justified block's slot.
+   */
+  private descendsFromJustified(node: ProtoNode, justifiedSlot: Slot | undefined): boolean {
+    let current: ProtoNode | undefined = node;
+    while (current !== undefined && (justifiedSlot === undefined || current.slot >= justifiedSlot)) {
+      if (current.blockRoot === this.justifiedRoot) {
+        return true;
+      }
+      current = current.parent !== undefined ? this.getNodeByIndex(current.parent) : undefined;
+    }
+    return false;
   }
 
   /**

From 4d1bcfa6803c51724890b950e7a6585c9a61a570 Mon Sep 17 00:00:00 2001
From: Chen Kai <281165273grape@gmail.com>
Date: Wed, 1 Jul 2026 03:45:22 -0400
Subject: [PATCH 04/23] test(spec): align fork-choice runner with spec
 test-format semantics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Changes to the shared fork-choice runner, each anchored to a test-format
or spec contract (not compliance-suite identity), so they apply uniformly
to fork_choice/sync/fork_choice_compliance:

- Register fork_choice_compliance in coveredTestRunners: without it every
  other spec suite iterating the same fixture tree (ssz_static, operations,
  sanity, ...) throws 'No test runner for fork_choice_compliance' once
  compliance fixtures are downloaded.

- Attestation timing precondition: spec validate_on_attestation requires
  get_current_slot(store) >= data.slot + 1. Lodestar enforces this 1-slot
  delay in the gossip/attestation-pool layer, not forkChoice.onAttestation;
  the runner calls onAttestation directly, so replicate the precondition
  (Lighthouse's runner excuses the same case post-hoc: DidntFail tolerated
  when data.slot >= current_slot). Clears all 298 negative-attestation
  compliance failures.

- Attestation step hardening: an unknown beacon block root on a valid:true
  step now fails loudly instead of being silently skipped, and the
  shuffling resolution runs inside the negative-test try/catch so that
  errors on valid:false steps (e.g. attesting to a future block) count as
  the expected rejection instead of crashing the case.

- Skip gloas ePBS signature verification unless bls_setting == 1: the
  test format mandates skipping verification for placeholder signatures
  (bls_setting: 2), which the block-import path already honors via
  validSignatures. Extend the same handling to the execution_payload and
  payload_attestation_message steps (Teku disables BLS at spec level for
  bls_setting IGNORED; Lighthouse compiles compliance under fake_crypto).

- Split viable_for_head_roots_and_weights into exact root-set equality
  plus a 1.2 ETH weight tolerance: the root set is epoch-determined and
  must match exactly (this strictness caught the getViableHeads
  justified-subtree bug; Teku's containsAll would not), while weights are
  stored in EFFECTIVE_BALANCE_INCREMENT units so the proposer-boost score
  quantizes to whole ETH; the divergence is bounded by
  (100 - gcd(P,100) + P)/100 = 1.2 ETH independent of preset.

Compliance (run 28413328593, minimal): fulu 1459/1472 (99.1%), remaining
11 proposer-boost-root divergences + 1-2 timeouts; gloas 200/1472, blocked
by processPayloadAttestation verifying signatures unconditionally (ignores
verifySignatures; not batched in getBlockSignatureSets) and a payload-status
vote-attribution divergence (weight diffs are exact multiples of 32 ETH
between EMPTY/FULL variants of the same root) — both documented follow-ups,
out of scope here. Known accommodation limit: ALREADY_KNOWN treated as
no-op success cannot re-apply proposer boost for a timely duplicate the
way spec on_block re-processing would. Standard minimal fork_choice+sync:
397 passed, unchanged.
---
 .../test/spec/presets/fork_choice.test.ts     | 138 ++++++++++++------
 .../test/spec/utils/specTestIterator.ts       |   1 +
 2 files changed, 94 insertions(+), 45 deletions(-)

diff --git a/packages/beacon-node/test/spec/presets/fork_choice.test.ts b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
index 29326a81d0e4..62b81cd3c869 100644
--- a/packages/beacon-node/test/spec/presets/fork_choice.test.ts
+++ b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
@@ -8,6 +8,7 @@ import {CheckpointWithHex, ExecutionStatus, ForkChoice} from "@lodestar/fork-cho
 import {testLogger} from "@lodestar/logger/test-utils";
 import {
   ACTIVE_PRESET,
+  EFFECTIVE_BALANCE_INCREMENT,
   ForkPostDeneb,
   ForkPostFulu,
   ForkPostGloas,
@@ -15,7 +16,6 @@ import {
   ForkPreFulu,
   ForkPreGloas,
   ForkSeq,
-  SLOTS_PER_EPOCH,
 } from "@lodestar/params";
 import {InputType} from "@lodestar/spec-test-util";
 import {
@@ -23,6 +23,7 @@ import {
   BeaconStateView,
   DataAvailabilityStatus,
   IBeaconStateViewGloas,
+  computeEpochAtSlot,
   createCachedBeaconState,
   createPubkeyCache,
   createSingleSignatureSetFromComponents,
@@ -193,25 +194,43 @@ const forkChoiceTest =
               if (!attestation) throw Error(`No attestation ${step.attestation}`);
               const attDataRootHex = toHexString(sszTypesFor(fork).AttestationData.hashTreeRoot(attestation.data));
 
+              // Spec `validate_on_attestation` requires `get_current_slot(store) >= attestation.data.slot + 1`
+              // (an attestation may only influence fork choice from the slot AFTER it was created). Lodestar
+              // enforces this 1-slot delay in the gossip/attestation-pool layer, not in `forkChoice.onAttestation`,
+              // so replicate the precondition here since the runner calls `onAttestation` directly.
+              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
+              if (currentSlot < attestation.data.slot + 1) {
+                if (isValid) {
+                  throw Error(`Attestation not yet 1 slot old but marked valid at step ${i}`);
+                }
+                logger.debug(
+                  `Step ${i}/${stepsLen} skip attestation: not yet 1 slot old (spec on_attestation rejects)`,
+                  {
+                    attSlot: attestation.data.slot,
+                    currentSlot,
+                  }
+                );
+                continue;
+              }
+
               // `on_attestation` decodes aggregation_bits with the shuffling at the attestation's
               // target checkpoint, not the head state — resolve it via ShufflingCache + regen so
               // cross-epoch fork attestations (surfaced by the compliance suite) decode correctly.
+              // The resolution runs inside the try so that errors on `valid: false` steps (e.g.
+              // attesting to a future block) count as the expected rejection.
               const attHeadBlock = chain.forkChoice.getBlockHexDefaultStatus(toHex(attestation.data.beaconBlockRoot));
-              if (attHeadBlock === null) {
-                logger.debug(`Step ${i}/${stepsLen} skip attestation: head block unknown`, {
-                  blockRoot: toHex(attestation.data.beaconBlockRoot),
-                });
-                continue;
+              if (attHeadBlock === null && isValid) {
+                throw Error(`Attestation beacon block root unknown to fork choice at step ${i}`);
               }
-              const attEpoch = Math.floor(attestation.data.slot / SLOTS_PER_EPOCH);
-              const shuffling = await getShufflingForAttestationVerification(
-                chain,
-                attEpoch,
-                attHeadBlock,
-                RegenCaller.validateGossipAttestation
-              );
-              const indexedAttestation = getIndexedAttestation(shuffling, ForkSeq[fork], attestation);
               try {
+                if (attHeadBlock === null) throw Error("Unknown attestation head block (expected rejection)");
+                const shuffling = await getShufflingForAttestationVerification(
+                  chain,
+                  computeEpochAtSlot(attestation.data.slot),
+                  attHeadBlock,
+                  RegenCaller.validateGossipAttestation
+                );
+                const indexedAttestation = getIndexedAttestation(shuffling, ForkSeq[fork], attestation);
                 chain.forkChoice.onAttestation(indexedAttestation, attDataRootHex);
                 if (!isValid) throw Error("Expect error since this is a negative test");
               } catch (e) {
@@ -269,27 +288,31 @@ const forkChoiceTest =
                     );
                   }
 
-                  // Signature verification, matching the `validateGossipPayloadAttestationMessage` flow
-                  const validatorPubkey = pubkeyCache.get(payloadAttestationMessage.validatorIndex);
-                  if (!validatorPubkey) {
-                    throw Error(`Unknown validator index ${payloadAttestationMessage.validatorIndex}`);
-                  }
-                  const signatureSet = createSingleSignatureSetFromComponents(
-                    validatorPubkey,
-                    getPayloadAttestationDataSigningRoot(beaconConfig, payloadAttestationMessage.data),
-                    payloadAttestationMessage.signature
-                  );
-                  let signatureValidity: boolean;
-                  try {
-                    signatureValidity = await chain.bls.verifySignatureSets([signatureSet], {
-                      verifyOnMainThread: true,
-                      batchable: true,
-                      priority: true,
-                    });
-                  } catch {
-                    signatureValidity = false;
+                  // Signature verification (matching `validateGossipPayloadAttestationMessage`) — skipped for
+                  // bls_setting !== 1: compliance fixtures use placeholder signatures (bls_setting: 2), so the
+                  // spec reference runner does not verify. Mirror the block-import accommodation (`validSignatures`).
+                  if (testcase.meta?.bls_setting === BigInt(1)) {
+                    const validatorPubkey = pubkeyCache.get(payloadAttestationMessage.validatorIndex);
+                    if (!validatorPubkey) {
+                      throw Error(`Unknown validator index ${payloadAttestationMessage.validatorIndex}`);
+                    }
+                    const signatureSet = createSingleSignatureSetFromComponents(
+                      validatorPubkey,
+                      getPayloadAttestationDataSigningRoot(beaconConfig, payloadAttestationMessage.data),
+                      payloadAttestationMessage.signature
+                    );
+                    let signatureValidity: boolean;
+                    try {
+                      signatureValidity = await chain.bls.verifySignatureSets([signatureSet], {
+                        verifyOnMainThread: true,
+                        batchable: true,
+                        priority: true,
+                      });
+                    } catch {
+                      signatureValidity = false;
+                    }
+                    if (!signatureValidity) throw Error("Invalid payload attestation signature");
                   }
-                  if (!signatureValidity) throw Error("Invalid payload attestation signature");
 
                   chain.forkChoice.notifyPtcMessages(
                     blockRoot,
@@ -524,16 +547,20 @@ const forkChoiceTest =
                 );
                 verifyExecutionPayloadEnvelope(beaconConfig, blockState as IBeaconStateViewGloas, envelope.message);
 
-                // Verify signature
-                const sigValid = await verifyExecutionPayloadEnvelopeSignature(
-                  beaconConfig,
-                  blockState as IBeaconStateViewGloas,
-                  pubkeyCache,
-                  envelope,
-                  blockState.latestBlockHeader.proposerIndex,
-                  chain.bls
-                );
-                if (!sigValid) throw Error("Invalid execution payload envelope signature");
+                // Verify signature — skipped for bls_setting !== 1: compliance fixtures use placeholder
+                // signatures (bls_setting: 2), so the spec reference runner does not verify. Mirror the
+                // block-import accommodation (`validSignatures` above).
+                if (testcase.meta?.bls_setting === BigInt(1)) {
+                  const sigValid = await verifyExecutionPayloadEnvelopeSignature(
+                    beaconConfig,
+                    blockState as IBeaconStateViewGloas,
+                    pubkeyCache,
+                    envelope,
+                    blockState.latestBlockHeader.proposerIndex,
+                    chain.bls
+                  );
+                  if (!sigValid) throw Error("Invalid execution payload envelope signature");
+                }
 
                 // Add predefined VALID status for the payload's block hash so the EL mock accepts it
                 executionEngineBackend.addPredefinedPayloadStatus(blockHash, {
@@ -639,7 +666,28 @@ const forkChoiceTest =
                   .getViableHeads()
                   .map(({root, weight}) => ({root, weight}))
                   .sort((a, b) => a.root.localeCompare(b.root));
-                expect(actual).toEqualWithMessage(expected, `Invalid viable heads at step ${i}`);
+
+                // The set of viable heads is determined by justified/finalized epochs, not weight,
+                // so it must match exactly. Comparing the root sets (not a subset) also rejects a
+                // degenerate empty result.
+                expect(actual.map((h) => h.root)).toEqualWithMessage(
+                  expected.map((h) => h.root),
+                  `Invalid viable head roots at step ${i}`
+                );
+
+                // Weights are stored in EFFECTIVE_BALANCE_INCREMENT units, so the proposer-boost
+                // score is floored to whole ETH while the spec keeps Gwei precision. Attestation
+                // weight is exact, so the per-head divergence is only the boost quantization, bounded
+                // by (100 - gcd(PROPOSER_SCORE_BOOST, 100) + PROPOSER_SCORE_BOOST) / 100 = 1.2 ETH,
+                // independent of SLOTS_PER_EPOCH and total balance. Compare within that bound.
+                const tolerance = 1.2 * EFFECTIVE_BALANCE_INCREMENT;
+                for (const [k, {root, weight}] of actual.entries()) {
+                  const diff = Math.abs(weight - expected[k].weight);
+                  expect(
+                    diff,
+                    `Viable head ${root} weight off by ${diff} Gwei (> 1.2 ETH) at step ${i}`
+                  ).toBeLessThanOrEqual(tolerance);
+                }
               }
               if (step.checks.should_override_forkchoice_update) {
                 const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
diff --git a/packages/beacon-node/test/spec/utils/specTestIterator.ts b/packages/beacon-node/test/spec/utils/specTestIterator.ts
index 66592383c4d5..ae0e5da02f41 100644
--- a/packages/beacon-node/test/spec/utils/specTestIterator.ts
+++ b/packages/beacon-node/test/spec/utils/specTestIterator.ts
@@ -34,6 +34,7 @@ const coveredTestRunners = [
   "finality",
   "fork",
   "fork_choice",
+  "fork_choice_compliance",
   "sync",
   "fork",
   "genesis",

From c0a24d83658e6164df0d4ee2fa24c9f02f6961ea Mon Sep 17 00:00:00 2001
From: Chen Kai <281165273grape@gmail.com>
Date: Mon, 6 Jul 2026 08:35:25 -0400
Subject: [PATCH 05/23] refactor(fork-choice): collapse justified-slot lookup
 in getViableHeads

Use the single getDefaultNodeIndex + getNodeByIndex idiom already used
elsewhere in protoArray instead of the two-hop getDefaultVariant + getNode
lookup. Semantically identical for all variant cases (pre-gloas FULL,
gloas PENDING, absent root); drops one redundant indices map lookup and
removes an unreachable throw path.
---
 packages/fork-choice/src/protoArray/protoArray.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index 0c0ebe201f6b..ac23ad8d018b 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1548,9 +1548,8 @@ export class ProtoArray {
     // that descends from the justified checkpoint block AND is itself viable for head. Iterating
     // all nodes without the justified-descendant filter would wrongly include FFG-viable leaves
     // that hang off the finalized checkpoint on a branch not under the current justified checkpoint.
-    const justifiedStatus = this.getDefaultVariant(this.justifiedRoot);
-    const justifiedSlot =
-      justifiedStatus !== undefined ? this.getNode(this.justifiedRoot, justifiedStatus)?.slot : undefined;
+    const justifiedIndex = this.getDefaultNodeIndex(this.justifiedRoot);
+    const justifiedSlot = justifiedIndex !== undefined ? this.getNodeByIndex(justifiedIndex)?.slot : undefined;
     // Gloas payload-status variants share a blockRoot and more than one can be a leaf (EMPTY and
     // FULL are both parented under PENDING); the spec's filtered tree is keyed by block root, so
     // emit each root at most once. Which variant's weight the spec expects is an open gloas

From 118ef89787cd487edb9635b808be1f361fa104d8 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 15 Jul 2026 23:36:12 -0700
Subject: [PATCH 06/23] fix: correct compliance runner semantics for alpha.12
 vectors

- getViableHeads(): emit one entry per gloas payload-status variant
  (root, payload_status, weight) per consensus-specs #5393; drop the
  dedupe-by-root heuristic; return increment-unit weights
- runner: read nested checks.head.payload_status (alpha.12 shape),
  replacing the dead flat head_payload_status key
- runner: exact viable-head weight comparison via proposer-boost
  emulation (bigint) instead of the 1.2 ETH tolerance; normalizes the
  documented boost-quantization divergence using the vector's expected
  boost root and the production getCommitteeFraction
- runner: payload-attestation steps now reject slot mismatch and
  non-PTC validators, and fail on unexpectedly-successful negative tests
- specTestIterator: compose SkipOpts.skippedTests with runner-local
  shouldSkip (was silently ignored for fork_choice); gate
  fork_choice_compliance behind RUN_FORK_CHOICE_COMPLIANCE=1; defer
  gloas compliance suite

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../test/spec/presets/fork_choice.test.ts     | 136 +++++++++++++-----
 .../test/spec/utils/specTestIterator.ts       |  23 ++-
 .../fork-choice/src/forkChoice/forkChoice.ts  |  12 +-
 packages/fork-choice/src/index.ts             |   2 +-
 .../fork-choice/src/protoArray/protoArray.ts  |  25 ++--
 5 files changed, 144 insertions(+), 54 deletions(-)

diff --git a/packages/beacon-node/test/spec/presets/fork_choice.test.ts b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
index 62b81cd3c869..377df0ef9e05 100644
--- a/packages/beacon-node/test/spec/presets/fork_choice.test.ts
+++ b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
@@ -4,7 +4,7 @@ import {expect} from "vitest";
 import {toHexString} from "@chainsafe/ssz";
 import {createBeaconConfig} from "@lodestar/config";
 import {getConfig} from "@lodestar/config/test-utils";
-import {CheckpointWithHex, ExecutionStatus, ForkChoice} from "@lodestar/fork-choice";
+import {CheckpointWithHex, ExecutionStatus, ForkChoice, getCommitteeFraction} from "@lodestar/fork-choice";
 import {testLogger} from "@lodestar/logger/test-utils";
 import {
   ACTIVE_PRESET,
@@ -16,6 +16,7 @@ import {
   ForkPreFulu,
   ForkPreGloas,
   ForkSeq,
+  SLOTS_PER_EPOCH,
 } from "@lodestar/params";
 import {InputType} from "@lodestar/spec-test-util";
 import {
@@ -268,7 +269,14 @@ const forkChoiceTest =
                   throw Error(`Block not found for root ${blockRoot}`);
                 }
 
-                if (protoBlock.slot === payloadAttestationMessage.data.slot) {
+                // Spec `on_payload_attestation_message` asserts the attested block is from the
+                // message's slot — a mismatch is a rejection, not a silent no-op.
+                if (protoBlock.slot !== payloadAttestationMessage.data.slot) {
+                  throw Error(
+                    `Block slot ${protoBlock.slot} does not match payload attestation slot ${payloadAttestationMessage.data.slot}`
+                  );
+                }
+                {
                   const blockState = await chain.regen.getBlockSlotState(
                     protoBlock,
                     payloadAttestationMessage.data.slot,
@@ -281,6 +289,13 @@ const forkChoiceTest =
                     payloadAttestationMessage.data.slot
                   );
 
+                  // Spec asserts the validator is a PTC member for the slot
+                  if (ptcIndices.length === 0) {
+                    throw Error(
+                      `Validator ${payloadAttestationMessage.validatorIndex} not in PTC for slot ${payloadAttestationMessage.data.slot}`
+                    );
+                  }
+
                   // Slot check, matching the `validateGossipPayloadAttestationMessage` flow
                   if (clock.currentSlot !== payloadAttestationMessage.data.slot) {
                     throw Error(
@@ -322,6 +337,7 @@ const forkChoiceTest =
                     payloadAttestationMessage.data.blobDataAvailable
                   );
                 }
+                if (!isValid) throw Error("Expect error since this is a negative test");
               } catch (e) {
                 if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
               }
@@ -604,12 +620,21 @@ const forkChoiceTest =
               // Forkchoice head is computed lazily only on request
               const head = (chain.forkChoice as ForkChoice).updateHead();
               const proposerBootRoot = (chain.forkChoice as ForkChoice).getProposerBoostRoot();
+              // Spec: EMPTY=0, FULL=1, PENDING=2; Ours: PENDING=0, EMPTY=1, FULL=2
+              const payloadStatusToSpec: Record<number, number> = {0: 2, 1: 0, 2: 1};
 
               if (step.checks.head !== undefined) {
                 expect({slot: head.slot, root: head.blockRoot}).toEqualWithMessage(
                   {slot: bnToNum(step.checks.head.slot), root: step.checks.head.root},
                   `Invalid head at step ${i}`
                 );
+                // Gloas and later: payload_status is nested inside the head check
+                if (step.checks.head.payload_status !== undefined) {
+                  expect(payloadStatusToSpec[head.payloadStatus]).toEqualWithMessage(
+                    bnToNum(step.checks.head.payload_status),
+                    `Invalid head payload status at step ${i}`
+                  );
+                }
               }
               if (step.checks.proposer_boost_root !== undefined) {
                 expect(proposerBootRoot).toEqualWithMessage(
@@ -650,43 +675,84 @@ const forkChoiceTest =
                   `Invalid proposer head at step ${i}`
                 );
               }
-              if (step.checks.head_payload_status !== undefined) {
-                // Spec: EMPTY=0, FULL=1, PENDING=2; Ours: PENDING=0, EMPTY=1, FULL=2
-                const payloadStatusToSpec: Record<number, number> = {0: 2, 1: 0, 2: 1};
-                expect(payloadStatusToSpec[head.payloadStatus]).toEqualWithMessage(
-                  bnToNum(step.checks.head_payload_status),
-                  `Invalid head payload status at step ${i}`
-                );
-              }
               if (step.checks.viable_for_head_roots_and_weights !== undefined) {
+                // Entries are identified by (root, payload_status, weight) per
+                // https://github.com/ethereum/consensus-specs/pull/5393 — gloas EMPTY/FULL
+                // variants of one block root are separate entries. Pre-gloas vectors omit
+                // payload_status (every pre-gloas node is FULL internally).
+                const isGloas = ForkSeq[fork] >= ForkSeq.gloas;
                 const expected = step.checks.viable_for_head_roots_and_weights
-                  .map((entry) => ({root: entry.root, weight: bnToNum(entry.weight)}))
-                  .sort((a, b) => a.root.localeCompare(b.root));
+                  .map((entry) => ({
+                    root: entry.root,
+                    payloadStatus: entry.payload_status !== undefined ? bnToNum(entry.payload_status) : undefined,
+                    weightGwei: entry.weight,
+                  }))
+                  .sort(cmpViableHead);
                 const actual = (chain.forkChoice as ForkChoice)
                   .getViableHeads()
-                  .map(({root, weight}) => ({root, weight}))
-                  .sort((a, b) => a.root.localeCompare(b.root));
+                  .map(({root, payloadStatus, weight}) => ({
+                    root,
+                    payloadStatus: isGloas ? payloadStatusToSpec[payloadStatus] : undefined,
+                    weightGwei: BigInt(weight) * BigInt(EFFECTIVE_BALANCE_INCREMENT),
+                  }))
+                  .sort(cmpViableHead);
 
                 // The set of viable heads is determined by justified/finalized epochs, not weight,
-                // so it must match exactly. Comparing the root sets (not a subset) also rejects a
-                // degenerate empty result.
-                expect(actual.map((h) => h.root)).toEqualWithMessage(
-                  expected.map((h) => h.root),
+                // so identity must match exactly. Comparing the full sets (not a subset) also
+                // rejects a degenerate empty result.
+                expect(actual.map(({root, payloadStatus}) => ({root, payloadStatus}))).toEqualWithMessage(
+                  expected.map(({root, payloadStatus}) => ({root, payloadStatus})),
                   `Invalid viable head roots at step ${i}`
                 );
 
-                // Weights are stored in EFFECTIVE_BALANCE_INCREMENT units, so the proposer-boost
-                // score is floored to whole ETH while the spec keeps Gwei precision. Attestation
-                // weight is exact, so the per-head divergence is only the boost quantization, bounded
-                // by (100 - gcd(PROPOSER_SCORE_BOOST, 100) + PROPOSER_SCORE_BOOST) / 100 = 1.2 ETH,
-                // independent of SLOTS_PER_EPOCH and total balance. Compare within that bound.
-                const tolerance = 1.2 * EFFECTIVE_BALANCE_INCREMENT;
-                for (const [k, {root, weight}] of actual.entries()) {
-                  const diff = Math.abs(weight - expected[k].weight);
-                  expect(
-                    diff,
-                    `Viable head ${root} weight off by ${diff} Gwei (> 1.2 ETH) at step ${i}`
-                  ).toBeLessThanOrEqual(tolerance);
+                // Exact weight comparison with boost emulation. Lodestar tracks weights in
+                // EFFECTIVE_BALANCE_INCREMENT units: attestation weight is exact (effective
+                // balances are increment multiples) but the proposer-boost score is double-floored
+                // to whole ETH (getCommitteeFraction) while the spec keeps Gwei precision — a
+                // known production divergence, bounded by
+                // (100 - gcd(PROPOSER_SCORE_BOOST, 100) + PROPOSER_SCORE_BOOST) / 100 = 1.2 ETH.
+                // Rather than compare within a tolerance (which would mask sub-1.2-ETH weight
+                // bugs), normalize the expected weight of the boosted entry by
+                // `- spec_boost + lodestar_boost` and compare exactly.
+                //
+                // Ordering rules (so normalization cannot mask a wrong boost root):
+                // - `checks.proposer_boost_root` was already asserted above, unadjusted.
+                // - Normalize using the VECTOR's expected boost root, never our actual one.
+                // - Zero boost root or absent field => no adjustment.
+                const expectedBoostRoot = step.checks.proposer_boost_root;
+                let specBoostGwei = BigInt(0);
+                let lodestarBoostGwei = BigInt(0);
+                if (expectedBoostRoot !== undefined && expectedBoostRoot !== ZERO_HASH_HEX) {
+                  const totalBalanceByIncrement = (
+                    chain.forkChoice as ForkChoice
+                  ).getJustifiedTotalActiveBalanceByIncrement();
+                  const totalBalanceGwei = BigInt(totalBalanceByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+                  // Spec: ((total_active_balance // SLOTS_PER_EPOCH) * PROPOSER_SCORE_BOOST) // 100, in Gwei
+                  specBoostGwei =
+                    ((totalBalanceGwei / BigInt(SLOTS_PER_EPOCH)) * BigInt(config.PROPOSER_SCORE_BOOST)) / BigInt(100);
+                  // Lodestar: same formula double-floored in increment units — use the production
+                  // function directly so the emulation cannot drift from the implementation.
+                  lodestarBoostGwei =
+                    BigInt(
+                      getCommitteeFraction(totalBalanceByIncrement, {
+                        slotsPerEpoch: SLOTS_PER_EPOCH,
+                        committeePercent: config.PROPOSER_SCORE_BOOST,
+                      })
+                    ) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+                }
+                for (const [k, act] of actual.entries()) {
+                  const exp = expected[k];
+                  // TODO GLOAS: boost attribution across payload-status variants of the boosted
+                  // root is Phase 4 work; pre-gloas each root has exactly one entry.
+                  const isBoosted = exp.root === expectedBoostRoot;
+                  const expectedAdjusted = isBoosted
+                    ? exp.weightGwei - specBoostGwei + lodestarBoostGwei
+                    : exp.weightGwei;
+                  expect(act.weightGwei).toEqualWithMessage(
+                    expectedAdjusted,
+                    `Invalid viable head weight for ${act.root} at step ${i}` +
+                      (isBoosted ? ` (boost-normalized: spec=${specBoostGwei} lodestar=${lodestarBoostGwei})` : "")
+                  );
                 }
               }
               if (step.checks.should_override_forkchoice_update) {
@@ -918,12 +984,13 @@ type Checks = {
     head?: {
       slot: bigint;
       root: string;
+      /** Gloas and later */
+      payload_status?: bigint;
     };
     time?: bigint;
     justified_checkpoint?: SpecTestCheckpoint;
     finalized_checkpoint?: SpecTestCheckpoint;
     proposer_boost_root?: RootHex;
-    head_payload_status?: bigint;
     get_proposer_head?: string;
     should_override_forkchoice_update?: {
       validator_is_connected: boolean;
@@ -939,10 +1006,15 @@ type Checks = {
       block_root: RootHex;
       votes: (boolean | null)[];
     };
-    viable_for_head_roots_and_weights?: {root: RootHex; weight: bigint}[];
+    viable_for_head_roots_and_weights?: {root: RootHex; weight: bigint; payload_status?: bigint}[];
   };
 };
 
+/** Sort by (root, payload_status) — the spec fixes no order; gloas variants share a root. */
+function cmpViableHead(a: {root: string; payloadStatus?: number}, b: {root: string; payloadStatus?: number}): number {
+  return a.root.localeCompare(b.root) || (a.payloadStatus ?? 0) - (b.payloadStatus ?? 0);
+}
+
 type ForkChoiceTestCase = {
   meta?: {
     description?: string;
diff --git a/packages/beacon-node/test/spec/utils/specTestIterator.ts b/packages/beacon-node/test/spec/utils/specTestIterator.ts
index ae0e5da02f41..60de88936236 100644
--- a/packages/beacon-node/test/spec/utils/specTestIterator.ts
+++ b/packages/beacon-node/test/spec/utils/specTestIterator.ts
@@ -81,13 +81,22 @@ export const defaultSkipOpts: SkipOpts = {
     // TODO-GLOAS: re-enable after Gloas light client is implemented
     /^gloas\/light_client\/.*/,
     /^gloas\/ssz_static\/LightClient(Bootstrap|FinalityUpdate|Header|OptimisticUpdate|Update)\/.*/,
+    // TODO GLOAS: compliance suite deferred to a follow-up PR — requires should_apply_proposer_boost
+    // (#9233), is_head_weak (#9654) and verifySignatures plumbing for embedded payload attestations.
+    // Baseline on the old artifact was 166/1472 (see PR #9314).
+    /^gloas\/fork_choice_compliance\/.*/,
   ],
   skippedTests: [
     // TODO-GLOAS: re-enable after gloas light client is implemented
     /\/gloas_fork$/,
   ],
   // TODO GLOAS: Investigate why networking tests are failing since alpha.5
-  skippedRunners: ["networking"],
+  skippedRunners: [
+    "networking",
+    // fork_choice_compliance is opt-in (`pnpm test:comptest`): ~1472 model-generated cases per
+    // fork — running them inside the regular spec suite would double-run and blow the budget.
+    ...(process.env.RUN_FORK_CHOICE_COMPLIANCE === "1" ? [] : ["fork_choice_compliance"]),
+  ],
 };
 
 /**
@@ -175,9 +184,15 @@ export function specTestIterator(
             // Generic testRunner
             else {
               const {testFunction, options} = testRunner.fn(fork, testHandler, testSuite);
-              if (opts.skippedTests && options.shouldSkip === undefined) {
-                options.shouldSkip = (_testCase: any, name: string, _index: number): boolean => {
-                  return opts?.skippedTests?.some((skippedMatch) => name.match(skippedMatch)) ?? false;
+              if (opts.skippedTests) {
+                // Compose with any runner-local shouldSkip — overwriting it would silently
+                // disable SkipOpts.skippedTests for runners that define their own (fork_choice).
+                const runnerShouldSkip = options.shouldSkip;
+                options.shouldSkip = (testCase: any, name: string, index: number): boolean => {
+                  return (
+                    (runnerShouldSkip?.(testCase, name, index) ?? false) ||
+                    (opts.skippedTests?.some((skippedMatch) => name.match(skippedMatch)) ?? false)
+                  );
                 };
               }
               describeDirectorySpecTest(testId, testSuiteDirpath, testFunction, options);
diff --git a/packages/fork-choice/src/forkChoice/forkChoice.ts b/packages/fork-choice/src/forkChoice/forkChoice.ts
index 90fd669bf714..3513e66a0b0f 100644
--- a/packages/fork-choice/src/forkChoice/forkChoice.ts
+++ b/packages/fork-choice/src/forkChoice/forkChoice.ts
@@ -594,10 +594,20 @@ export class ForkChoice implements IForkChoice {
     return this.protoArray.nodes.filter((node) => node.bestChild === undefined);
   }
 
-  getViableHeads(): {root: RootHex; weight: number}[] {
+  /** Weights are in EFFECTIVE_BALANCE_INCREMENT units (NOT Gwei). */
+  getViableHeads(): {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] {
     return this.protoArray.getViableHeads(this.fcStore.currentSlot);
   }
 
+  /**
+   * The cached justified total active balance, in EFFECTIVE_BALANCE_INCREMENT units.
+   * This is the exact balance source production uses for the proposer boost score
+   * (see getCommitteeFraction); exposed for the spec-test runner's boost emulation.
+   */
+  getJustifiedTotalActiveBalanceByIncrement(): number {
+    return this.fcStore.justified.totalBalance;
+  }
+
   /** This is for the debug API only */
   getAllNodes(): ProtoNode[] {
     return this.protoArray.nodes;
diff --git a/packages/fork-choice/src/index.ts b/packages/fork-choice/src/index.ts
index 9d5f8a54b3eb..312f245ee796 100644
--- a/packages/fork-choice/src/index.ts
+++ b/packages/fork-choice/src/index.ts
@@ -17,7 +17,7 @@ export {
   type IFastConfirmationStore,
   getFastConfirmationMetrics,
 } from "./forkChoice/fastConfirmation/fastConfirmationRule.ts";
-export {ForkChoice, type ForkChoiceOpts, UpdateHeadOpt} from "./forkChoice/forkChoice.js";
+export {ForkChoice, type ForkChoiceOpts, UpdateHeadOpt, getCommitteeFraction} from "./forkChoice/forkChoice.js";
 export {
   type AncestorResult,
   AncestorStatus,
diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index ac23ad8d018b..f4e6aab81d9b 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1,5 +1,5 @@
 import {BitArray} from "@chainsafe/ssz";
-import {EFFECTIVE_BALANCE_INCREMENT, GENESIS_EPOCH, PTC_SIZE} from "@lodestar/params";
+import {GENESIS_EPOCH, PTC_SIZE} from "@lodestar/params";
 import {DataAvailabilityStatus, computeEpochAtSlot, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, RootHex, Slot} from "@lodestar/types";
 import {bitCount, toRootHex} from "@lodestar/utils";
@@ -1541,8 +1541,8 @@ export class ProtoArray {
     return correctJustified && correctFinalized;
   }
 
-  /** Weight is converted from increment units to Gwei. */
-  getViableHeads(currentSlot: Slot): {root: RootHex; weight: number}[] {
+  /** Weights are in EFFECTIVE_BALANCE_INCREMENT units (NOT Gwei); callers scale as needed. */
+  getViableHeads(currentSlot: Slot): {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] {
     // Mirror the spec's `get_filtered_block_tree`, which is rooted at the store's justified
     // checkpoint: a viable head is a leaf (no viable descendant, i.e. `bestChild === undefined`)
     // that descends from the justified checkpoint block AND is itself viable for head. Iterating
@@ -1550,11 +1550,10 @@ export class ProtoArray {
     // that hang off the finalized checkpoint on a branch not under the current justified checkpoint.
     const justifiedIndex = this.getDefaultNodeIndex(this.justifiedRoot);
     const justifiedSlot = justifiedIndex !== undefined ? this.getNodeByIndex(justifiedIndex)?.slot : undefined;
-    // Gloas payload-status variants share a blockRoot and more than one can be a leaf (EMPTY and
-    // FULL are both parented under PENDING); the spec's filtered tree is keyed by block root, so
-    // emit each root at most once. Which variant's weight the spec expects is an open gloas
-    // divergence — deterministically keep the heaviest qualifying variant.
-    const weightByRoot = new Map<RootHex, number>();
+    // Gloas payload-status variants of one blockRoot are distinct nodes in the spec's filtered
+    // tree, identified by (root, payload_status, weight) — emit one entry per variant.
+    // https://github.com/ethereum/consensus-specs/pull/5393
+    const heads: {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] = [];
     for (const node of this.nodes) {
       if (node.bestChild !== undefined || !this.nodeIsViableForHead(node, currentSlot)) {
         continue;
@@ -1562,15 +1561,9 @@ export class ProtoArray {
       if (this.justifiedEpoch !== GENESIS_EPOCH && !this.descendsFromJustified(node, justifiedSlot)) {
         continue;
       }
-      const prev = weightByRoot.get(node.blockRoot);
-      if (prev === undefined || node.weight > prev) {
-        weightByRoot.set(node.blockRoot, node.weight);
-      }
+      heads.push({root: node.blockRoot, payloadStatus: node.payloadStatus, weight: node.weight});
     }
-    return Array.from(weightByRoot.entries()).map(([root, weight]) => ({
-      root,
-      weight: weight * EFFECTIVE_BALANCE_INCREMENT,
-    }));
+    return heads;
   }
 
   /**

From a4bc419f0a965762330a2bc7637d9d74b7c174d9 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 15 Jul 2026 23:47:02 -0700
Subject: [PATCH 07/23] feat: add opt-in fork-choice compliance vector download
 + test:comptest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add `pnpm download-comptests` and `pnpm test:comptest` (root + beacon-node),
fully outside the regular download-spec-tests/test:spec flow.

The comptests.tar.gz release asset exists since consensus-specs #5334;
vectors are fetched pinned to v1.7.0-alpha.12 (valid against the alpha.11
pin: the pre-gloas fork-choice spec delta is rename-only).

The standard downloader deletes its entire output directory on a cache
miss, so it cannot be reused for a second asset sharing spec-tests/.
downloadComptests() is asset-scoped instead: extracts to a temp dir,
replaces only tests/<preset>/<fork>/fork_choice_compliance/ subtrees,
and writes its own comptests-version.json marker only after a successful
merge — a failed download leaves existing fixtures and marker untouched.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 package.json                                  |   2 +
 packages/beacon-node/package.json             |   2 +
 .../test/spec/downloadComptests.ts            |  21 +++
 packages/spec-test-util/package.json          |   5 +
 .../spec-test-util/src/downloadComptests.ts   | 137 ++++++++++++++++++
 5 files changed, 167 insertions(+)
 create mode 100644 packages/beacon-node/test/spec/downloadComptests.ts
 create mode 100644 packages/spec-test-util/src/downloadComptests.ts

diff --git a/package.json b/package.json
index a807b5adc9e8..d7beff8ae919 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,8 @@
     "test:browsers": "vitest run --project browser",
     "test:e2e": "vitest run --project e2e --project e2e-mainnet",
     "download-spec-tests": "pnpm -r download-spec-tests",
+    "download-comptests": "pnpm -r download-comptests",
+    "test:comptest": "RUN_FORK_CHOICE_COMPLIANCE=1 vitest run --project spec-minimal packages/beacon-node/test/spec/presets/fork_choice.test.ts -t fork_choice_compliance",
     "test:spec": "vitest run --project spec-minimal --project spec-mainnet",
     "benchmark": "pnpm benchmark:files 'packages/*/test/perf/**/*.test.ts'",
     "benchmark:files": "NODE_OPTIONS='--max-old-space-size=8192 --loader=ts-node/esm' benchmark --config .benchrc.yaml --defaultBranch unstable",
diff --git a/packages/beacon-node/package.json b/packages/beacon-node/package.json
index aee30caa1129..fd53a4cebd39 100644
--- a/packages/beacon-node/package.json
+++ b/packages/beacon-node/package.json
@@ -100,6 +100,8 @@
     "test:sim": "vitest run test/sim/**/*.test.ts",
     "test:sim:blobs": "vitest run test/sim/4844-interop.test.ts",
     "download-spec-tests": "node --loader=ts-node/esm test/spec/downloadTests.ts",
+    "download-comptests": "node --loader=ts-node/esm test/spec/downloadComptests.ts",
+    "test:comptest": "RUN_FORK_CHOICE_COMPLIANCE=1 vitest run --project spec-minimal test/spec/presets/fork_choice.test.ts -t fork_choice_compliance",
     "test:spec:bls": "vitest run --project spec-minimal test/spec/bls/",
     "test:spec:general": "vitest run --project spec-minimal test/spec/general/",
     "test:spec:minimal": "vitest run --project spec-minimal test/spec/presets/",
diff --git a/packages/beacon-node/test/spec/downloadComptests.ts b/packages/beacon-node/test/spec/downloadComptests.ts
new file mode 100644
index 000000000000..6ccf3f1ada51
--- /dev/null
+++ b/packages/beacon-node/test/spec/downloadComptests.ts
@@ -0,0 +1,21 @@
+import {downloadComptests} from "@lodestar/spec-test-util/downloadComptests";
+import {ethereumConsensusSpecsTests} from "./specTestVersioning.js";
+
+// The comptests pin is independent of the standard spec-tests pin: pre-gloas fork-choice
+// semantics are identical between alpha.11 and alpha.12 (rename-only spec delta), so the
+// alpha.12 vectors are valid while unstable still pins alpha.11. Collapse this into
+// `ethereumConsensusSpecsTests.specVersion` once the standard pin reaches v1.7.0-alpha.12
+// (PR #9390).
+const COMPTESTS_SPEC_VERSION = "v1.7.0-alpha.12";
+
+await downloadComptests(
+  {
+    specVersion: COMPTESTS_SPEC_VERSION,
+    outputDir: ethereumConsensusSpecsTests.outputDir,
+    specTestsRepoUrl: ethereumConsensusSpecsTests.specTestsRepoUrl,
+  },
+  console.log
+).catch((e: Error) => {
+  console.error(e);
+  process.exit(1);
+});
diff --git a/packages/spec-test-util/package.json b/packages/spec-test-util/package.json
index bab0446f3da4..0dae4a1af096 100644
--- a/packages/spec-test-util/package.json
+++ b/packages/spec-test-util/package.json
@@ -24,6 +24,11 @@
       "bun": "./src/downloadNightlyTests.ts",
       "types": "./lib/downloadNightlyTests.d.ts",
       "import": "./lib/downloadNightlyTests.js"
+    },
+    "./downloadComptests": {
+      "bun": "./src/downloadComptests.ts",
+      "types": "./lib/downloadComptests.d.ts",
+      "import": "./lib/downloadComptests.js"
     }
   },
   "files": [
diff --git a/packages/spec-test-util/src/downloadComptests.ts b/packages/spec-test-util/src/downloadComptests.ts
new file mode 100644
index 000000000000..73c9c071d49e
--- /dev/null
+++ b/packages/spec-test-util/src/downloadComptests.ts
@@ -0,0 +1,137 @@
+import {execFile} from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {pipeline} from "node:stream/promises";
+import {ReadableStream as NodeReadableStream} from "node:stream/web";
+import {promisify} from "node:util";
+import {fetch, retry} from "@lodestar/utils";
+import {defaultSpecTestsRepoUrl} from "./downloadTests.js";
+
+const logEmpty = (): void => {};
+
+export type DownloadComptestsOptions = {
+  specVersion: string;
+  /** Shared spec-tests output dir, the same one the standard downloader extracts into */
+  outputDir: string;
+  /** Root Github URL `https://github.com/ethereum/consensus-specs` */
+  specTestsRepoUrl?: string;
+  fetchInit?: RequestInit;
+};
+
+const MARKER_FILENAME = "comptests-version.json";
+const COMPTESTS_SUBDIR = "fork_choice_compliance";
+
+/**
+ * Download the fork-choice compliance test vectors (`comptests.tar.gz` release asset,
+ * consensus-specs #5334) into the shared spec-tests directory.
+ *
+ * The standard downloader (`downloadGenericSpecTests`) deletes its ENTIRE output directory on a
+ * cache miss, so it cannot be pointed at the shared dir for a second asset. This downloader is
+ * asset-scoped instead:
+ * - extracts into a temporary directory first,
+ * - replaces only comptest-owned paths (`tests/<preset>/<fork>/fork_choice_compliance/`),
+ * - never deletes the shared output directory,
+ * - writes its own marker (`comptests-version.json`) only after a successful merge, so a failed
+ *   download/extraction leaves existing fixtures and marker untouched.
+ *
+ * Note: a standard-tests version change wipes the whole shared dir including these vectors
+ * (correct — new pin needs new vectors); the `test:comptest` zero-test guard catches the absence.
+ */
+export async function downloadComptests(
+  {specVersion, outputDir, specTestsRepoUrl, fetchInit}: DownloadComptestsOptions,
+  log: (msg: string) => void = logEmpty
+): Promise<void> {
+  log(`outputDir = ${outputDir}`);
+
+  const markerPath = path.join(outputDir, MARKER_FILENAME);
+  if (readMarkerVersion(markerPath) === specVersion) {
+    return log(`comptests version ${specVersion} already downloaded`);
+  }
+
+  const url = `${specTestsRepoUrl ?? defaultSpecTestsRepoUrl}/releases/download/${specVersion}/comptests.tar.gz`;
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lodestar-comptests-"));
+
+  try {
+    await retry(
+      async () => {
+        const res = await fetch(url, {signal: AbortSignal.timeout(30 * 60 * 1000), ...fetchInit});
+        if (!res.ok) {
+          throw new Error(`Failed to download file from ${url}: ${res.status} ${res.statusText}`);
+        }
+        if (!res.body) {
+          throw new Error("Response body is null");
+        }
+
+        log(`Downloading ${url} - ${res.headers.get("content-length")} bytes`);
+        const tarball = path.join(tmpDir, "comptests.tar.gz");
+        await pipeline(res.body as unknown as NodeReadableStream, fs.createWriteStream(tarball));
+        log(`Downloaded ${url} - ${fs.statSync(tarball).size} bytes`);
+
+        await promisify(execFile)("tar", ["-xzf", tarball, "-C", tmpDir, "--exclude=._*", "--exclude=*/._*"], {
+          maxBuffer: 1000 * 1024 * 1024, // 1 GB
+        });
+        log(`Extracted ${tarball}`);
+        fs.unlinkSync(tarball);
+      },
+      {
+        retries: 3,
+        onRetry: (e, attempt) => {
+          log(`Download attempt ${attempt} for comptests failed: ${e.message}`);
+        },
+      }
+    );
+
+    // Remove ALL existing comptest-owned paths first so forks dropped upstream leave no stale cases
+    for (const dir of findComptestDirs(outputDir)) {
+      fs.rmSync(dir, {recursive: true, force: true});
+    }
+
+    // Move only comptest-owned paths from the temp extraction into the shared dir
+    const extracted = findComptestDirs(tmpDir);
+    if (extracted.length === 0) {
+      throw new Error(`No ${COMPTESTS_SUBDIR} directories found in comptests.tar.gz from ${url}`);
+    }
+    for (const srcDir of extracted) {
+      const destDir = path.join(outputDir, path.relative(tmpDir, srcDir));
+      fs.mkdirSync(path.dirname(destDir), {recursive: true});
+      fs.cpSync(srcDir, destDir, {recursive: true});
+      log(`Installed ${path.relative(outputDir, destDir)}`);
+    }
+
+    // Marker written only after a fully successful merge
+    fs.writeFileSync(markerPath, JSON.stringify({specVersion}, null, 2));
+    log(`comptests ${specVersion} ready`);
+  } finally {
+    fs.rmSync(tmpDir, {recursive: true, force: true});
+  }
+}
+
+function readMarkerVersion(markerPath: string): string | null {
+  if (!fs.existsSync(markerPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(markerPath, "utf8")) as {specVersion?: unknown};
+    return typeof parsed.specVersion === "string" ? parsed.specVersion : null;
+  } catch {
+    // Unparseable/legacy marker => treat as stale and redownload
+    return null;
+  }
+}
+
+/** Find all `tests/<preset>/<fork>/fork_choice_compliance` dirs under `root` */
+function findComptestDirs(root: string): string[] {
+  const found: string[] = [];
+  const testsDir = path.join(root, "tests");
+  if (!fs.existsSync(testsDir)) return found;
+  for (const preset of fs.readdirSync(testsDir)) {
+    const presetDir = path.join(testsDir, preset);
+    if (!fs.statSync(presetDir).isDirectory()) continue;
+    for (const fork of fs.readdirSync(presetDir)) {
+      const complianceDir = path.join(presetDir, fork, COMPTESTS_SUBDIR);
+      if (fs.existsSync(complianceDir) && fs.statSync(complianceDir).isDirectory()) {
+        found.push(complianceDir);
+      }
+    }
+  }
+  return found;
+}

From 8d248600bb9c3281c575c0a11c82bb177def5308 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 15 Jul 2026 23:52:23 -0700
Subject: [PATCH 08/23] test: fail test:comptest loudly when compliance
 fixtures are absent

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../test/spec/presets/fork_choice.test.ts         | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/packages/beacon-node/test/spec/presets/fork_choice.test.ts b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
index 377df0ef9e05..3dd8db894ae4 100644
--- a/packages/beacon-node/test/spec/presets/fork_choice.test.ts
+++ b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import {generateKeyPair} from "@libp2p/crypto/keys";
 import {expect} from "vitest";
@@ -1064,6 +1065,20 @@ function isCheck(step: Step): step is Checks {
   return typeof (step as Checks).checks === "object";
 }
 
+// Zero-test guard: `pnpm test:comptest` must fail loudly when fixtures are absent —
+// a filter matching zero tests would otherwise read as green.
+if (process.env.RUN_FORK_CHOICE_COMPLIANCE === "1") {
+  const presetDir = path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET);
+  const hasComplianceFixtures =
+    fs.existsSync(presetDir) &&
+    fs.readdirSync(presetDir).some((fork) => fs.existsSync(path.join(presetDir, fork, "fork_choice_compliance")));
+  if (!hasComplianceFixtures) {
+    throw Error(
+      "RUN_FORK_CHOICE_COMPLIANCE=1 but no fork_choice_compliance fixtures found — run `pnpm download-comptests` first"
+    );
+  }
+}
+
 specTestIterator(path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET), {
   fork_choice: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: false})},
   sync: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: true})},

From 49f6716e821eb2840d3476b7a99b374845278111 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 15 Jul 2026 23:55:04 -0700
Subject: [PATCH 09/23] test: unit-test comptests downloader merge safety
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Covers: additive install alongside standard fixtures, refresh replacing
comptest paths + removing stale forks, cache hit, failed extraction
leaving fixtures and marker untouched, legacy marker treated as stale.

Also fixes the ordering bug the tests caught: validate the temp
extraction is non-empty BEFORE removing existing comptest paths — tar
can exit 0 on a truncated archive, which would have wiped the existing
vectors against an empty extraction.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../spec-test-util/src/downloadComptests.ts   |  13 +-
 .../test/unit/downloadComptests.test.ts       | 146 ++++++++++++++++++
 2 files changed, 153 insertions(+), 6 deletions(-)
 create mode 100644 packages/spec-test-util/test/unit/downloadComptests.test.ts

diff --git a/packages/spec-test-util/src/downloadComptests.ts b/packages/spec-test-util/src/downloadComptests.ts
index 73c9c071d49e..602500e5055f 100644
--- a/packages/spec-test-util/src/downloadComptests.ts
+++ b/packages/spec-test-util/src/downloadComptests.ts
@@ -82,16 +82,17 @@ export async function downloadComptests(
       }
     );
 
-    // Remove ALL existing comptest-owned paths first so forks dropped upstream leave no stale cases
-    for (const dir of findComptestDirs(outputDir)) {
-      fs.rmSync(dir, {recursive: true, force: true});
-    }
-
-    // Move only comptest-owned paths from the temp extraction into the shared dir
+    // Validate the extraction BEFORE touching the shared dir — tar can exit 0 on a truncated
+    // archive, and removing existing fixtures against an empty extraction would destroy them.
     const extracted = findComptestDirs(tmpDir);
     if (extracted.length === 0) {
       throw new Error(`No ${COMPTESTS_SUBDIR} directories found in comptests.tar.gz from ${url}`);
     }
+
+    // Remove ALL existing comptest-owned paths so forks dropped upstream leave no stale cases
+    for (const dir of findComptestDirs(outputDir)) {
+      fs.rmSync(dir, {recursive: true, force: true});
+    }
     for (const srcDir of extracted) {
       const destDir = path.join(outputDir, path.relative(tmpDir, srcDir));
       fs.mkdirSync(path.dirname(destDir), {recursive: true});
diff --git a/packages/spec-test-util/test/unit/downloadComptests.test.ts b/packages/spec-test-util/test/unit/downloadComptests.test.ts
new file mode 100644
index 000000000000..490e00fd03f8
--- /dev/null
+++ b/packages/spec-test-util/test/unit/downloadComptests.test.ts
@@ -0,0 +1,146 @@
+import {execFileSync} from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {Readable} from "node:stream";
+import {afterEach, beforeEach, describe, expect, it, vi} from "vitest";
+import {downloadComptests} from "../../src/downloadComptests.js";
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+const fetchMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@lodestar/utils", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@lodestar/utils")>();
+  return {...original, fetch: fetchMock};
+});
+
+describe("downloadComptests", () => {
+  let workDir: string;
+  let outputDir: string;
+
+  beforeEach(() => {
+    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "comptests-test-"));
+    outputDir = path.join(workDir, "spec-tests");
+    fs.mkdirSync(outputDir, {recursive: true});
+    fetchMock.mockReset();
+  });
+
+  afterEach(() => {
+    fs.rmSync(workDir, {recursive: true, force: true});
+  });
+
+  /** Build a comptests.tar.gz containing `tests/minimal/<fork>/fork_choice_compliance/<case>` */
+  function makeTarball(forks: Record<string, string[]>): Uint8Array {
+    const stageDir = path.join(workDir, `stage-${Math.random().toString(36).slice(2)}`);
+    for (const [fork, cases] of Object.entries(forks)) {
+      for (const testCase of cases) {
+        const caseDir = path.join(stageDir, "tests/minimal", fork, "fork_choice_compliance/block_tree_test", testCase);
+        fs.mkdirSync(caseDir, {recursive: true});
+        fs.writeFileSync(path.join(caseDir, "steps.yaml"), `- {tick: 0} # ${fork}/${testCase}`);
+      }
+    }
+    // Junk dirs present in the real asset
+    fs.mkdirSync(path.join(stageDir, "tests/core/pyspec"), {recursive: true});
+    const tarPath = path.join(workDir, `fixture-${Math.random().toString(36).slice(2)}.tar.gz`);
+    execFileSync("tar", ["-czf", tarPath, "-C", stageDir, "tests"]);
+    return fs.readFileSync(tarPath);
+  }
+
+  function mockFetchTarball(bytes: Uint8Array): void {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      headers: {get: () => String(bytes.length)},
+      body: Readable.toWeb(Readable.from([bytes])),
+    });
+  }
+
+  function writeStandardFixture(): string {
+    const standardFile = path.join(outputDir, "tests/minimal/altair/fork_choice/on_block/case_0/steps.yaml");
+    fs.mkdirSync(path.dirname(standardFile), {recursive: true});
+    fs.writeFileSync(standardFile, "- {tick: 0}");
+    fs.writeFileSync(path.join(outputDir, "version.txt"), "v1.7.0-alpha.12");
+    return standardFile;
+  }
+
+  const opts = (specVersion: string) => ({specVersion, outputDir});
+
+  it("installs comptests without touching standard fixtures", async () => {
+    const standardFile = writeStandardFixture();
+    mockFetchTarball(makeTarball({altair: ["case_a"], deneb: ["case_b"]}));
+
+    await downloadComptests(opts("v1.7.0-alpha.12"));
+
+    expect(fs.existsSync(standardFile)).toBe(true);
+    expect(fs.readFileSync(path.join(outputDir, "version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
+    for (const fork of ["altair", "deneb"]) {
+      expect(fs.existsSync(path.join(outputDir, "tests/minimal", fork, "fork_choice_compliance"))).toBe(true);
+    }
+    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
+      specVersion: "v1.7.0-alpha.12",
+    });
+    // Junk dirs from the tarball are not merged
+    expect(fs.existsSync(path.join(outputDir, "tests/core"))).toBe(false);
+  });
+
+  it("refresh on version change replaces comptest paths, preserves standard, removes stale forks", async () => {
+    const standardFile = writeStandardFixture();
+    mockFetchTarball(makeTarball({altair: ["old_case"], bellatrix: ["stale_case"]}));
+    await downloadComptests(opts("v1.7.0-alpha.11"));
+
+    mockFetchTarball(makeTarball({altair: ["new_case"]}));
+    await downloadComptests(opts("v1.7.0-alpha.12"));
+
+    expect(fs.existsSync(standardFile)).toBe(true);
+    const altairCompliance = path.join(outputDir, "tests/minimal/altair/fork_choice_compliance/block_tree_test");
+    expect(fs.readdirSync(altairCompliance)).toEqual(["new_case"]);
+    // bellatrix dropped upstream => no stale cases left behind
+    expect(fs.existsSync(path.join(outputDir, "tests/minimal/bellatrix/fork_choice_compliance"))).toBe(false);
+    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
+      specVersion: "v1.7.0-alpha.12",
+    });
+  });
+
+  it("cache hit does not fetch", async () => {
+    mockFetchTarball(makeTarball({altair: ["case_a"]}));
+    await downloadComptests(opts("v1.7.0-alpha.12"));
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+
+    await downloadComptests(opts("v1.7.0-alpha.12"));
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("failed extraction leaves existing fixtures and marker untouched", async () => {
+    const standardFile = writeStandardFixture();
+    mockFetchTarball(makeTarball({altair: ["good_case"]}));
+    await downloadComptests(opts("v1.7.0-alpha.11"));
+
+    // Corrupt tarball on refresh
+    fetchMock.mockResolvedValue({
+      ok: true,
+      headers: {get: () => "12"},
+      body: Readable.toWeb(Readable.from([new Uint8Array([0x1f, 0x8b, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])])),
+    });
+    await expect(downloadComptests(opts("v1.7.0-alpha.12"))).rejects.toThrow();
+
+    expect(fs.existsSync(standardFile)).toBe(true);
+    expect(
+      fs.existsSync(path.join(outputDir, "tests/minimal/altair/fork_choice_compliance/block_tree_test/good_case"))
+    ).toBe(true);
+    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
+      specVersion: "v1.7.0-alpha.11",
+    });
+  });
+
+  it("unparseable marker is treated as stale and redownloads", async () => {
+    fs.writeFileSync(path.join(outputDir, "comptests-version.json"), "v1.7.0-alpha.12"); // legacy plain text
+    mockFetchTarball(makeTarball({altair: ["case_a"]}));
+
+    await downloadComptests(opts("v1.7.0-alpha.12"));
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
+      specVersion: "v1.7.0-alpha.12",
+    });
+  });
+});

From 22f4c1cb6a33cb0b4726e745cd2a5bcead8608f4 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 15 Jul 2026 23:59:12 -0700
Subject: [PATCH 10/23] test: unit-test getViableHeads leaf selection and gloas
 variant identity

Covers justified-subtree leaf selection with increment-unit weights, and
gloas payload-status variants of one root reported as separate entries
(EMPTY-only before the envelope, EMPTY+FULL after onExecutionPayload).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../unit/protoArray/getViableHeads.test.ts    | 100 ++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts

diff --git a/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts b/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts
new file mode 100644
index 000000000000..5139cc4c98ce
--- /dev/null
+++ b/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts
@@ -0,0 +1,100 @@
+import {describe, expect, it} from "vitest";
+import {DataAvailabilityStatus} from "@lodestar/state-transition";
+import {ExecutionStatus, PayloadStatus, ProtoArray} from "../../../src/index.js";
+
+/** Block metadata shared by every test node */
+function blockFields(overrides: {
+  slot: number;
+  blockRoot: string;
+  parentRoot: string;
+  payloadStatus?: PayloadStatus;
+}): Parameters<ProtoArray["onBlock"]>[0] {
+  return {
+    slot: overrides.slot,
+    blockRoot: overrides.blockRoot,
+    parentRoot: overrides.parentRoot,
+    stateRoot: "0",
+    targetRoot: "1",
+
+    justifiedEpoch: 0,
+    justifiedRoot: "0",
+    finalizedEpoch: 0,
+    finalizedRoot: "0",
+    unrealizedJustifiedEpoch: 0,
+    unrealizedJustifiedRoot: "0",
+    unrealizedFinalizedEpoch: 0,
+    unrealizedFinalizedRoot: "0",
+
+    timeliness: false,
+
+    ...{executionPayloadBlockHash: null, executionStatus: ExecutionStatus.PreMerge},
+    dataAvailabilityStatus: DataAvailabilityStatus.PreData,
+
+    parentBlockHash: null,
+    payloadStatus: overrides.payloadStatus ?? PayloadStatus.FULL,
+  };
+}
+
+function initProtoArray(): ProtoArray {
+  return ProtoArray.initialize(
+    {
+      ...blockFields({slot: 0, blockRoot: "1", parentRoot: "1"}),
+      stateRoot: "0",
+    } as Parameters<typeof ProtoArray.initialize>[0],
+    0
+  );
+}
+
+describe("ProtoArray.getViableHeads", () => {
+  it("returns every viable leaf with increment-unit weight", () => {
+    const fc = initProtoArray();
+    // 1 <- 2 <- 3 and 1 <- 4 (two competing leaves)
+    fc.onBlock(blockFields({slot: 1, blockRoot: "2", parentRoot: "1"}), 1, null);
+    fc.onBlock(blockFields({slot: 2, blockRoot: "3", parentRoot: "2"}), 2, null);
+    fc.onBlock(blockFields({slot: 1, blockRoot: "4", parentRoot: "1"}), 2, null);
+
+    // Non-leaf "2" must be excluded; genesis "1" has viable children => excluded
+    fc.applyScoreChanges({
+      deltas: [0, 0, 30, 12],
+      proposerBoost: null,
+      justifiedEpoch: 0,
+      justifiedRoot: "0",
+      finalizedEpoch: 0,
+      finalizedRoot: "0",
+      currentSlot: 2,
+    });
+
+    const heads = fc.getViableHeads(2).sort((a, b) => a.root.localeCompare(b.root));
+    expect(heads).toEqual([
+      {root: "3", payloadStatus: PayloadStatus.FULL, weight: 30},
+      {root: "4", payloadStatus: PayloadStatus.FULL, weight: 12},
+    ]);
+  });
+
+  it("emits gloas payload-status variants of one root as separate entries", () => {
+    const fc = initProtoArray();
+    // A gloas block (parentBlockHash !== null) creates PENDING and EMPTY variants sharing
+    // blockRoot "2" at insertion
+    fc.onBlock(
+      {
+        ...blockFields({slot: 1, blockRoot: "2", parentRoot: "1", payloadStatus: PayloadStatus.PENDING}),
+        ...{executionPayloadBlockHash: "0xeb", executionStatus: ExecutionStatus.Valid},
+        parentBlockHash: "0xea",
+      },
+      1,
+      null
+    );
+
+    // Before the envelope arrives only the EMPTY variant is a leaf (PENDING's bestChild
+    // points at it, so PENDING itself is not a leaf)
+    expect(fc.getViableHeads(1)).toEqual([{root: "2", payloadStatus: PayloadStatus.EMPTY, weight: 0}]);
+
+    // Revealing the payload creates the FULL variant as a sibling leaf of EMPTY
+    fc.onExecutionPayload("2", 1, "0xeb", 1, 30_000_000, null, ExecutionStatus.Valid, DataAvailabilityStatus.Available);
+
+    // Every leaf variant is reported separately, never deduped by root (consensus-specs #5393)
+    const heads = fc.getViableHeads(1);
+    const variantsOfRoot2 = heads.filter((h) => h.root === "2");
+    expect(variantsOfRoot2.map((h) => h.payloadStatus).sort()).toEqual([PayloadStatus.EMPTY, PayloadStatus.FULL]);
+  });
+});

From d374c3618751843989ff8976326be22d592e38db Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 00:01:55 -0700
Subject: [PATCH 11/23] refactor: pin comptests download to the standard
 spec-tests version

Single source of truth: spec-tests-version.json. The asset exists on
every release since v1.7.0-alpha.11 (consensus-specs #5334), so no
separate pin is needed; the comptests follow the pin bump in #9390
automatically.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/beacon-node/test/spec/downloadComptests.ts | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/packages/beacon-node/test/spec/downloadComptests.ts b/packages/beacon-node/test/spec/downloadComptests.ts
index 6ccf3f1ada51..20d7b578c3c2 100644
--- a/packages/beacon-node/test/spec/downloadComptests.ts
+++ b/packages/beacon-node/test/spec/downloadComptests.ts
@@ -1,16 +1,11 @@
 import {downloadComptests} from "@lodestar/spec-test-util/downloadComptests";
 import {ethereumConsensusSpecsTests} from "./specTestVersioning.js";
 
-// The comptests pin is independent of the standard spec-tests pin: pre-gloas fork-choice
-// semantics are identical between alpha.11 and alpha.12 (rename-only spec delta), so the
-// alpha.12 vectors are valid while unstable still pins alpha.11. Collapse this into
-// `ethereumConsensusSpecsTests.specVersion` once the standard pin reaches v1.7.0-alpha.12
-// (PR #9390).
-const COMPTESTS_SPEC_VERSION = "v1.7.0-alpha.12";
-
+// Same pin as the standard spec tests (spec-tests-version.json). The comptests.tar.gz release
+// asset exists for every release since v1.7.0-alpha.11 (consensus-specs #5334).
 await downloadComptests(
   {
-    specVersion: COMPTESTS_SPEC_VERSION,
+    specVersion: ethereumConsensusSpecsTests.specVersion,
     outputDir: ethereumConsensusSpecsTests.outputDir,
     specTestsRepoUrl: ethereumConsensusSpecsTests.specTestsRepoUrl,
   },

From b9e8e583f977a5319581e9368e3de10304b7426e Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 00:12:23 -0700
Subject: [PATCH 12/23] refactor: dedicated vitest project for compliance
 suite, drop env-var gating

Compliance registration moves out of fork_choice.test.ts into its own
test/spec/comptest/ file backed by a dedicated `comptest` vitest
project; the shared runner is extracted to utils/forkChoiceTestRunner.ts.

The regular spec projects exclude test/spec/comptest/** so
test:spec/test:spec:minimal can never pick the suite up, which removes
the need for RUN_FORK_CHOICE_COMPLIANCE: `pnpm test:comptest` simply
runs the comptest project. Zero-test guard (workspace config has
passWithNoTests: true) moves into the comptest entry file, now
unconditional.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 configs/vitest.config.spec.ts                 |   23 +
 package.json                                  |    2 +-
 packages/beacon-node/package.json             |    2 +-
 .../comptest/fork_choice_compliance.test.ts   |   24 +
 .../test/spec/presets/fork_choice.test.ts     | 1085 +----------------
 .../test/spec/utils/forkChoiceTestRunner.ts   | 1061 ++++++++++++++++
 .../test/spec/utils/specTestIterator.ts       |    7 +-
 vitest.config.ts                              |    6 +-
 8 files changed, 1121 insertions(+), 1089 deletions(-)
 create mode 100644 packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
 create mode 100644 packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts

diff --git a/configs/vitest.config.spec.ts b/configs/vitest.config.spec.ts
index c66eaa2670e7..dab6471f7892 100644
--- a/configs/vitest.config.spec.ts
+++ b/configs/vitest.config.spec.ts
@@ -5,6 +5,7 @@ export const specProjectMinimal = defineProject({
   test: {
     name: "spec-minimal",
     include: ["**/test/spec/**/*.test.ts"],
+    exclude: ["**/test/spec/comptest/**"],
     setupFiles: [
       path.join(__dirname, "../scripts/vitest/setupFiles/customMatchers.ts"),
       path.join(__dirname, "../scripts/vitest/setupFiles/dotenv.ts"),
@@ -26,6 +27,7 @@ export const specProjectMainnet = defineProject({
   test: {
     name: "spec-mainnet",
     include: ["**/test/spec/**/*.test.ts"],
+    exclude: ["**/test/spec/comptest/**"],
     setupFiles: [
       path.join(__dirname, "../scripts/vitest/setupFiles/customMatchers.ts"),
       path.join(__dirname, "../scripts/vitest/setupFiles/dotenv.ts"),
@@ -42,3 +44,24 @@ export const specProjectMainnet = defineProject({
     },
   },
 });
+
+// Fork-choice compliance suite (`pnpm test:comptest`) — deliberately its own project so the
+// regular spec projects never pick it up: ~1472 model-generated cases per fork.
+// Fixtures via `pnpm download-comptests`.
+export const specProjectComptest = defineProject({
+  test: {
+    name: "comptest",
+    include: ["**/test/spec/comptest/**/*.test.ts"],
+    setupFiles: [
+      path.join(__dirname, "../scripts/vitest/setupFiles/customMatchers.ts"),
+      path.join(__dirname, "../scripts/vitest/setupFiles/dotenv.ts"),
+      path.join(__dirname, "../scripts/vitest/setupFiles/lodestarPreset.ts"),
+    ],
+    testTimeout: 1000 * 60 * 15,
+    hookTimeout: 1000 * 60 * 15,
+    pool: "forks",
+    env: {
+      LODESTAR_PRESET: "minimal",
+    },
+  },
+});
diff --git a/package.json b/package.json
index d7beff8ae919..905118972dde 100644
--- a/package.json
+++ b/package.json
@@ -31,7 +31,7 @@
     "test:e2e": "vitest run --project e2e --project e2e-mainnet",
     "download-spec-tests": "pnpm -r download-spec-tests",
     "download-comptests": "pnpm -r download-comptests",
-    "test:comptest": "RUN_FORK_CHOICE_COMPLIANCE=1 vitest run --project spec-minimal packages/beacon-node/test/spec/presets/fork_choice.test.ts -t fork_choice_compliance",
+    "test:comptest": "vitest run --project comptest",
     "test:spec": "vitest run --project spec-minimal --project spec-mainnet",
     "benchmark": "pnpm benchmark:files 'packages/*/test/perf/**/*.test.ts'",
     "benchmark:files": "NODE_OPTIONS='--max-old-space-size=8192 --loader=ts-node/esm' benchmark --config .benchrc.yaml --defaultBranch unstable",
diff --git a/packages/beacon-node/package.json b/packages/beacon-node/package.json
index fd53a4cebd39..75da40adc89b 100644
--- a/packages/beacon-node/package.json
+++ b/packages/beacon-node/package.json
@@ -101,7 +101,7 @@
     "test:sim:blobs": "vitest run test/sim/4844-interop.test.ts",
     "download-spec-tests": "node --loader=ts-node/esm test/spec/downloadTests.ts",
     "download-comptests": "node --loader=ts-node/esm test/spec/downloadComptests.ts",
-    "test:comptest": "RUN_FORK_CHOICE_COMPLIANCE=1 vitest run --project spec-minimal test/spec/presets/fork_choice.test.ts -t fork_choice_compliance",
+    "test:comptest": "vitest run --project comptest",
     "test:spec:bls": "vitest run --project spec-minimal test/spec/bls/",
     "test:spec:general": "vitest run --project spec-minimal test/spec/general/",
     "test:spec:minimal": "vitest run --project spec-minimal test/spec/presets/",
diff --git a/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
new file mode 100644
index 000000000000..a4d7bb520207
--- /dev/null
+++ b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+import {ACTIVE_PRESET} from "@lodestar/params";
+import {ethereumConsensusSpecsTests} from "../specTestVersioning.js";
+import {forkChoiceTestRunner} from "../utils/forkChoiceTestRunner.js";
+import {specTestIterator} from "../utils/specTestIterator.js";
+import {RunnerType} from "../utils/types.js";
+
+// Fork-choice compliance suite (`pnpm test:comptest`) — its own vitest project, never part of
+// the regular spec runs. Fixtures via `pnpm download-comptests`.
+
+// Zero-test guard: the workspace vitest config sets `passWithNoTests: true`, so without this a
+// run against missing fixtures would silently pass.
+const presetDir = path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET);
+const hasComplianceFixtures =
+  fs.existsSync(presetDir) &&
+  fs.readdirSync(presetDir).some((fork) => fs.existsSync(path.join(presetDir, fork, "fork_choice_compliance")));
+if (!hasComplianceFixtures) {
+  throw Error("No fork_choice_compliance fixtures found — run `pnpm download-comptests` first");
+}
+
+specTestIterator(presetDir, {
+  fork_choice_compliance: {type: RunnerType.default, fn: forkChoiceTestRunner({onlyPredefinedResponses: false})},
+});
diff --git a/packages/beacon-node/test/spec/presets/fork_choice.test.ts b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
index 3dd8db894ae4..3cd1bf9d4cf8 100644
--- a/packages/beacon-node/test/spec/presets/fork_choice.test.ts
+++ b/packages/beacon-node/test/spec/presets/fork_choice.test.ts
@@ -1,1086 +1,11 @@
-import fs from "node:fs";
 import path from "node:path";
-import {generateKeyPair} from "@libp2p/crypto/keys";
-import {expect} from "vitest";
-import {toHexString} from "@chainsafe/ssz";
-import {createBeaconConfig} from "@lodestar/config";
-import {getConfig} from "@lodestar/config/test-utils";
-import {CheckpointWithHex, ExecutionStatus, ForkChoice, getCommitteeFraction} from "@lodestar/fork-choice";
-import {testLogger} from "@lodestar/logger/test-utils";
-import {
-  ACTIVE_PRESET,
-  EFFECTIVE_BALANCE_INCREMENT,
-  ForkPostDeneb,
-  ForkPostFulu,
-  ForkPostGloas,
-  ForkPreDeneb,
-  ForkPreFulu,
-  ForkPreGloas,
-  ForkSeq,
-  SLOTS_PER_EPOCH,
-} from "@lodestar/params";
-import {InputType} from "@lodestar/spec-test-util";
-import {
-  BeaconStateAllForks,
-  BeaconStateView,
-  DataAvailabilityStatus,
-  IBeaconStateViewGloas,
-  computeEpochAtSlot,
-  createCachedBeaconState,
-  createPubkeyCache,
-  createSingleSignatureSetFromComponents,
-  getIndexedAttestation,
-  getPayloadAttestationDataSigningRoot,
-  isExecutionStateType,
-  isGloasStateType,
-  signedBlockToSignedHeader,
-  syncPubkeys,
-} from "@lodestar/state-transition";
-import {
-  Attestation,
-  AttesterSlashing,
-  BeaconBlock,
-  RootHex,
-  SignedBeaconBlock,
-  deneb,
-  fulu,
-  gloas,
-  ssz,
-  sszTypesFor,
-} from "@lodestar/types";
-import {PayloadAttestationMessage} from "@lodestar/types/gloas";
-import {bnToNum, fromHex, toHex, toRootHex} from "@lodestar/utils";
-import {
-  BlockInputBlobs,
-  BlockInputColumns,
-  BlockInputNoData,
-  BlockInputPreData,
-  BlockInputSource,
-} from "../../../src/chain/blocks/blockInput/index.js";
-import {AttestationImportOpt, BlobSidecarValidation} from "../../../src/chain/blocks/types.js";
-import {
-  verifyExecutionPayloadEnvelope,
-  verifyExecutionPayloadEnvelopeSignature,
-} from "../../../src/chain/blocks/verifyExecutionPayloadEnvelope.js";
-import {BlockError, BlockErrorCode} from "../../../src/chain/errors/blockError.js";
-import {BeaconChain, ChainEvent} from "../../../src/chain/index.js";
-import {defaultChainOptions} from "../../../src/chain/options.js";
-import {RegenCaller} from "../../../src/chain/regen/index.js";
-import {getShufflingForAttestationVerification} from "../../../src/chain/validation/attestation.js";
-import {validateFuluBlockDataColumnSidecars} from "../../../src/chain/validation/dataColumnSidecar.js";
-import {ZERO_HASH_HEX} from "../../../src/constants/constants.js";
-import {ExecutionPayloadStatus} from "../../../src/execution/engine/interface.js";
-import {ExecutionEngineMockBackend} from "../../../src/execution/engine/mock.js";
-import {getExecutionEngineFromBackend} from "../../../src/execution/index.js";
-import {computePreFuluKzgCommitmentsInclusionProof} from "../../../src/util/blobs.js";
-import {ClockEvent} from "../../../src/util/clock.js";
-import {ClockStopped} from "../../mocks/clock.js";
-import {getMockedBeaconDb} from "../../mocks/mockedBeaconDb.js";
-import {assertCorrectProgressiveBalances} from "../config.js";
+import {ACTIVE_PRESET} from "@lodestar/params";
 import {ethereumConsensusSpecsTests} from "../specTestVersioning.js";
+import {forkChoiceTestRunner} from "../utils/forkChoiceTestRunner.js";
 import {specTestIterator} from "../utils/specTestIterator.js";
-import {RunnerType, TestRunnerFn} from "../utils/types.js";
-
-const ANCHOR_STATE_FILE_NAME = "anchor_state";
-const ANCHOR_BLOCK_FILE_NAME = "anchor_block";
-const BLOCK_FILE_NAME = "^(block)_([0-9a-zA-Z]+)$";
-const BLOBS_FILE_NAME = "^(blobs)_([0-9a-zA-Z]+)$";
-const COLUMN_FILE_NAME = "^(column)_([0-9a-zA-Z]+)$";
-const EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME = "^(execution_payload_envelope)_([0-9a-zA-Z]+)$";
-const ATTESTATION_FILE_NAME = "^(attestation)_([0-9a-zA-Z])+$";
-const ATTESTER_SLASHING_FILE_NAME = "^(attester_slashing)_([0-9a-zA-Z])+$";
-const PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME = "^(payload_attestation_message)_([0-9a-zA-Z])+$";
-
-const logger = testLogger("spec-test");
-
-const forkChoiceTest =
-  (opts: {onlyPredefinedResponses: boolean}): TestRunnerFn<ForkChoiceTestCase, void> =>
-  (fork) => {
-    return {
-      testFunction: async (testcase, _directoryName, testCaseName) => {
-        const {steps, anchorState} = testcase;
-        const currentSlot = anchorState.slot;
-        const config = getConfig(fork);
-        // const state = createCachedBeaconStateTest(anchorState, config);
-
-        /** This is to track test's tickTime to be used in proposer boost */
-        let tickTime = 0;
-        const clock = new ClockStopped(currentSlot);
-        const executionEngineBackend = new ExecutionEngineMockBackend({
-          onlyPredefinedResponses: opts.onlyPredefinedResponses,
-          genesisBlockHash: isGloasStateType(anchorState)
-            ? toHexString(anchorState.latestBlockHash)
-            : isExecutionStateType(anchorState)
-              ? toHexString(anchorState.latestExecutionPayloadHeader.blockHash)
-              : ZERO_HASH_HEX,
-        });
-
-        const controller = new AbortController();
-        const executionEngine = getExecutionEngineFromBackend(executionEngineBackend, {
-          signal: controller.signal,
-          logger: testLogger("executionEngine"),
-        });
-
-        const beaconConfig = createBeaconConfig(config, anchorState.genesisValidatorsRoot);
-        const pubkeyCache = createPubkeyCache();
-        syncPubkeys(pubkeyCache, anchorState.validators.getAllReadonlyValues());
-        const cachedState = createCachedBeaconState(
-          anchorState,
-          {
-            config: beaconConfig,
-            pubkeyCache,
-          },
-          {skipSyncPubkeys: true}
-        );
-
-        const chain = new BeaconChain(
-          {
-            ...defaultChainOptions,
-            // Do not start workers
-            blsVerifyAllMainThread: true,
-            // Do not run any archiver tasks
-            disableArchiveOnCheckpoint: true,
-            // Since the tests have deep-reorgs attested data is not available often printing lots of error logs.
-            // While this function is only called for head blocks, best to disable.
-            disableLightClientServerOnImportBlockHead: true,
-            // No need to log BlockErrors, the spec test runner will only log them if not not expected
-            // Otherwise spec tests logs get cluttered with expected errors
-            disableOnBlockError: true,
-            // PrepareNextSlot scheduler is used to precompute epoch transition and prepare for the next payload
-            // we don't use these in fork choice spec tests
-            disablePrepareNextSlot: true,
-            assertCorrectProgressiveBalances,
-            proposerBoost: true,
-            proposerBoostReorg: true,
-          },
-          {
-            privateKey: await generateKeyPair("secp256k1"),
-            config: beaconConfig,
-            pubkeyCache,
-            db: getMockedBeaconDb(),
-            dataDir: ".",
-            dbName: ",",
-            logger,
-            processShutdownCallback: () => {},
-            clock,
-            metrics: null,
-            validatorMonitor: null,
-            anchorState: new BeaconStateView(cachedState),
-            isAnchorStateFinalized: true,
-            executionEngine,
-            executionBuilder: undefined,
-          }
-        );
-
-        // The handler of `ChainEvent.forkChoiceFinalized` access `db.block` and raise error if not found.
-        chain.emitter.removeAllListeners(ChainEvent.forkChoiceFinalized);
-
-        const stepsLen = steps.length;
-        logger.debug("Fork choice test", {steps: stepsLen});
-
-        try {
-          for (const [i, step] of steps.entries()) {
-            if (isTick(step)) {
-              tickTime = bnToNum(step.tick);
-              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
-              logger.debug(`Step ${i}/${stepsLen} tick`, {currentSlot, valid: Boolean(step.valid), time: tickTime});
-              clock.emit(ClockEvent.slot, currentSlot);
-              clock.setSlot(currentSlot);
-            }
-
-            // attestation step
-            else if (isAttestation(step)) {
-              const isValid = Boolean(step.valid ?? true);
-              logger.debug(`Step ${i}/${stepsLen} attestation`, {root: step.attestation, valid: isValid});
-              const attestation = testcase.attestations.get(step.attestation);
-              if (!attestation) throw Error(`No attestation ${step.attestation}`);
-              const attDataRootHex = toHexString(sszTypesFor(fork).AttestationData.hashTreeRoot(attestation.data));
-
-              // Spec `validate_on_attestation` requires `get_current_slot(store) >= attestation.data.slot + 1`
-              // (an attestation may only influence fork choice from the slot AFTER it was created). Lodestar
-              // enforces this 1-slot delay in the gossip/attestation-pool layer, not in `forkChoice.onAttestation`,
-              // so replicate the precondition here since the runner calls `onAttestation` directly.
-              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
-              if (currentSlot < attestation.data.slot + 1) {
-                if (isValid) {
-                  throw Error(`Attestation not yet 1 slot old but marked valid at step ${i}`);
-                }
-                logger.debug(
-                  `Step ${i}/${stepsLen} skip attestation: not yet 1 slot old (spec on_attestation rejects)`,
-                  {
-                    attSlot: attestation.data.slot,
-                    currentSlot,
-                  }
-                );
-                continue;
-              }
-
-              // `on_attestation` decodes aggregation_bits with the shuffling at the attestation's
-              // target checkpoint, not the head state — resolve it via ShufflingCache + regen so
-              // cross-epoch fork attestations (surfaced by the compliance suite) decode correctly.
-              // The resolution runs inside the try so that errors on `valid: false` steps (e.g.
-              // attesting to a future block) count as the expected rejection.
-              const attHeadBlock = chain.forkChoice.getBlockHexDefaultStatus(toHex(attestation.data.beaconBlockRoot));
-              if (attHeadBlock === null && isValid) {
-                throw Error(`Attestation beacon block root unknown to fork choice at step ${i}`);
-              }
-              try {
-                if (attHeadBlock === null) throw Error("Unknown attestation head block (expected rejection)");
-                const shuffling = await getShufflingForAttestationVerification(
-                  chain,
-                  computeEpochAtSlot(attestation.data.slot),
-                  attHeadBlock,
-                  RegenCaller.validateGossipAttestation
-                );
-                const indexedAttestation = getIndexedAttestation(shuffling, ForkSeq[fork], attestation);
-                chain.forkChoice.onAttestation(indexedAttestation, attDataRootHex);
-                if (!isValid) throw Error("Expect error since this is a negative test");
-              } catch (e) {
-                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
-              }
-            }
-
-            // attester slashing step
-            else if (isAttesterSlashing(step)) {
-              logger.debug(`Step ${i}/${stepsLen} attester slashing`, {
-                root: step.attester_slashing,
-                valid: Boolean(step.valid),
-              });
-              const attesterSlashing = testcase.attesterSlashings.get(step.attester_slashing);
-              if (!attesterSlashing) throw Error(`No attester slashing ${step.attester_slashing}`);
-              chain.forkChoice.onAttesterSlashing(attesterSlashing);
-            }
-
-            // payload attestation message step
-            else if (isPayloadAttestationMessage(step)) {
-              const isValid = Boolean(step.valid ?? true);
-              logger.debug(`Step ${i}/${stepsLen} payload attestation message`, {
-                root: step.payload_attestation_message,
-                valid: isValid,
-              });
-              const payloadAttestationMessage = testcase.payloadAttestationMessages.get(
-                step.payload_attestation_message
-              );
-              if (!payloadAttestationMessage)
-                throw Error(`No payload attestation message ${step.payload_attestation_message}`);
-              try {
-                const blockRoot = toRootHex(payloadAttestationMessage.data.beaconBlockRoot);
-                const protoBlock = chain.forkChoice.getBlockHexDefaultStatus(blockRoot);
-                if (!protoBlock) {
-                  throw Error(`Block not found for root ${blockRoot}`);
-                }
-
-                // Spec `on_payload_attestation_message` asserts the attested block is from the
-                // message's slot — a mismatch is a rejection, not a silent no-op.
-                if (protoBlock.slot !== payloadAttestationMessage.data.slot) {
-                  throw Error(
-                    `Block slot ${protoBlock.slot} does not match payload attestation slot ${payloadAttestationMessage.data.slot}`
-                  );
-                }
-                {
-                  const blockState = await chain.regen.getBlockSlotState(
-                    protoBlock,
-                    payloadAttestationMessage.data.slot,
-                    {dontTransferCache: true},
-                    RegenCaller.processBlock
-                  );
-
-                  const ptcIndices = (blockState as IBeaconStateViewGloas).getIndicesInPayloadTimelinessCommittee(
-                    payloadAttestationMessage.validatorIndex,
-                    payloadAttestationMessage.data.slot
-                  );
-
-                  // Spec asserts the validator is a PTC member for the slot
-                  if (ptcIndices.length === 0) {
-                    throw Error(
-                      `Validator ${payloadAttestationMessage.validatorIndex} not in PTC for slot ${payloadAttestationMessage.data.slot}`
-                    );
-                  }
-
-                  // Slot check, matching the `validateGossipPayloadAttestationMessage` flow
-                  if (clock.currentSlot !== payloadAttestationMessage.data.slot) {
-                    throw Error(
-                      `Message slot ${payloadAttestationMessage.data.slot} is not current slot ${clock.currentSlot}`
-                    );
-                  }
-
-                  // Signature verification (matching `validateGossipPayloadAttestationMessage`) — skipped for
-                  // bls_setting !== 1: compliance fixtures use placeholder signatures (bls_setting: 2), so the
-                  // spec reference runner does not verify. Mirror the block-import accommodation (`validSignatures`).
-                  if (testcase.meta?.bls_setting === BigInt(1)) {
-                    const validatorPubkey = pubkeyCache.get(payloadAttestationMessage.validatorIndex);
-                    if (!validatorPubkey) {
-                      throw Error(`Unknown validator index ${payloadAttestationMessage.validatorIndex}`);
-                    }
-                    const signatureSet = createSingleSignatureSetFromComponents(
-                      validatorPubkey,
-                      getPayloadAttestationDataSigningRoot(beaconConfig, payloadAttestationMessage.data),
-                      payloadAttestationMessage.signature
-                    );
-                    let signatureValidity: boolean;
-                    try {
-                      signatureValidity = await chain.bls.verifySignatureSets([signatureSet], {
-                        verifyOnMainThread: true,
-                        batchable: true,
-                        priority: true,
-                      });
-                    } catch {
-                      signatureValidity = false;
-                    }
-                    if (!signatureValidity) throw Error("Invalid payload attestation signature");
-                  }
-
-                  chain.forkChoice.notifyPtcMessages(
-                    blockRoot,
-                    payloadAttestationMessage.data.slot,
-                    ptcIndices,
-                    payloadAttestationMessage.data.payloadPresent,
-                    payloadAttestationMessage.data.blobDataAvailable
-                  );
-                }
-                if (!isValid) throw Error("Expect error since this is a negative test");
-              } catch (e) {
-                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
-              }
-            }
-
-            // block step
-            else if (isBlock(step)) {
-              const isValid = Boolean(step.valid ?? true);
-              const signedBlock = testcase.blocks.get(step.block);
-              if (!signedBlock) {
-                throw Error(`No block ${step.block}`);
-              }
-
-              // Post-Deneb and pre-Fulu, `columns` should not be present. Post-Fulu `blobs` and
-              // `proofs` should not be present.
-              let blobs: deneb.Blob[] | undefined;
-              let proofs: deneb.KZGProof[] | undefined;
-              let columns: fulu.DataColumnSidecar[] | undefined;
-              if (step.blobs !== undefined) {
-                blobs = testcase.blobs.get(step.blobs);
-              }
-              if (step.proofs !== undefined) {
-                proofs = step.proofs.map((proof) => ssz.deneb.KZGProof.deserialize(fromHex(proof)));
-              }
-              if (step.columns !== undefined) {
-                columns = [];
-                for (const columnName of step.columns) {
-                  const column = testcase.columns.get(columnName);
-                  if (column === undefined) {
-                    throw Error(`Malformed spec test. Column file with name ${columnName} not found.`);
-                  }
-                  columns.push(column);
-                }
-              }
-
-              const {slot} = signedBlock.message;
-              // Log the BeaconBlock root instead of the SignedBeaconBlock root, forkchoice references BeaconBlock roots
-              const blockRoot = config
-                .getForkTypes(signedBlock.message.slot)
-                .BeaconBlock.hashTreeRoot(signedBlock.message);
-              const blockRootHex = toHex(blockRoot);
-              logger.debug(`Step ${i}/${stepsLen} block`, {
-                slot,
-                id: step.block,
-                root: toHexString(blockRoot),
-                parentRoot: toHexString(signedBlock.message.parentRoot),
-                isValid,
-              });
-
-              try {
-                let blockImport;
-                const forkSeq = config.getForkSeq(slot);
-
-                if (forkSeq >= ForkSeq.gloas) {
-                  // Gloas (ePBS) blocks don't carry blobs/columns directly on the block body.
-                  // Blob KZG commitments are nested inside signedExecutionPayloadBid.
-                  // Use BlockInputNoData since DA is handled separately via execution payload envelopes.
-                  blockImport = BlockInputNoData.createFromBlock({
-                    forkName: fork,
-                    block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
-                    blockRootHex,
-                    source: BlockInputSource.gossip,
-                    seenTimestampSec: 0,
-                    daOutOfRange: false,
-                  });
-                  // importBlock requires a PayloadEnvelopeInput to exist for gloas blocks; in
-                  // production this is seeded by gossip / by-root / by-range / API producers.
-                  // Spec tests bypass those, so seed it here to mirror the gossip-handler path.
-                  chain.seenPayloadEnvelopeInputCache.add({
-                    blockRootHex,
-                    block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
-                    forkName: fork,
-                    sampledColumns: chain.custodyConfig.sampledColumns,
-                    custodyColumns: chain.custodyConfig.custodyColumns,
-                    timeCreatedSec: Date.now() / 1000,
-                  });
-                } else if (forkSeq >= ForkSeq.fulu) {
-                  if (columns === undefined) {
-                    columns = [];
-                  }
-
-                  await validateFuluBlockDataColumnSidecars(
-                    chain,
-                    slot,
-                    blockRoot,
-                    (signedBlock as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>).message.body.blobKzgCommitments
-                      .length,
-                    columns,
-                    chain.metrics?.peerDas
-                  );
-
-                  blockImport = BlockInputColumns.createFromBlock({
-                    forkName: fork,
-                    block: signedBlock as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>,
-                    blockRootHex,
-                    custodyColumns:
-                      // in most test case instances we do not want to assign any custody as there are no columns provided
-                      // with the test case.  For on_block_peerdas__not_available the exact situation that is being tested
-                      // is no availability so block processing should fail.  For this one test case add some default
-                      // custody so that the await will fail in verifyBlocksDataAvailability.ts
-                      testCaseName !== "on_block_peerdas__not_available" ? columns.map((c) => c.index) : [2, 4, 6, 8],
-                    sampledColumns:
-                      testCaseName !== "on_block_peerdas__not_available"
-                        ? columns.map((c) => c.index)
-                        : [2, 4, 6, 8, 10, 12, 14, 16],
-                    source: BlockInputSource.gossip,
-                    seenTimestampSec: 0,
-                    daOutOfRange: false,
-                  });
-                  for (const column of columns) {
-                    blockImport.addColumn({
-                      blockRootHex,
-                      columnSidecar: column,
-                      source: BlockInputSource.gossip,
-                      seenTimestampSec: 0,
-                    });
-                  }
-                  // getBlockInput.availableData(config, signedBlock, BlockSource.gossip, blockData);
-                } else if (forkSeq >= ForkSeq.deneb && forkSeq < ForkSeq.fulu) {
-                  if (blobs === undefined) {
-                    // seems like some deneb tests don't have this and we are supposed to assume empty
-                    // throw Error("Missing blobs for the deneb+ block");
-                    blobs = [];
-                  }
-                  if (proofs === undefined) {
-                    // seems like some deneb tests don't have this and we are supposed to assume empty
-                    // throw Error("proofs for the deneb+ block");
-                    proofs = [];
-                  }
-                  // the kzg lib for validation of minimal setup is not yet integrated, lets just verify lengths
-                  // post integration use validateBlobsAndProofs
-                  const commitments = (signedBlock as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
-                  if (blobs.length !== commitments.length || proofs.length !== commitments.length) {
-                    throw Error("Invalid blobs or proofs lengths");
-                  }
-
-                  const blobSidecars: deneb.BlobSidecars = blobs.map((blob, index) => {
-                    return {
-                      index,
-                      blob,
-                      kzgCommitment: commitments[index],
-                      kzgProof: (proofs ?? [])[index],
-                      signedBlockHeader: signedBlockToSignedHeader(config, signedBlock),
-                      kzgCommitmentInclusionProof: computePreFuluKzgCommitmentsInclusionProof(
-                        fork,
-                        signedBlock.message.body,
-                        index
-                      ),
-                    };
-                  });
-
-                  blockImport = BlockInputBlobs.createFromBlock({
-                    forkName: fork,
-                    block: signedBlock as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>,
-                    blockRootHex,
-                    source: BlockInputSource.gossip,
-                    seenTimestampSec: 0,
-                    daOutOfRange: false,
-                  });
-                  for (const blob of blobSidecars) {
-                    blockImport.addBlob({
-                      blockRootHex,
-                      blobSidecar: blob,
-                      source: BlockInputSource.gossip,
-                      seenTimestampSec: 0,
-                    });
-                  }
-                } else {
-                  blockImport = BlockInputPreData.createFromBlock({
-                    forkName: fork,
-                    block: signedBlock as SignedBeaconBlock<ForkPreDeneb>,
-                    blockRootHex,
-                    source: BlockInputSource.gossip,
-                    seenTimestampSec: 0,
-                    daOutOfRange: false,
-                  });
-                }
-
-                await chain.processBlock(blockImport, {
-                  seenTimestampSec: tickTime,
-                  validBlobSidecars: BlobSidecarValidation.Full,
-                  importAttestations: AttestationImportOpt.Force,
-                  validSignatures: testcase.meta?.bls_setting !== BigInt(1),
-                });
-                if (!isValid) throw Error("Expect error since this is a negative test");
-              } catch (e) {
-                // Spec `on_block` is a no-op success on a known block; lodestar's production
-                // import path rejects with ALREADY_KNOWN. Treat as success in the spec runner.
-                if (isValid && e instanceof BlockError && e.type.code === BlockErrorCode.ALREADY_KNOWN) {
-                  logger.debug(`Step ${i}/${stepsLen} block already known — treating as no-op success`, {
-                    id: step.block,
-                  });
-                } else if (isValid || (e as Error).message === "Expect error since this is a negative test") {
-                  throw e;
-                }
-              }
-            }
-
-            // execution_payload step for Gloas (ePBS) tests
-            else if (isExecutionPayload(step)) {
-              const isValid = Boolean(step.valid ?? true);
-              logger.debug(`Step ${i}/${stepsLen} execution_payload`, {
-                envelope: step.execution_payload,
-                valid: isValid,
-              });
-              const envelope = testcase.executionPayloadEnvelopes.get(step.execution_payload);
-              if (!envelope) throw Error(`No execution payload envelope ${step.execution_payload}`);
-
-              try {
-                const beaconBlockRoot = toHex(envelope.message.beaconBlockRoot);
-                const blockHash = toHex(envelope.message.payload.blockHash);
-                const blockNumber = envelope.message.payload.blockNumber;
-                const gasLimit = envelope.message.payload.gasLimit;
-
-                // Verify envelope against the state
-                const protoBlock = chain.forkChoice.getBlockHexDefaultStatus(beaconBlockRoot);
-                if (!protoBlock) throw Error(`Block not found for root ${beaconBlockRoot}`);
-                const blockState = await chain.regen.getBlockSlotState(
-                  protoBlock,
-                  protoBlock.slot,
-                  {dontTransferCache: true},
-                  RegenCaller.processBlock
-                );
-                verifyExecutionPayloadEnvelope(beaconConfig, blockState as IBeaconStateViewGloas, envelope.message);
-
-                // Verify signature — skipped for bls_setting !== 1: compliance fixtures use placeholder
-                // signatures (bls_setting: 2), so the spec reference runner does not verify. Mirror the
-                // block-import accommodation (`validSignatures` above).
-                if (testcase.meta?.bls_setting === BigInt(1)) {
-                  const sigValid = await verifyExecutionPayloadEnvelopeSignature(
-                    beaconConfig,
-                    blockState as IBeaconStateViewGloas,
-                    pubkeyCache,
-                    envelope,
-                    blockState.latestBlockHeader.proposerIndex,
-                    chain.bls
-                  );
-                  if (!sigValid) throw Error("Invalid execution payload envelope signature");
-                }
-
-                // Add predefined VALID status for the payload's block hash so the EL mock accepts it
-                executionEngineBackend.addPredefinedPayloadStatus(blockHash, {
-                  status: ExecutionPayloadStatus.VALID,
-                  latestValidHash: null,
-                  validationError: null,
-                });
-
-                (chain.forkChoice as ForkChoice).onExecutionPayload(
-                  beaconBlockRoot,
-                  blockHash,
-                  blockNumber,
-                  gasLimit,
-                  ExecutionStatus.Valid,
-                  DataAvailabilityStatus.Available
-                );
-                if (!isValid) throw Error("Expect error since this is a negative test");
-              } catch (e) {
-                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
-              }
-            }
-
-            // Optional step for optimistic sync tests.
-            else if (isOnPayloadInfoStep(step)) {
-              logger.debug(`Step ${i}/${stepsLen} payload_status`, {blockHash: step.block_hash});
-              const status = ExecutionPayloadStatus[step.payload_status.status];
-              if (status === undefined) {
-                throw Error(`Unknown payload_status.status: ${step.payload_status.status}`);
-              }
-              executionEngineBackend.addPredefinedPayloadStatus(step.block_hash, {
-                status,
-                latestValidHash: step.payload_status.latest_valid_hash,
-                validationError: step.payload_status.validation_error,
-              });
-            }
-
-            // checks step
-            else if (isCheck(step)) {
-              logger.debug(`Step ${i}/${stepsLen} check`);
-
-              // Forkchoice head is computed lazily only on request
-              const head = (chain.forkChoice as ForkChoice).updateHead();
-              const proposerBootRoot = (chain.forkChoice as ForkChoice).getProposerBoostRoot();
-              // Spec: EMPTY=0, FULL=1, PENDING=2; Ours: PENDING=0, EMPTY=1, FULL=2
-              const payloadStatusToSpec: Record<number, number> = {0: 2, 1: 0, 2: 1};
-
-              if (step.checks.head !== undefined) {
-                expect({slot: head.slot, root: head.blockRoot}).toEqualWithMessage(
-                  {slot: bnToNum(step.checks.head.slot), root: step.checks.head.root},
-                  `Invalid head at step ${i}`
-                );
-                // Gloas and later: payload_status is nested inside the head check
-                if (step.checks.head.payload_status !== undefined) {
-                  expect(payloadStatusToSpec[head.payloadStatus]).toEqualWithMessage(
-                    bnToNum(step.checks.head.payload_status),
-                    `Invalid head payload status at step ${i}`
-                  );
-                }
-              }
-              if (step.checks.proposer_boost_root !== undefined) {
-                expect(proposerBootRoot).toEqualWithMessage(
-                  step.checks.proposer_boost_root,
-                  `Invalid proposer boost root at step ${i}`
-                );
-              }
-              // time in spec mapped to Slot in our forkchoice implementation.
-              // Compare in slots because proposer boost steps doesn't always come on
-              // slot boundary.
-              if (step.checks.time !== undefined && step.checks.time > 0)
-                expect(chain.forkChoice.getTime()).toEqualWithMessage(
-                  Math.floor(bnToNum(step.checks.time) / (config.SLOT_DURATION_MS / 1000)),
-                  `Invalid forkchoice time at step ${i}`
-                );
-              if (step.checks.justified_checkpoint) {
-                expect(toSpecTestCheckpoint(chain.forkChoice.getJustifiedCheckpoint())).toEqualWithMessage(
-                  step.checks.justified_checkpoint,
-                  `Invalid justified checkpoint at step ${i}`
-                );
-              }
-              if (step.checks.finalized_checkpoint) {
-                expect(toSpecTestCheckpoint(chain.forkChoice.getFinalizedCheckpoint())).toEqualWithMessage(
-                  step.checks.finalized_checkpoint,
-                  `Invalid finalized checkpoint at step ${i}`
-                );
-              }
-              if (step.checks.get_proposer_head) {
-                const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
-                const {proposerHead, notReorgedReason} = (chain.forkChoice as ForkChoice).getProposerHead(
-                  head,
-                  tickTime % (config.SLOT_DURATION_MS / 1000),
-                  currentSlot
-                );
-                logger.debug(`Not reorged reason ${notReorgedReason} at step ${i}`);
-                expect(proposerHead.blockRoot).toEqualWithMessage(
-                  step.checks.get_proposer_head,
-                  `Invalid proposer head at step ${i}`
-                );
-              }
-              if (step.checks.viable_for_head_roots_and_weights !== undefined) {
-                // Entries are identified by (root, payload_status, weight) per
-                // https://github.com/ethereum/consensus-specs/pull/5393 — gloas EMPTY/FULL
-                // variants of one block root are separate entries. Pre-gloas vectors omit
-                // payload_status (every pre-gloas node is FULL internally).
-                const isGloas = ForkSeq[fork] >= ForkSeq.gloas;
-                const expected = step.checks.viable_for_head_roots_and_weights
-                  .map((entry) => ({
-                    root: entry.root,
-                    payloadStatus: entry.payload_status !== undefined ? bnToNum(entry.payload_status) : undefined,
-                    weightGwei: entry.weight,
-                  }))
-                  .sort(cmpViableHead);
-                const actual = (chain.forkChoice as ForkChoice)
-                  .getViableHeads()
-                  .map(({root, payloadStatus, weight}) => ({
-                    root,
-                    payloadStatus: isGloas ? payloadStatusToSpec[payloadStatus] : undefined,
-                    weightGwei: BigInt(weight) * BigInt(EFFECTIVE_BALANCE_INCREMENT),
-                  }))
-                  .sort(cmpViableHead);
-
-                // The set of viable heads is determined by justified/finalized epochs, not weight,
-                // so identity must match exactly. Comparing the full sets (not a subset) also
-                // rejects a degenerate empty result.
-                expect(actual.map(({root, payloadStatus}) => ({root, payloadStatus}))).toEqualWithMessage(
-                  expected.map(({root, payloadStatus}) => ({root, payloadStatus})),
-                  `Invalid viable head roots at step ${i}`
-                );
-
-                // Exact weight comparison with boost emulation. Lodestar tracks weights in
-                // EFFECTIVE_BALANCE_INCREMENT units: attestation weight is exact (effective
-                // balances are increment multiples) but the proposer-boost score is double-floored
-                // to whole ETH (getCommitteeFraction) while the spec keeps Gwei precision — a
-                // known production divergence, bounded by
-                // (100 - gcd(PROPOSER_SCORE_BOOST, 100) + PROPOSER_SCORE_BOOST) / 100 = 1.2 ETH.
-                // Rather than compare within a tolerance (which would mask sub-1.2-ETH weight
-                // bugs), normalize the expected weight of the boosted entry by
-                // `- spec_boost + lodestar_boost` and compare exactly.
-                //
-                // Ordering rules (so normalization cannot mask a wrong boost root):
-                // - `checks.proposer_boost_root` was already asserted above, unadjusted.
-                // - Normalize using the VECTOR's expected boost root, never our actual one.
-                // - Zero boost root or absent field => no adjustment.
-                const expectedBoostRoot = step.checks.proposer_boost_root;
-                let specBoostGwei = BigInt(0);
-                let lodestarBoostGwei = BigInt(0);
-                if (expectedBoostRoot !== undefined && expectedBoostRoot !== ZERO_HASH_HEX) {
-                  const totalBalanceByIncrement = (
-                    chain.forkChoice as ForkChoice
-                  ).getJustifiedTotalActiveBalanceByIncrement();
-                  const totalBalanceGwei = BigInt(totalBalanceByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
-                  // Spec: ((total_active_balance // SLOTS_PER_EPOCH) * PROPOSER_SCORE_BOOST) // 100, in Gwei
-                  specBoostGwei =
-                    ((totalBalanceGwei / BigInt(SLOTS_PER_EPOCH)) * BigInt(config.PROPOSER_SCORE_BOOST)) / BigInt(100);
-                  // Lodestar: same formula double-floored in increment units — use the production
-                  // function directly so the emulation cannot drift from the implementation.
-                  lodestarBoostGwei =
-                    BigInt(
-                      getCommitteeFraction(totalBalanceByIncrement, {
-                        slotsPerEpoch: SLOTS_PER_EPOCH,
-                        committeePercent: config.PROPOSER_SCORE_BOOST,
-                      })
-                    ) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
-                }
-                for (const [k, act] of actual.entries()) {
-                  const exp = expected[k];
-                  // TODO GLOAS: boost attribution across payload-status variants of the boosted
-                  // root is Phase 4 work; pre-gloas each root has exactly one entry.
-                  const isBoosted = exp.root === expectedBoostRoot;
-                  const expectedAdjusted = isBoosted
-                    ? exp.weightGwei - specBoostGwei + lodestarBoostGwei
-                    : exp.weightGwei;
-                  expect(act.weightGwei).toEqualWithMessage(
-                    expectedAdjusted,
-                    `Invalid viable head weight for ${act.root} at step ${i}` +
-                      (isBoosted ? ` (boost-normalized: spec=${specBoostGwei} lodestar=${lodestarBoostGwei})` : "")
-                  );
-                }
-              }
-              if (step.checks.should_override_forkchoice_update) {
-                const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
-                const result = chain.forkChoice.shouldOverrideForkChoiceUpdate(
-                  head,
-                  tickTime % (config.SLOT_DURATION_MS / 1000),
-                  currentSlot
-                );
-                if (result.shouldOverrideFcu === false) {
-                  logger.debug(`Not override fcu reason ${result.reason} at step ${i}`);
-                }
-                expect({result: result.shouldOverrideFcu, validator_is_connected: true}).toEqualWithMessage(
-                  step.checks.should_override_forkchoice_update,
-                  `Invalid should override fcu result at step ${i}`
-                );
-              }
-              if (step.checks.payload_timeliness_vote) {
-                expect(
-                  chain.forkChoice.getPayloadTimelinessVotes(step.checks.payload_timeliness_vote.block_root)
-                ).toEqualWithMessage(
-                  step.checks.payload_timeliness_vote.votes,
-                  `Invalid payload timeliness votes at step ${i}`
-                );
-              }
-              if (step.checks.payload_data_availability_vote) {
-                expect(
-                  chain.forkChoice.getPayloadDataAvailabilityVotes(
-                    step.checks.payload_data_availability_vote.block_root
-                  )
-                ).toEqualWithMessage(
-                  step.checks.payload_data_availability_vote.votes,
-                  `Invalid payload data availability votes at step ${i}`
-                );
-              }
-            }
-
-            // None of the above
-            else {
-              throw Error(`Unknown step ${i}/${stepsLen}: ${JSON.stringify(Object.keys(step))}`);
-            }
-          }
-        } finally {
-          await chain.close();
-        }
-      },
-
-      options: {
-        inputTypes: {
-          meta: InputType.YAML,
-          steps: InputType.YAML,
-        },
-        sszTypes: {
-          [ANCHOR_STATE_FILE_NAME]: ssz[fork].BeaconState,
-          [ANCHOR_BLOCK_FILE_NAME]: ssz[fork].BeaconBlock,
-          [BLOCK_FILE_NAME]: ssz[fork].SignedBeaconBlock,
-          [BLOBS_FILE_NAME]: ssz.deneb.Blobs,
-          [COLUMN_FILE_NAME]: ssz.fulu.DataColumnSidecar,
-          [EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME]: ssz.gloas.SignedExecutionPayloadEnvelope,
-          [ATTESTATION_FILE_NAME]: sszTypesFor(fork).Attestation,
-          [ATTESTER_SLASHING_FILE_NAME]: sszTypesFor(fork).AttesterSlashing,
-          [PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME]: ssz.gloas.PayloadAttestationMessage,
-        },
-        mapToTestCase: (t: Record<string, any>) => {
-          // t has input file name as key
-          const blocks = new Map<string, SignedBeaconBlock>();
-          const blobs = new Map<string, deneb.Blobs>();
-          const columns = new Map<string, fulu.DataColumnSidecar>();
-          const executionPayloadEnvelopes = new Map<string, gloas.SignedExecutionPayloadEnvelope>();
-          const attestations = new Map<string, Attestation>();
-          const attesterSlashings = new Map<string, AttesterSlashing>();
-          const payloadAttestationMessages = new Map<string, PayloadAttestationMessage>();
-          for (const key in t) {
-            if (!Object.prototype.hasOwnProperty.call(t, key)) continue;
-
-            const blockMatch = key.match(BLOCK_FILE_NAME);
-            if (blockMatch) {
-              blocks.set(key, t[key]);
-            }
-            const blobsMatch = key.match(BLOBS_FILE_NAME);
-            if (blobsMatch) {
-              blobs.set(key, t[key]);
-            }
-            const columnMatch = key.match(COLUMN_FILE_NAME);
-            if (columnMatch) {
-              columns.set(key, t[key]);
-            }
-            const envelopeMatch = key.match(EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME);
-            if (envelopeMatch) {
-              executionPayloadEnvelopes.set(key, t[key]);
-            }
-            const attMatch = key.match(ATTESTATION_FILE_NAME);
-            if (attMatch) {
-              attestations.set(key, t[key]);
-            }
-            const attesterSlashingMatch = key.match(ATTESTER_SLASHING_FILE_NAME);
-            if (attesterSlashingMatch) {
-              attesterSlashings.set(key, t[key]);
-            }
-            const payloadAttestationMessageMatch = key.match(PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME);
-            if (payloadAttestationMessageMatch) {
-              payloadAttestationMessages.set(key, t[key]);
-            }
-          }
-          return {
-            meta: t["meta"] as ForkChoiceTestCase["meta"],
-            anchorState: t[ANCHOR_STATE_FILE_NAME] as ForkChoiceTestCase["anchorState"],
-            anchorBlock: t[ANCHOR_BLOCK_FILE_NAME] as ForkChoiceTestCase["anchorBlock"],
-            steps: t["steps"] as ForkChoiceTestCase["steps"],
-            blocks,
-            blobs,
-            columns,
-            executionPayloadEnvelopes,
-            attestations,
-            attesterSlashings,
-            payloadAttestationMessages,
-          };
-        },
-        // timeout needs to be set longer than BLOB_AVAILABILITY_TIMEOUT so that on_block_peerdas__not_available fails
-        timeout: 15000,
-        expectFunc: () => {},
-        // Do not manually skip tests here, do it in packages/beacon-node/test/spec/presets/index.test.ts
-        // EXCEPTION : this test skipped here because prefix match can't be don't for this particular test
-        // as testId for the entire directory is same : `deneb/fork_choice/on_block/pyspec_tests` and
-        // we just want to skip this one particular test because we don't have minimal kzg lib integrated
-        //
-        // This skip can be removed once a kzg lib with run-time minimal blob size setup is released and
-        // integrated
-        shouldSkip: (_testcase, name, _index) =>
-          name.includes("invalid_incorrect_proof") ||
-          // TODO GLOAS: These tests will be unskipped by https://github.com/ChainSafe/lodestar/pull/9233
-          (name.includes("gloas") &&
-            (name.includes("simple_attempted_reorg_without_enough_ffg_votes") ||
-              name.includes("include_votes_another_empty_chain_with_enough_ffg_votes_current_epoch") ||
-              name.includes("include_votes_another_empty_chain_with_enough_ffg_votes_previous_epoch") ||
-              name.includes("include_votes_another_empty_chain_without_enough_ffg_votes_current_epoch"))),
-      },
-    };
-  };
-
-function toSpecTestCheckpoint(checkpoint: CheckpointWithHex): SpecTestCheckpoint {
-  return {
-    epoch: BigInt(checkpoint.epoch),
-    root: checkpoint.rootHex,
-  };
-}
-
-type Step =
-  | OnTick
-  | OnAttestation
-  | OnAttesterSlashing
-  | OnPayloadAttestationMessage
-  | OnBlock
-  | OnExecutionPayloadEnvelope
-  | OnPayloadInfo
-  | Checks;
-
-type SpecTestCheckpoint = {epoch: bigint; root: string};
-
-// This test executes steps in sequence. There may be multiple items of the following types:
-// on_tick execution step
-
-type OnTick = {
-  /** to execute `on_tick(store, time)` */
-  tick: bigint;
-  /** optional, default to `true`. */
-  valid?: number;
-};
-
-type OnAttestation = {
-  /** the name of the `attestation_<32-byte-root>.ssz_snappy` file. To execute `on_attestation(store, attestation)` */
-  attestation: string;
-  /** optional, default to `true`. */
-  valid?: number;
-};
-
-type OnAttesterSlashing = {
-  /**
-   * the name of the `attester_slashing_<32-byte-root>.ssz_snappy` file.
-   * To execute `on_attester_slashing(store, attester_slashing)` with the given attester slashing.
-   */
-  attester_slashing: string;
-  /** optional, default to `true` */
-  valid?: number;
-};
-
-type OnPayloadAttestationMessage = {
-  /**
-   * the name of the `payload_attestation_message_<32-byte-root>.ssz_snappy` file.
-   * To execute `on_payload_attestation_message(store, payload_attestation_message)`.
-   */
-  payload_attestation_message: string;
-  /** optional, default to `true` */
-  valid?: number;
-};
-
-type OnBlock = {
-  /** the name of the `block_<32-byte-root>.ssz_snappy` file. To execute `on_block(store, block)` */
-  block: string;
-  blobs?: string;
-  proofs?: string[];
-  columns?: string[];
-  /** optional, default to `true`. */
-  valid?: number;
-};
-
-type OnExecutionPayloadEnvelope = {
-  /** the name of the execution_payload_envelope file */
-  execution_payload: string;
-  /** optional, default to `true`. */
-  valid?: number;
-};
-
-type OnPayloadInfo = {
-  /** Encoded 32-byte value of payload's block hash. */
-  block_hash: string;
-  payload_status: {
-    status: "VALID" | "INVALID" | "SYNCING" | "ACCEPTED" | "INVALID_BLOCK_HASH";
-    /** Encoded 32-byte value of the latest valid block hash, may be `null`. */
-    latest_valid_hash: string;
-    /** Message providing additional details on the validation error, may be `null`. */
-    validation_error: string;
-  };
-};
-
-type Checks = {
-  /** Value in the ForkChoice store to verify it's correct after being mutated by another step */
-  checks: {
-    head?: {
-      slot: bigint;
-      root: string;
-      /** Gloas and later */
-      payload_status?: bigint;
-    };
-    time?: bigint;
-    justified_checkpoint?: SpecTestCheckpoint;
-    finalized_checkpoint?: SpecTestCheckpoint;
-    proposer_boost_root?: RootHex;
-    get_proposer_head?: string;
-    should_override_forkchoice_update?: {
-      validator_is_connected: boolean;
-      result: boolean;
-    };
-    /** Gloas: PTC timeliness votes per PTC position (`null` = member has not attested). */
-    payload_timeliness_vote?: {
-      block_root: RootHex;
-      votes: (boolean | null)[];
-    };
-    /** Gloas: PTC data-availability votes per PTC position (`null` = member has not attested). */
-    payload_data_availability_vote?: {
-      block_root: RootHex;
-      votes: (boolean | null)[];
-    };
-    viable_for_head_roots_and_weights?: {root: RootHex; weight: bigint; payload_status?: bigint}[];
-  };
-};
-
-/** Sort by (root, payload_status) — the spec fixes no order; gloas variants share a root. */
-function cmpViableHead(a: {root: string; payloadStatus?: number}, b: {root: string; payloadStatus?: number}): number {
-  return a.root.localeCompare(b.root) || (a.payloadStatus ?? 0) - (b.payloadStatus ?? 0);
-}
-
-type ForkChoiceTestCase = {
-  meta?: {
-    description?: string;
-    bls_setting: bigint;
-  };
-  anchorState: BeaconStateAllForks;
-  anchorBlock: BeaconBlock;
-  steps: Step[];
-  blocks: Map<string, SignedBeaconBlock>;
-  blobs: Map<string, deneb.Blobs>;
-  columns: Map<string, fulu.DataColumnSidecar>;
-  executionPayloadEnvelopes: Map<string, gloas.SignedExecutionPayloadEnvelope>;
-  attestations: Map<string, Attestation>;
-  attesterSlashings: Map<string, AttesterSlashing>;
-  payloadAttestationMessages: Map<string, PayloadAttestationMessage>;
-};
-
-function isTick(step: Step): step is OnTick {
-  return (step as OnTick).tick >= 0;
-}
-
-function isAttestation(step: Step): step is OnAttestation {
-  return typeof (step as OnAttestation).attestation === "string";
-}
-
-function isAttesterSlashing(step: Step): step is OnAttesterSlashing {
-  return typeof (step as OnAttesterSlashing).attester_slashing === "string";
-}
-
-function isPayloadAttestationMessage(step: Step): step is OnPayloadAttestationMessage {
-  return typeof (step as OnPayloadAttestationMessage).payload_attestation_message === "string";
-}
-
-function isBlock(step: Step): step is OnBlock {
-  return typeof (step as OnBlock).block === "string";
-}
-
-function isExecutionPayload(step: Step): step is OnExecutionPayloadEnvelope {
-  return typeof (step as OnExecutionPayloadEnvelope).execution_payload === "string";
-}
-
-function isOnPayloadInfoStep(step: Step): step is OnPayloadInfo {
-  return typeof (step as OnPayloadInfo).block_hash === "string";
-}
-
-function isCheck(step: Step): step is Checks {
-  return typeof (step as Checks).checks === "object";
-}
-
-// Zero-test guard: `pnpm test:comptest` must fail loudly when fixtures are absent —
-// a filter matching zero tests would otherwise read as green.
-if (process.env.RUN_FORK_CHOICE_COMPLIANCE === "1") {
-  const presetDir = path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET);
-  const hasComplianceFixtures =
-    fs.existsSync(presetDir) &&
-    fs.readdirSync(presetDir).some((fork) => fs.existsSync(path.join(presetDir, fork, "fork_choice_compliance")));
-  if (!hasComplianceFixtures) {
-    throw Error(
-      "RUN_FORK_CHOICE_COMPLIANCE=1 but no fork_choice_compliance fixtures found — run `pnpm download-comptests` first"
-    );
-  }
-}
+import {RunnerType} from "../utils/types.js";
 
 specTestIterator(path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET), {
-  fork_choice: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: false})},
-  sync: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: true})},
-  fork_choice_compliance: {type: RunnerType.default, fn: forkChoiceTest({onlyPredefinedResponses: false})},
+  fork_choice: {type: RunnerType.default, fn: forkChoiceTestRunner({onlyPredefinedResponses: false})},
+  sync: {type: RunnerType.default, fn: forkChoiceTestRunner({onlyPredefinedResponses: true})},
 });
diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
new file mode 100644
index 000000000000..a4c5a4e6cf65
--- /dev/null
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -0,0 +1,1061 @@
+import {generateKeyPair} from "@libp2p/crypto/keys";
+import {expect} from "vitest";
+import {toHexString} from "@chainsafe/ssz";
+import {createBeaconConfig} from "@lodestar/config";
+import {getConfig} from "@lodestar/config/test-utils";
+import {CheckpointWithHex, ExecutionStatus, ForkChoice, getCommitteeFraction} from "@lodestar/fork-choice";
+import {testLogger} from "@lodestar/logger/test-utils";
+import {
+  EFFECTIVE_BALANCE_INCREMENT,
+  ForkPostDeneb,
+  ForkPostFulu,
+  ForkPostGloas,
+  ForkPreDeneb,
+  ForkPreFulu,
+  ForkPreGloas,
+  ForkSeq,
+  SLOTS_PER_EPOCH,
+} from "@lodestar/params";
+import {InputType} from "@lodestar/spec-test-util";
+import {
+  BeaconStateAllForks,
+  BeaconStateView,
+  DataAvailabilityStatus,
+  IBeaconStateViewGloas,
+  computeEpochAtSlot,
+  createCachedBeaconState,
+  createPubkeyCache,
+  createSingleSignatureSetFromComponents,
+  getIndexedAttestation,
+  getPayloadAttestationDataSigningRoot,
+  isExecutionStateType,
+  isGloasStateType,
+  signedBlockToSignedHeader,
+  syncPubkeys,
+} from "@lodestar/state-transition";
+import {
+  Attestation,
+  AttesterSlashing,
+  BeaconBlock,
+  RootHex,
+  SignedBeaconBlock,
+  deneb,
+  fulu,
+  gloas,
+  ssz,
+  sszTypesFor,
+} from "@lodestar/types";
+import {PayloadAttestationMessage} from "@lodestar/types/gloas";
+import {bnToNum, fromHex, toHex, toRootHex} from "@lodestar/utils";
+import {
+  BlockInputBlobs,
+  BlockInputColumns,
+  BlockInputNoData,
+  BlockInputPreData,
+  BlockInputSource,
+} from "../../../src/chain/blocks/blockInput/index.js";
+import {AttestationImportOpt, BlobSidecarValidation} from "../../../src/chain/blocks/types.js";
+import {
+  verifyExecutionPayloadEnvelope,
+  verifyExecutionPayloadEnvelopeSignature,
+} from "../../../src/chain/blocks/verifyExecutionPayloadEnvelope.js";
+import {BlockError, BlockErrorCode} from "../../../src/chain/errors/blockError.js";
+import {BeaconChain, ChainEvent} from "../../../src/chain/index.js";
+import {defaultChainOptions} from "../../../src/chain/options.js";
+import {RegenCaller} from "../../../src/chain/regen/index.js";
+import {getShufflingForAttestationVerification} from "../../../src/chain/validation/attestation.js";
+import {validateFuluBlockDataColumnSidecars} from "../../../src/chain/validation/dataColumnSidecar.js";
+import {ZERO_HASH_HEX} from "../../../src/constants/constants.js";
+import {ExecutionPayloadStatus} from "../../../src/execution/engine/interface.js";
+import {ExecutionEngineMockBackend} from "../../../src/execution/engine/mock.js";
+import {getExecutionEngineFromBackend} from "../../../src/execution/index.js";
+import {computePreFuluKzgCommitmentsInclusionProof} from "../../../src/util/blobs.js";
+import {ClockEvent} from "../../../src/util/clock.js";
+import {ClockStopped} from "../../mocks/clock.js";
+import {getMockedBeaconDb} from "../../mocks/mockedBeaconDb.js";
+import {assertCorrectProgressiveBalances} from "../config.js";
+import {TestRunnerFn} from "./types.js";
+
+const ANCHOR_STATE_FILE_NAME = "anchor_state";
+const ANCHOR_BLOCK_FILE_NAME = "anchor_block";
+const BLOCK_FILE_NAME = "^(block)_([0-9a-zA-Z]+)$";
+const BLOBS_FILE_NAME = "^(blobs)_([0-9a-zA-Z]+)$";
+const COLUMN_FILE_NAME = "^(column)_([0-9a-zA-Z]+)$";
+const EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME = "^(execution_payload_envelope)_([0-9a-zA-Z]+)$";
+const ATTESTATION_FILE_NAME = "^(attestation)_([0-9a-zA-Z])+$";
+const ATTESTER_SLASHING_FILE_NAME = "^(attester_slashing)_([0-9a-zA-Z])+$";
+const PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME = "^(payload_attestation_message)_([0-9a-zA-Z])+$";
+
+const logger = testLogger("spec-test");
+
+export const forkChoiceTestRunner =
+  (opts: {onlyPredefinedResponses: boolean}): TestRunnerFn<ForkChoiceTestCase, void> =>
+  (fork) => {
+    return {
+      testFunction: async (testcase, _directoryName, testCaseName) => {
+        const {steps, anchorState} = testcase;
+        const currentSlot = anchorState.slot;
+        const config = getConfig(fork);
+        // const state = createCachedBeaconStateTest(anchorState, config);
+
+        /** This is to track test's tickTime to be used in proposer boost */
+        let tickTime = 0;
+        const clock = new ClockStopped(currentSlot);
+        const executionEngineBackend = new ExecutionEngineMockBackend({
+          onlyPredefinedResponses: opts.onlyPredefinedResponses,
+          genesisBlockHash: isGloasStateType(anchorState)
+            ? toHexString(anchorState.latestBlockHash)
+            : isExecutionStateType(anchorState)
+              ? toHexString(anchorState.latestExecutionPayloadHeader.blockHash)
+              : ZERO_HASH_HEX,
+        });
+
+        const controller = new AbortController();
+        const executionEngine = getExecutionEngineFromBackend(executionEngineBackend, {
+          signal: controller.signal,
+          logger: testLogger("executionEngine"),
+        });
+
+        const beaconConfig = createBeaconConfig(config, anchorState.genesisValidatorsRoot);
+        const pubkeyCache = createPubkeyCache();
+        syncPubkeys(pubkeyCache, anchorState.validators.getAllReadonlyValues());
+        const cachedState = createCachedBeaconState(
+          anchorState,
+          {
+            config: beaconConfig,
+            pubkeyCache,
+          },
+          {skipSyncPubkeys: true}
+        );
+
+        const chain = new BeaconChain(
+          {
+            ...defaultChainOptions,
+            // Do not start workers
+            blsVerifyAllMainThread: true,
+            // Do not run any archiver tasks
+            disableArchiveOnCheckpoint: true,
+            // Since the tests have deep-reorgs attested data is not available often printing lots of error logs.
+            // While this function is only called for head blocks, best to disable.
+            disableLightClientServerOnImportBlockHead: true,
+            // No need to log BlockErrors, the spec test runner will only log them if not not expected
+            // Otherwise spec tests logs get cluttered with expected errors
+            disableOnBlockError: true,
+            // PrepareNextSlot scheduler is used to precompute epoch transition and prepare for the next payload
+            // we don't use these in fork choice spec tests
+            disablePrepareNextSlot: true,
+            assertCorrectProgressiveBalances,
+            proposerBoost: true,
+            proposerBoostReorg: true,
+          },
+          {
+            privateKey: await generateKeyPair("secp256k1"),
+            config: beaconConfig,
+            pubkeyCache,
+            db: getMockedBeaconDb(),
+            dataDir: ".",
+            dbName: ",",
+            logger,
+            processShutdownCallback: () => {},
+            clock,
+            metrics: null,
+            validatorMonitor: null,
+            anchorState: new BeaconStateView(cachedState),
+            isAnchorStateFinalized: true,
+            executionEngine,
+            executionBuilder: undefined,
+          }
+        );
+
+        // The handler of `ChainEvent.forkChoiceFinalized` access `db.block` and raise error if not found.
+        chain.emitter.removeAllListeners(ChainEvent.forkChoiceFinalized);
+
+        const stepsLen = steps.length;
+        logger.debug("Fork choice test", {steps: stepsLen});
+
+        try {
+          for (const [i, step] of steps.entries()) {
+            if (isTick(step)) {
+              tickTime = bnToNum(step.tick);
+              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
+              logger.debug(`Step ${i}/${stepsLen} tick`, {currentSlot, valid: Boolean(step.valid), time: tickTime});
+              clock.emit(ClockEvent.slot, currentSlot);
+              clock.setSlot(currentSlot);
+            }
+
+            // attestation step
+            else if (isAttestation(step)) {
+              const isValid = Boolean(step.valid ?? true);
+              logger.debug(`Step ${i}/${stepsLen} attestation`, {root: step.attestation, valid: isValid});
+              const attestation = testcase.attestations.get(step.attestation);
+              if (!attestation) throw Error(`No attestation ${step.attestation}`);
+              const attDataRootHex = toHexString(sszTypesFor(fork).AttestationData.hashTreeRoot(attestation.data));
+
+              // Spec `validate_on_attestation` requires `get_current_slot(store) >= attestation.data.slot + 1`
+              // (an attestation may only influence fork choice from the slot AFTER it was created). Lodestar
+              // enforces this 1-slot delay in the gossip/attestation-pool layer, not in `forkChoice.onAttestation`,
+              // so replicate the precondition here since the runner calls `onAttestation` directly.
+              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
+              if (currentSlot < attestation.data.slot + 1) {
+                if (isValid) {
+                  throw Error(`Attestation not yet 1 slot old but marked valid at step ${i}`);
+                }
+                logger.debug(
+                  `Step ${i}/${stepsLen} skip attestation: not yet 1 slot old (spec on_attestation rejects)`,
+                  {
+                    attSlot: attestation.data.slot,
+                    currentSlot,
+                  }
+                );
+                continue;
+              }
+
+              // `on_attestation` decodes aggregation_bits with the shuffling at the attestation's
+              // target checkpoint, not the head state — resolve it via ShufflingCache + regen so
+              // cross-epoch fork attestations (surfaced by the compliance suite) decode correctly.
+              // The resolution runs inside the try so that errors on `valid: false` steps (e.g.
+              // attesting to a future block) count as the expected rejection.
+              const attHeadBlock = chain.forkChoice.getBlockHexDefaultStatus(toHex(attestation.data.beaconBlockRoot));
+              if (attHeadBlock === null && isValid) {
+                throw Error(`Attestation beacon block root unknown to fork choice at step ${i}`);
+              }
+              try {
+                if (attHeadBlock === null) throw Error("Unknown attestation head block (expected rejection)");
+                const shuffling = await getShufflingForAttestationVerification(
+                  chain,
+                  computeEpochAtSlot(attestation.data.slot),
+                  attHeadBlock,
+                  RegenCaller.validateGossipAttestation
+                );
+                const indexedAttestation = getIndexedAttestation(shuffling, ForkSeq[fork], attestation);
+                chain.forkChoice.onAttestation(indexedAttestation, attDataRootHex);
+                if (!isValid) throw Error("Expect error since this is a negative test");
+              } catch (e) {
+                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
+              }
+            }
+
+            // attester slashing step
+            else if (isAttesterSlashing(step)) {
+              logger.debug(`Step ${i}/${stepsLen} attester slashing`, {
+                root: step.attester_slashing,
+                valid: Boolean(step.valid),
+              });
+              const attesterSlashing = testcase.attesterSlashings.get(step.attester_slashing);
+              if (!attesterSlashing) throw Error(`No attester slashing ${step.attester_slashing}`);
+              chain.forkChoice.onAttesterSlashing(attesterSlashing);
+            }
+
+            // payload attestation message step
+            else if (isPayloadAttestationMessage(step)) {
+              const isValid = Boolean(step.valid ?? true);
+              logger.debug(`Step ${i}/${stepsLen} payload attestation message`, {
+                root: step.payload_attestation_message,
+                valid: isValid,
+              });
+              const payloadAttestationMessage = testcase.payloadAttestationMessages.get(
+                step.payload_attestation_message
+              );
+              if (!payloadAttestationMessage)
+                throw Error(`No payload attestation message ${step.payload_attestation_message}`);
+              try {
+                const blockRoot = toRootHex(payloadAttestationMessage.data.beaconBlockRoot);
+                const protoBlock = chain.forkChoice.getBlockHexDefaultStatus(blockRoot);
+                if (!protoBlock) {
+                  throw Error(`Block not found for root ${blockRoot}`);
+                }
+
+                // Spec `on_payload_attestation_message` asserts the attested block is from the
+                // message's slot — a mismatch is a rejection, not a silent no-op.
+                if (protoBlock.slot !== payloadAttestationMessage.data.slot) {
+                  throw Error(
+                    `Block slot ${protoBlock.slot} does not match payload attestation slot ${payloadAttestationMessage.data.slot}`
+                  );
+                }
+                {
+                  const blockState = await chain.regen.getBlockSlotState(
+                    protoBlock,
+                    payloadAttestationMessage.data.slot,
+                    {dontTransferCache: true},
+                    RegenCaller.processBlock
+                  );
+
+                  const ptcIndices = (blockState as IBeaconStateViewGloas).getIndicesInPayloadTimelinessCommittee(
+                    payloadAttestationMessage.validatorIndex,
+                    payloadAttestationMessage.data.slot
+                  );
+
+                  // Spec asserts the validator is a PTC member for the slot
+                  if (ptcIndices.length === 0) {
+                    throw Error(
+                      `Validator ${payloadAttestationMessage.validatorIndex} not in PTC for slot ${payloadAttestationMessage.data.slot}`
+                    );
+                  }
+
+                  // Slot check, matching the `validateGossipPayloadAttestationMessage` flow
+                  if (clock.currentSlot !== payloadAttestationMessage.data.slot) {
+                    throw Error(
+                      `Message slot ${payloadAttestationMessage.data.slot} is not current slot ${clock.currentSlot}`
+                    );
+                  }
+
+                  // Signature verification (matching `validateGossipPayloadAttestationMessage`) — skipped for
+                  // bls_setting !== 1: compliance fixtures use placeholder signatures (bls_setting: 2), so the
+                  // spec reference runner does not verify. Mirror the block-import accommodation (`validSignatures`).
+                  if (testcase.meta?.bls_setting === BigInt(1)) {
+                    const validatorPubkey = pubkeyCache.get(payloadAttestationMessage.validatorIndex);
+                    if (!validatorPubkey) {
+                      throw Error(`Unknown validator index ${payloadAttestationMessage.validatorIndex}`);
+                    }
+                    const signatureSet = createSingleSignatureSetFromComponents(
+                      validatorPubkey,
+                      getPayloadAttestationDataSigningRoot(beaconConfig, payloadAttestationMessage.data),
+                      payloadAttestationMessage.signature
+                    );
+                    let signatureValidity: boolean;
+                    try {
+                      signatureValidity = await chain.bls.verifySignatureSets([signatureSet], {
+                        verifyOnMainThread: true,
+                        batchable: true,
+                        priority: true,
+                      });
+                    } catch {
+                      signatureValidity = false;
+                    }
+                    if (!signatureValidity) throw Error("Invalid payload attestation signature");
+                  }
+
+                  chain.forkChoice.notifyPtcMessages(
+                    blockRoot,
+                    payloadAttestationMessage.data.slot,
+                    ptcIndices,
+                    payloadAttestationMessage.data.payloadPresent,
+                    payloadAttestationMessage.data.blobDataAvailable
+                  );
+                }
+                if (!isValid) throw Error("Expect error since this is a negative test");
+              } catch (e) {
+                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
+              }
+            }
+
+            // block step
+            else if (isBlock(step)) {
+              const isValid = Boolean(step.valid ?? true);
+              const signedBlock = testcase.blocks.get(step.block);
+              if (!signedBlock) {
+                throw Error(`No block ${step.block}`);
+              }
+
+              // Post-Deneb and pre-Fulu, `columns` should not be present. Post-Fulu `blobs` and
+              // `proofs` should not be present.
+              let blobs: deneb.Blob[] | undefined;
+              let proofs: deneb.KZGProof[] | undefined;
+              let columns: fulu.DataColumnSidecar[] | undefined;
+              if (step.blobs !== undefined) {
+                blobs = testcase.blobs.get(step.blobs);
+              }
+              if (step.proofs !== undefined) {
+                proofs = step.proofs.map((proof) => ssz.deneb.KZGProof.deserialize(fromHex(proof)));
+              }
+              if (step.columns !== undefined) {
+                columns = [];
+                for (const columnName of step.columns) {
+                  const column = testcase.columns.get(columnName);
+                  if (column === undefined) {
+                    throw Error(`Malformed spec test. Column file with name ${columnName} not found.`);
+                  }
+                  columns.push(column);
+                }
+              }
+
+              const {slot} = signedBlock.message;
+              // Log the BeaconBlock root instead of the SignedBeaconBlock root, forkchoice references BeaconBlock roots
+              const blockRoot = config
+                .getForkTypes(signedBlock.message.slot)
+                .BeaconBlock.hashTreeRoot(signedBlock.message);
+              const blockRootHex = toHex(blockRoot);
+              logger.debug(`Step ${i}/${stepsLen} block`, {
+                slot,
+                id: step.block,
+                root: toHexString(blockRoot),
+                parentRoot: toHexString(signedBlock.message.parentRoot),
+                isValid,
+              });
+
+              try {
+                let blockImport;
+                const forkSeq = config.getForkSeq(slot);
+
+                if (forkSeq >= ForkSeq.gloas) {
+                  // Gloas (ePBS) blocks don't carry blobs/columns directly on the block body.
+                  // Blob KZG commitments are nested inside signedExecutionPayloadBid.
+                  // Use BlockInputNoData since DA is handled separately via execution payload envelopes.
+                  blockImport = BlockInputNoData.createFromBlock({
+                    forkName: fork,
+                    block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
+                    blockRootHex,
+                    source: BlockInputSource.gossip,
+                    seenTimestampSec: 0,
+                    daOutOfRange: false,
+                  });
+                  // importBlock requires a PayloadEnvelopeInput to exist for gloas blocks; in
+                  // production this is seeded by gossip / by-root / by-range / API producers.
+                  // Spec tests bypass those, so seed it here to mirror the gossip-handler path.
+                  chain.seenPayloadEnvelopeInputCache.add({
+                    blockRootHex,
+                    block: signedBlock as SignedBeaconBlock<ForkPostGloas>,
+                    forkName: fork,
+                    sampledColumns: chain.custodyConfig.sampledColumns,
+                    custodyColumns: chain.custodyConfig.custodyColumns,
+                    timeCreatedSec: Date.now() / 1000,
+                  });
+                } else if (forkSeq >= ForkSeq.fulu) {
+                  if (columns === undefined) {
+                    columns = [];
+                  }
+
+                  await validateFuluBlockDataColumnSidecars(
+                    chain,
+                    slot,
+                    blockRoot,
+                    (signedBlock as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>).message.body.blobKzgCommitments
+                      .length,
+                    columns,
+                    chain.metrics?.peerDas
+                  );
+
+                  blockImport = BlockInputColumns.createFromBlock({
+                    forkName: fork,
+                    block: signedBlock as SignedBeaconBlock<ForkPostFulu & ForkPreGloas>,
+                    blockRootHex,
+                    custodyColumns:
+                      // in most test case instances we do not want to assign any custody as there are no columns provided
+                      // with the test case.  For on_block_peerdas__not_available the exact situation that is being tested
+                      // is no availability so block processing should fail.  For this one test case add some default
+                      // custody so that the await will fail in verifyBlocksDataAvailability.ts
+                      testCaseName !== "on_block_peerdas__not_available" ? columns.map((c) => c.index) : [2, 4, 6, 8],
+                    sampledColumns:
+                      testCaseName !== "on_block_peerdas__not_available"
+                        ? columns.map((c) => c.index)
+                        : [2, 4, 6, 8, 10, 12, 14, 16],
+                    source: BlockInputSource.gossip,
+                    seenTimestampSec: 0,
+                    daOutOfRange: false,
+                  });
+                  for (const column of columns) {
+                    blockImport.addColumn({
+                      blockRootHex,
+                      columnSidecar: column,
+                      source: BlockInputSource.gossip,
+                      seenTimestampSec: 0,
+                    });
+                  }
+                  // getBlockInput.availableData(config, signedBlock, BlockSource.gossip, blockData);
+                } else if (forkSeq >= ForkSeq.deneb && forkSeq < ForkSeq.fulu) {
+                  if (blobs === undefined) {
+                    // seems like some deneb tests don't have this and we are supposed to assume empty
+                    // throw Error("Missing blobs for the deneb+ block");
+                    blobs = [];
+                  }
+                  if (proofs === undefined) {
+                    // seems like some deneb tests don't have this and we are supposed to assume empty
+                    // throw Error("proofs for the deneb+ block");
+                    proofs = [];
+                  }
+                  // the kzg lib for validation of minimal setup is not yet integrated, lets just verify lengths
+                  // post integration use validateBlobsAndProofs
+                  const commitments = (signedBlock as deneb.SignedBeaconBlock).message.body.blobKzgCommitments;
+                  if (blobs.length !== commitments.length || proofs.length !== commitments.length) {
+                    throw Error("Invalid blobs or proofs lengths");
+                  }
+
+                  const blobSidecars: deneb.BlobSidecars = blobs.map((blob, index) => {
+                    return {
+                      index,
+                      blob,
+                      kzgCommitment: commitments[index],
+                      kzgProof: (proofs ?? [])[index],
+                      signedBlockHeader: signedBlockToSignedHeader(config, signedBlock),
+                      kzgCommitmentInclusionProof: computePreFuluKzgCommitmentsInclusionProof(
+                        fork,
+                        signedBlock.message.body,
+                        index
+                      ),
+                    };
+                  });
+
+                  blockImport = BlockInputBlobs.createFromBlock({
+                    forkName: fork,
+                    block: signedBlock as SignedBeaconBlock<ForkPostDeneb & ForkPreFulu>,
+                    blockRootHex,
+                    source: BlockInputSource.gossip,
+                    seenTimestampSec: 0,
+                    daOutOfRange: false,
+                  });
+                  for (const blob of blobSidecars) {
+                    blockImport.addBlob({
+                      blockRootHex,
+                      blobSidecar: blob,
+                      source: BlockInputSource.gossip,
+                      seenTimestampSec: 0,
+                    });
+                  }
+                } else {
+                  blockImport = BlockInputPreData.createFromBlock({
+                    forkName: fork,
+                    block: signedBlock as SignedBeaconBlock<ForkPreDeneb>,
+                    blockRootHex,
+                    source: BlockInputSource.gossip,
+                    seenTimestampSec: 0,
+                    daOutOfRange: false,
+                  });
+                }
+
+                await chain.processBlock(blockImport, {
+                  seenTimestampSec: tickTime,
+                  validBlobSidecars: BlobSidecarValidation.Full,
+                  importAttestations: AttestationImportOpt.Force,
+                  validSignatures: testcase.meta?.bls_setting !== BigInt(1),
+                });
+                if (!isValid) throw Error("Expect error since this is a negative test");
+              } catch (e) {
+                // Spec `on_block` is a no-op success on a known block; lodestar's production
+                // import path rejects with ALREADY_KNOWN. Treat as success in the spec runner.
+                if (isValid && e instanceof BlockError && e.type.code === BlockErrorCode.ALREADY_KNOWN) {
+                  logger.debug(`Step ${i}/${stepsLen} block already known — treating as no-op success`, {
+                    id: step.block,
+                  });
+                } else if (isValid || (e as Error).message === "Expect error since this is a negative test") {
+                  throw e;
+                }
+              }
+            }
+
+            // execution_payload step for Gloas (ePBS) tests
+            else if (isExecutionPayload(step)) {
+              const isValid = Boolean(step.valid ?? true);
+              logger.debug(`Step ${i}/${stepsLen} execution_payload`, {
+                envelope: step.execution_payload,
+                valid: isValid,
+              });
+              const envelope = testcase.executionPayloadEnvelopes.get(step.execution_payload);
+              if (!envelope) throw Error(`No execution payload envelope ${step.execution_payload}`);
+
+              try {
+                const beaconBlockRoot = toHex(envelope.message.beaconBlockRoot);
+                const blockHash = toHex(envelope.message.payload.blockHash);
+                const blockNumber = envelope.message.payload.blockNumber;
+                const gasLimit = envelope.message.payload.gasLimit;
+
+                // Verify envelope against the state
+                const protoBlock = chain.forkChoice.getBlockHexDefaultStatus(beaconBlockRoot);
+                if (!protoBlock) throw Error(`Block not found for root ${beaconBlockRoot}`);
+                const blockState = await chain.regen.getBlockSlotState(
+                  protoBlock,
+                  protoBlock.slot,
+                  {dontTransferCache: true},
+                  RegenCaller.processBlock
+                );
+                verifyExecutionPayloadEnvelope(beaconConfig, blockState as IBeaconStateViewGloas, envelope.message);
+
+                // Verify signature — skipped for bls_setting !== 1: compliance fixtures use placeholder
+                // signatures (bls_setting: 2), so the spec reference runner does not verify. Mirror the
+                // block-import accommodation (`validSignatures` above).
+                if (testcase.meta?.bls_setting === BigInt(1)) {
+                  const sigValid = await verifyExecutionPayloadEnvelopeSignature(
+                    beaconConfig,
+                    blockState as IBeaconStateViewGloas,
+                    pubkeyCache,
+                    envelope,
+                    blockState.latestBlockHeader.proposerIndex,
+                    chain.bls
+                  );
+                  if (!sigValid) throw Error("Invalid execution payload envelope signature");
+                }
+
+                // Add predefined VALID status for the payload's block hash so the EL mock accepts it
+                executionEngineBackend.addPredefinedPayloadStatus(blockHash, {
+                  status: ExecutionPayloadStatus.VALID,
+                  latestValidHash: null,
+                  validationError: null,
+                });
+
+                (chain.forkChoice as ForkChoice).onExecutionPayload(
+                  beaconBlockRoot,
+                  blockHash,
+                  blockNumber,
+                  gasLimit,
+                  ExecutionStatus.Valid,
+                  DataAvailabilityStatus.Available
+                );
+                if (!isValid) throw Error("Expect error since this is a negative test");
+              } catch (e) {
+                if (isValid || (e as Error).message === "Expect error since this is a negative test") throw e;
+              }
+            }
+
+            // Optional step for optimistic sync tests.
+            else if (isOnPayloadInfoStep(step)) {
+              logger.debug(`Step ${i}/${stepsLen} payload_status`, {blockHash: step.block_hash});
+              const status = ExecutionPayloadStatus[step.payload_status.status];
+              if (status === undefined) {
+                throw Error(`Unknown payload_status.status: ${step.payload_status.status}`);
+              }
+              executionEngineBackend.addPredefinedPayloadStatus(step.block_hash, {
+                status,
+                latestValidHash: step.payload_status.latest_valid_hash,
+                validationError: step.payload_status.validation_error,
+              });
+            }
+
+            // checks step
+            else if (isCheck(step)) {
+              logger.debug(`Step ${i}/${stepsLen} check`);
+
+              // Forkchoice head is computed lazily only on request
+              const head = (chain.forkChoice as ForkChoice).updateHead();
+              const proposerBootRoot = (chain.forkChoice as ForkChoice).getProposerBoostRoot();
+              // Spec: EMPTY=0, FULL=1, PENDING=2; Ours: PENDING=0, EMPTY=1, FULL=2
+              const payloadStatusToSpec: Record<number, number> = {0: 2, 1: 0, 2: 1};
+
+              if (step.checks.head !== undefined) {
+                expect({slot: head.slot, root: head.blockRoot}).toEqualWithMessage(
+                  {slot: bnToNum(step.checks.head.slot), root: step.checks.head.root},
+                  `Invalid head at step ${i}`
+                );
+                // Gloas and later: payload_status is nested inside the head check
+                if (step.checks.head.payload_status !== undefined) {
+                  expect(payloadStatusToSpec[head.payloadStatus]).toEqualWithMessage(
+                    bnToNum(step.checks.head.payload_status),
+                    `Invalid head payload status at step ${i}`
+                  );
+                }
+              }
+              if (step.checks.proposer_boost_root !== undefined) {
+                expect(proposerBootRoot).toEqualWithMessage(
+                  step.checks.proposer_boost_root,
+                  `Invalid proposer boost root at step ${i}`
+                );
+              }
+              // time in spec mapped to Slot in our forkchoice implementation.
+              // Compare in slots because proposer boost steps doesn't always come on
+              // slot boundary.
+              if (step.checks.time !== undefined && step.checks.time > 0)
+                expect(chain.forkChoice.getTime()).toEqualWithMessage(
+                  Math.floor(bnToNum(step.checks.time) / (config.SLOT_DURATION_MS / 1000)),
+                  `Invalid forkchoice time at step ${i}`
+                );
+              if (step.checks.justified_checkpoint) {
+                expect(toSpecTestCheckpoint(chain.forkChoice.getJustifiedCheckpoint())).toEqualWithMessage(
+                  step.checks.justified_checkpoint,
+                  `Invalid justified checkpoint at step ${i}`
+                );
+              }
+              if (step.checks.finalized_checkpoint) {
+                expect(toSpecTestCheckpoint(chain.forkChoice.getFinalizedCheckpoint())).toEqualWithMessage(
+                  step.checks.finalized_checkpoint,
+                  `Invalid finalized checkpoint at step ${i}`
+                );
+              }
+              if (step.checks.get_proposer_head) {
+                const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
+                const {proposerHead, notReorgedReason} = (chain.forkChoice as ForkChoice).getProposerHead(
+                  head,
+                  tickTime % (config.SLOT_DURATION_MS / 1000),
+                  currentSlot
+                );
+                logger.debug(`Not reorged reason ${notReorgedReason} at step ${i}`);
+                expect(proposerHead.blockRoot).toEqualWithMessage(
+                  step.checks.get_proposer_head,
+                  `Invalid proposer head at step ${i}`
+                );
+              }
+              if (step.checks.viable_for_head_roots_and_weights !== undefined) {
+                // Entries are identified by (root, payload_status, weight) per
+                // https://github.com/ethereum/consensus-specs/pull/5393 — gloas EMPTY/FULL
+                // variants of one block root are separate entries. Pre-gloas vectors omit
+                // payload_status (every pre-gloas node is FULL internally).
+                const isGloas = ForkSeq[fork] >= ForkSeq.gloas;
+                const expected = step.checks.viable_for_head_roots_and_weights
+                  .map((entry) => ({
+                    root: entry.root,
+                    payloadStatus: entry.payload_status !== undefined ? bnToNum(entry.payload_status) : undefined,
+                    weightGwei: entry.weight,
+                  }))
+                  .sort(cmpViableHead);
+                const actual = (chain.forkChoice as ForkChoice)
+                  .getViableHeads()
+                  .map(({root, payloadStatus, weight}) => ({
+                    root,
+                    payloadStatus: isGloas ? payloadStatusToSpec[payloadStatus] : undefined,
+                    weightGwei: BigInt(weight) * BigInt(EFFECTIVE_BALANCE_INCREMENT),
+                  }))
+                  .sort(cmpViableHead);
+
+                // The set of viable heads is determined by justified/finalized epochs, not weight,
+                // so identity must match exactly. Comparing the full sets (not a subset) also
+                // rejects a degenerate empty result.
+                expect(actual.map(({root, payloadStatus}) => ({root, payloadStatus}))).toEqualWithMessage(
+                  expected.map(({root, payloadStatus}) => ({root, payloadStatus})),
+                  `Invalid viable head roots at step ${i}`
+                );
+
+                // Exact weight comparison with boost emulation. Lodestar tracks weights in
+                // EFFECTIVE_BALANCE_INCREMENT units: attestation weight is exact (effective
+                // balances are increment multiples) but the proposer-boost score is double-floored
+                // to whole ETH (getCommitteeFraction) while the spec keeps Gwei precision — a
+                // known production divergence, bounded by
+                // (100 - gcd(PROPOSER_SCORE_BOOST, 100) + PROPOSER_SCORE_BOOST) / 100 = 1.2 ETH.
+                // Rather than compare within a tolerance (which would mask sub-1.2-ETH weight
+                // bugs), normalize the expected weight of the boosted entry by
+                // `- spec_boost + lodestar_boost` and compare exactly.
+                //
+                // Ordering rules (so normalization cannot mask a wrong boost root):
+                // - `checks.proposer_boost_root` was already asserted above, unadjusted.
+                // - Normalize using the VECTOR's expected boost root, never our actual one.
+                // - Zero boost root or absent field => no adjustment.
+                const expectedBoostRoot = step.checks.proposer_boost_root;
+                let specBoostGwei = BigInt(0);
+                let lodestarBoostGwei = BigInt(0);
+                if (expectedBoostRoot !== undefined && expectedBoostRoot !== ZERO_HASH_HEX) {
+                  const totalBalanceByIncrement = (
+                    chain.forkChoice as ForkChoice
+                  ).getJustifiedTotalActiveBalanceByIncrement();
+                  const totalBalanceGwei = BigInt(totalBalanceByIncrement) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+                  // Spec: ((total_active_balance // SLOTS_PER_EPOCH) * PROPOSER_SCORE_BOOST) // 100, in Gwei
+                  specBoostGwei =
+                    ((totalBalanceGwei / BigInt(SLOTS_PER_EPOCH)) * BigInt(config.PROPOSER_SCORE_BOOST)) / BigInt(100);
+                  // Lodestar: same formula double-floored in increment units — use the production
+                  // function directly so the emulation cannot drift from the implementation.
+                  lodestarBoostGwei =
+                    BigInt(
+                      getCommitteeFraction(totalBalanceByIncrement, {
+                        slotsPerEpoch: SLOTS_PER_EPOCH,
+                        committeePercent: config.PROPOSER_SCORE_BOOST,
+                      })
+                    ) * BigInt(EFFECTIVE_BALANCE_INCREMENT);
+                }
+                for (const [k, act] of actual.entries()) {
+                  const exp = expected[k];
+                  // TODO GLOAS: boost attribution across payload-status variants of the boosted
+                  // root is Phase 4 work; pre-gloas each root has exactly one entry.
+                  const isBoosted = exp.root === expectedBoostRoot;
+                  const expectedAdjusted = isBoosted
+                    ? exp.weightGwei - specBoostGwei + lodestarBoostGwei
+                    : exp.weightGwei;
+                  expect(act.weightGwei).toEqualWithMessage(
+                    expectedAdjusted,
+                    `Invalid viable head weight for ${act.root} at step ${i}` +
+                      (isBoosted ? ` (boost-normalized: spec=${specBoostGwei} lodestar=${lodestarBoostGwei})` : "")
+                  );
+                }
+              }
+              if (step.checks.should_override_forkchoice_update) {
+                const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
+                const result = chain.forkChoice.shouldOverrideForkChoiceUpdate(
+                  head,
+                  tickTime % (config.SLOT_DURATION_MS / 1000),
+                  currentSlot
+                );
+                if (result.shouldOverrideFcu === false) {
+                  logger.debug(`Not override fcu reason ${result.reason} at step ${i}`);
+                }
+                expect({result: result.shouldOverrideFcu, validator_is_connected: true}).toEqualWithMessage(
+                  step.checks.should_override_forkchoice_update,
+                  `Invalid should override fcu result at step ${i}`
+                );
+              }
+              if (step.checks.payload_timeliness_vote) {
+                expect(
+                  chain.forkChoice.getPayloadTimelinessVotes(step.checks.payload_timeliness_vote.block_root)
+                ).toEqualWithMessage(
+                  step.checks.payload_timeliness_vote.votes,
+                  `Invalid payload timeliness votes at step ${i}`
+                );
+              }
+              if (step.checks.payload_data_availability_vote) {
+                expect(
+                  chain.forkChoice.getPayloadDataAvailabilityVotes(
+                    step.checks.payload_data_availability_vote.block_root
+                  )
+                ).toEqualWithMessage(
+                  step.checks.payload_data_availability_vote.votes,
+                  `Invalid payload data availability votes at step ${i}`
+                );
+              }
+            }
+
+            // None of the above
+            else {
+              throw Error(`Unknown step ${i}/${stepsLen}: ${JSON.stringify(Object.keys(step))}`);
+            }
+          }
+        } finally {
+          await chain.close();
+        }
+      },
+
+      options: {
+        inputTypes: {
+          meta: InputType.YAML,
+          steps: InputType.YAML,
+        },
+        sszTypes: {
+          [ANCHOR_STATE_FILE_NAME]: ssz[fork].BeaconState,
+          [ANCHOR_BLOCK_FILE_NAME]: ssz[fork].BeaconBlock,
+          [BLOCK_FILE_NAME]: ssz[fork].SignedBeaconBlock,
+          [BLOBS_FILE_NAME]: ssz.deneb.Blobs,
+          [COLUMN_FILE_NAME]: ssz.fulu.DataColumnSidecar,
+          [EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME]: ssz.gloas.SignedExecutionPayloadEnvelope,
+          [ATTESTATION_FILE_NAME]: sszTypesFor(fork).Attestation,
+          [ATTESTER_SLASHING_FILE_NAME]: sszTypesFor(fork).AttesterSlashing,
+          [PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME]: ssz.gloas.PayloadAttestationMessage,
+        },
+        mapToTestCase: (t: Record<string, any>) => {
+          // t has input file name as key
+          const blocks = new Map<string, SignedBeaconBlock>();
+          const blobs = new Map<string, deneb.Blobs>();
+          const columns = new Map<string, fulu.DataColumnSidecar>();
+          const executionPayloadEnvelopes = new Map<string, gloas.SignedExecutionPayloadEnvelope>();
+          const attestations = new Map<string, Attestation>();
+          const attesterSlashings = new Map<string, AttesterSlashing>();
+          const payloadAttestationMessages = new Map<string, PayloadAttestationMessage>();
+          for (const key in t) {
+            if (!Object.prototype.hasOwnProperty.call(t, key)) continue;
+
+            const blockMatch = key.match(BLOCK_FILE_NAME);
+            if (blockMatch) {
+              blocks.set(key, t[key]);
+            }
+            const blobsMatch = key.match(BLOBS_FILE_NAME);
+            if (blobsMatch) {
+              blobs.set(key, t[key]);
+            }
+            const columnMatch = key.match(COLUMN_FILE_NAME);
+            if (columnMatch) {
+              columns.set(key, t[key]);
+            }
+            const envelopeMatch = key.match(EXECUTION_PAYLOAD_ENVELOPE_FILE_NAME);
+            if (envelopeMatch) {
+              executionPayloadEnvelopes.set(key, t[key]);
+            }
+            const attMatch = key.match(ATTESTATION_FILE_NAME);
+            if (attMatch) {
+              attestations.set(key, t[key]);
+            }
+            const attesterSlashingMatch = key.match(ATTESTER_SLASHING_FILE_NAME);
+            if (attesterSlashingMatch) {
+              attesterSlashings.set(key, t[key]);
+            }
+            const payloadAttestationMessageMatch = key.match(PAYLOAD_ATTESTATION_MESSAGE_FILE_NAME);
+            if (payloadAttestationMessageMatch) {
+              payloadAttestationMessages.set(key, t[key]);
+            }
+          }
+          return {
+            meta: t["meta"] as ForkChoiceTestCase["meta"],
+            anchorState: t[ANCHOR_STATE_FILE_NAME] as ForkChoiceTestCase["anchorState"],
+            anchorBlock: t[ANCHOR_BLOCK_FILE_NAME] as ForkChoiceTestCase["anchorBlock"],
+            steps: t["steps"] as ForkChoiceTestCase["steps"],
+            blocks,
+            blobs,
+            columns,
+            executionPayloadEnvelopes,
+            attestations,
+            attesterSlashings,
+            payloadAttestationMessages,
+          };
+        },
+        // timeout needs to be set longer than BLOB_AVAILABILITY_TIMEOUT so that on_block_peerdas__not_available fails
+        timeout: 15000,
+        expectFunc: () => {},
+        // Do not manually skip tests here, do it in packages/beacon-node/test/spec/presets/index.test.ts
+        // EXCEPTION : this test skipped here because prefix match can't be don't for this particular test
+        // as testId for the entire directory is same : `deneb/fork_choice/on_block/pyspec_tests` and
+        // we just want to skip this one particular test because we don't have minimal kzg lib integrated
+        //
+        // This skip can be removed once a kzg lib with run-time minimal blob size setup is released and
+        // integrated
+        shouldSkip: (_testcase, name, _index) =>
+          name.includes("invalid_incorrect_proof") ||
+          // TODO GLOAS: These tests will be unskipped by https://github.com/ChainSafe/lodestar/pull/9233
+          (name.includes("gloas") &&
+            (name.includes("simple_attempted_reorg_without_enough_ffg_votes") ||
+              name.includes("include_votes_another_empty_chain_with_enough_ffg_votes_current_epoch") ||
+              name.includes("include_votes_another_empty_chain_with_enough_ffg_votes_previous_epoch") ||
+              name.includes("include_votes_another_empty_chain_without_enough_ffg_votes_current_epoch"))),
+      },
+    };
+  };
+
+function toSpecTestCheckpoint(checkpoint: CheckpointWithHex): SpecTestCheckpoint {
+  return {
+    epoch: BigInt(checkpoint.epoch),
+    root: checkpoint.rootHex,
+  };
+}
+
+type Step =
+  | OnTick
+  | OnAttestation
+  | OnAttesterSlashing
+  | OnPayloadAttestationMessage
+  | OnBlock
+  | OnExecutionPayloadEnvelope
+  | OnPayloadInfo
+  | Checks;
+
+type SpecTestCheckpoint = {epoch: bigint; root: string};
+
+// This test executes steps in sequence. There may be multiple items of the following types:
+// on_tick execution step
+
+type OnTick = {
+  /** to execute `on_tick(store, time)` */
+  tick: bigint;
+  /** optional, default to `true`. */
+  valid?: number;
+};
+
+type OnAttestation = {
+  /** the name of the `attestation_<32-byte-root>.ssz_snappy` file. To execute `on_attestation(store, attestation)` */
+  attestation: string;
+  /** optional, default to `true`. */
+  valid?: number;
+};
+
+type OnAttesterSlashing = {
+  /**
+   * the name of the `attester_slashing_<32-byte-root>.ssz_snappy` file.
+   * To execute `on_attester_slashing(store, attester_slashing)` with the given attester slashing.
+   */
+  attester_slashing: string;
+  /** optional, default to `true` */
+  valid?: number;
+};
+
+type OnPayloadAttestationMessage = {
+  /**
+   * the name of the `payload_attestation_message_<32-byte-root>.ssz_snappy` file.
+   * To execute `on_payload_attestation_message(store, payload_attestation_message)`.
+   */
+  payload_attestation_message: string;
+  /** optional, default to `true` */
+  valid?: number;
+};
+
+type OnBlock = {
+  /** the name of the `block_<32-byte-root>.ssz_snappy` file. To execute `on_block(store, block)` */
+  block: string;
+  blobs?: string;
+  proofs?: string[];
+  columns?: string[];
+  /** optional, default to `true`. */
+  valid?: number;
+};
+
+type OnExecutionPayloadEnvelope = {
+  /** the name of the execution_payload_envelope file */
+  execution_payload: string;
+  /** optional, default to `true`. */
+  valid?: number;
+};
+
+type OnPayloadInfo = {
+  /** Encoded 32-byte value of payload's block hash. */
+  block_hash: string;
+  payload_status: {
+    status: "VALID" | "INVALID" | "SYNCING" | "ACCEPTED" | "INVALID_BLOCK_HASH";
+    /** Encoded 32-byte value of the latest valid block hash, may be `null`. */
+    latest_valid_hash: string;
+    /** Message providing additional details on the validation error, may be `null`. */
+    validation_error: string;
+  };
+};
+
+type Checks = {
+  /** Value in the ForkChoice store to verify it's correct after being mutated by another step */
+  checks: {
+    head?: {
+      slot: bigint;
+      root: string;
+      /** Gloas and later */
+      payload_status?: bigint;
+    };
+    time?: bigint;
+    justified_checkpoint?: SpecTestCheckpoint;
+    finalized_checkpoint?: SpecTestCheckpoint;
+    proposer_boost_root?: RootHex;
+    get_proposer_head?: string;
+    should_override_forkchoice_update?: {
+      validator_is_connected: boolean;
+      result: boolean;
+    };
+    /** Gloas: PTC timeliness votes per PTC position (`null` = member has not attested). */
+    payload_timeliness_vote?: {
+      block_root: RootHex;
+      votes: (boolean | null)[];
+    };
+    /** Gloas: PTC data-availability votes per PTC position (`null` = member has not attested). */
+    payload_data_availability_vote?: {
+      block_root: RootHex;
+      votes: (boolean | null)[];
+    };
+    viable_for_head_roots_and_weights?: {root: RootHex; weight: bigint; payload_status?: bigint}[];
+  };
+};
+
+/** Sort by (root, payload_status) — the spec fixes no order; gloas variants share a root. */
+function cmpViableHead(a: {root: string; payloadStatus?: number}, b: {root: string; payloadStatus?: number}): number {
+  return a.root.localeCompare(b.root) || (a.payloadStatus ?? 0) - (b.payloadStatus ?? 0);
+}
+
+type ForkChoiceTestCase = {
+  meta?: {
+    description?: string;
+    bls_setting: bigint;
+  };
+  anchorState: BeaconStateAllForks;
+  anchorBlock: BeaconBlock;
+  steps: Step[];
+  blocks: Map<string, SignedBeaconBlock>;
+  blobs: Map<string, deneb.Blobs>;
+  columns: Map<string, fulu.DataColumnSidecar>;
+  executionPayloadEnvelopes: Map<string, gloas.SignedExecutionPayloadEnvelope>;
+  attestations: Map<string, Attestation>;
+  attesterSlashings: Map<string, AttesterSlashing>;
+  payloadAttestationMessages: Map<string, PayloadAttestationMessage>;
+};
+
+function isTick(step: Step): step is OnTick {
+  return (step as OnTick).tick >= 0;
+}
+
+function isAttestation(step: Step): step is OnAttestation {
+  return typeof (step as OnAttestation).attestation === "string";
+}
+
+function isAttesterSlashing(step: Step): step is OnAttesterSlashing {
+  return typeof (step as OnAttesterSlashing).attester_slashing === "string";
+}
+
+function isPayloadAttestationMessage(step: Step): step is OnPayloadAttestationMessage {
+  return typeof (step as OnPayloadAttestationMessage).payload_attestation_message === "string";
+}
+
+function isBlock(step: Step): step is OnBlock {
+  return typeof (step as OnBlock).block === "string";
+}
+
+function isExecutionPayload(step: Step): step is OnExecutionPayloadEnvelope {
+  return typeof (step as OnExecutionPayloadEnvelope).execution_payload === "string";
+}
+
+function isOnPayloadInfoStep(step: Step): step is OnPayloadInfo {
+  return typeof (step as OnPayloadInfo).block_hash === "string";
+}
+
+function isCheck(step: Step): step is Checks {
+  return typeof (step as Checks).checks === "object";
+}
diff --git a/packages/beacon-node/test/spec/utils/specTestIterator.ts b/packages/beacon-node/test/spec/utils/specTestIterator.ts
index 60de88936236..3ff605e6231a 100644
--- a/packages/beacon-node/test/spec/utils/specTestIterator.ts
+++ b/packages/beacon-node/test/spec/utils/specTestIterator.ts
@@ -91,12 +91,7 @@ export const defaultSkipOpts: SkipOpts = {
     /\/gloas_fork$/,
   ],
   // TODO GLOAS: Investigate why networking tests are failing since alpha.5
-  skippedRunners: [
-    "networking",
-    // fork_choice_compliance is opt-in (`pnpm test:comptest`): ~1472 model-generated cases per
-    // fork — running them inside the regular spec suite would double-run and blow the budget.
-    ...(process.env.RUN_FORK_CHOICE_COMPLIANCE === "1" ? [] : ["fork_choice_compliance"]),
-  ],
+  skippedRunners: ["networking"],
 };
 
 /**
diff --git a/vitest.config.ts b/vitest.config.ts
index d312ab364bca..7e173b8ebcbd 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -2,7 +2,7 @@ import path from "node:path";
 import {TestUserConfig, defineConfig} from "vitest/config";
 import {browserTestProject} from "./configs/vitest.config.browser.js";
 import {e2eMainnetProject, e2eMinimalProject} from "./configs/vitest.config.e2e.js";
-import {specProjectMainnet, specProjectMinimal} from "./configs/vitest.config.spec.js";
+import {specProjectComptest, specProjectMainnet, specProjectMinimal} from "./configs/vitest.config.spec.js";
 import {typesTestProject} from "./configs/vitest.config.types.js";
 import {unitTestMainnetProject, unitTestMinimalProject} from "./configs/vitest.config.unit.js";
 import {esmCjsInteropPlugin} from "./scripts/vite/plugins/esmCjsInteropPlugin.js";
@@ -46,6 +46,10 @@ export default defineConfig({
         extends: true,
         ...specProjectMainnet,
       },
+      {
+        extends: true,
+        ...specProjectComptest,
+      },
       {
         extends: true,
         ...typesTestProject,

From 36823290c6d85fbfe847d7c8e3175903726e9699 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 13:03:24 -0700
Subject: [PATCH 13/23] test: skip compliance case hitting stale-head proposer
 boost bug

block_tree_test_16_201284350_1 fails identically on every pre-gloas fork:
the dependent-root gate compares against the cached head, which is stale
when the preceding tick crosses an epoch boundary and pulls up the
justified checkpoint. Tracked in #9666.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 packages/beacon-node/test/spec/utils/specTestIterator.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/beacon-node/test/spec/utils/specTestIterator.ts b/packages/beacon-node/test/spec/utils/specTestIterator.ts
index 3ff605e6231a..7fd89a4575d8 100644
--- a/packages/beacon-node/test/spec/utils/specTestIterator.ts
+++ b/packages/beacon-node/test/spec/utils/specTestIterator.ts
@@ -89,6 +89,10 @@ export const defaultSkipOpts: SkipOpts = {
   skippedTests: [
     // TODO-GLOAS: re-enable after gloas light client is implemented
     /\/gloas_fork$/,
+    // Proposer-boost dependent-root gate uses stale cached head across epoch-boundary ticks;
+    // boost wrongly denied. Fails identically on every pre-gloas fork.
+    // https://github.com/ChainSafe/lodestar/issues/9666
+    /fork_choice_compliance\/block_tree_test\/pyspec_tests\/block_tree_test_16_201284350_1$/,
   ],
   // TODO GLOAS: Investigate why networking tests are failing since alpha.5
   skippedRunners: ["networking"],

From 31bd1dbaa83e8ec7796ac23f6bb44b723b99833d Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 13:25:26 -0700
Subject: [PATCH 14/23] fix: payload-attestation slot mismatch is a no-op
 success per spec
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Spec on_payload_attestation_message returns early when the message slot
does not match the attested block's slot ('PTC votes can only change the
vote for their assigned beacon block, return early otherwise') — it is
not a rejection. Restore conditional processing; the PTC-membership
assert and the negative-test assertion remain.

https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.12/specs/gloas/fork-choice.md#on_payload_attestation_message

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../test/spec/utils/forkChoiceTestRunner.ts          | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
index a4c5a4e6cf65..5b5d098a5d0a 100644
--- a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -265,14 +265,10 @@ export const forkChoiceTestRunner =
                   throw Error(`Block not found for root ${blockRoot}`);
                 }
 
-                // Spec `on_payload_attestation_message` asserts the attested block is from the
-                // message's slot — a mismatch is a rejection, not a silent no-op.
-                if (protoBlock.slot !== payloadAttestationMessage.data.slot) {
-                  throw Error(
-                    `Block slot ${protoBlock.slot} does not match payload attestation slot ${payloadAttestationMessage.data.slot}`
-                  );
-                }
-                {
+                // "PTC votes can only change the vote for their assigned beacon block, return
+                // early otherwise" — a slot mismatch is a no-op SUCCESS, not a rejection.
+                // https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.12/specs/gloas/fork-choice.md#on_payload_attestation_message
+                if (protoBlock.slot === payloadAttestationMessage.data.slot) {
                   const blockState = await chain.regen.getBlockSlotState(
                     protoBlock,
                     payloadAttestationMessage.data.slot,

From 05908df31eca9f126fb8de967e9458a78b7a43f5 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 13:40:25 -0700
Subject: [PATCH 15/23] refactor: plain-text comptests version marker

comptests-version.txt, matching the standard downloader's version.txt
convention; a single version string needs no JSON.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../spec-test-util/src/downloadComptests.ts   | 15 +++++---------
 .../test/unit/downloadComptests.test.ts       | 20 ++++++-------------
 2 files changed, 11 insertions(+), 24 deletions(-)

diff --git a/packages/spec-test-util/src/downloadComptests.ts b/packages/spec-test-util/src/downloadComptests.ts
index 602500e5055f..14ce688666c0 100644
--- a/packages/spec-test-util/src/downloadComptests.ts
+++ b/packages/spec-test-util/src/downloadComptests.ts
@@ -19,7 +19,8 @@ export type DownloadComptestsOptions = {
   fetchInit?: RequestInit;
 };
 
-const MARKER_FILENAME = "comptests-version.json";
+// Same convention as the standard downloader's version.txt, scoped to the comptests asset
+const MARKER_FILENAME = "comptests-version.txt";
 const COMPTESTS_SUBDIR = "fork_choice_compliance";
 
 /**
@@ -32,7 +33,7 @@ const COMPTESTS_SUBDIR = "fork_choice_compliance";
  * - extracts into a temporary directory first,
  * - replaces only comptest-owned paths (`tests/<preset>/<fork>/fork_choice_compliance/`),
  * - never deletes the shared output directory,
- * - writes its own marker (`comptests-version.json`) only after a successful merge, so a failed
+ * - writes its own marker (`comptests-version.txt`) only after a successful merge, so a failed
  *   download/extraction leaves existing fixtures and marker untouched.
  *
  * Note: a standard-tests version change wipes the whole shared dir including these vectors
@@ -101,7 +102,7 @@ export async function downloadComptests(
     }
 
     // Marker written only after a fully successful merge
-    fs.writeFileSync(markerPath, JSON.stringify({specVersion}, null, 2));
+    fs.writeFileSync(markerPath, specVersion);
     log(`comptests ${specVersion} ready`);
   } finally {
     fs.rmSync(tmpDir, {recursive: true, force: true});
@@ -110,13 +111,7 @@ export async function downloadComptests(
 
 function readMarkerVersion(markerPath: string): string | null {
   if (!fs.existsSync(markerPath)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(markerPath, "utf8")) as {specVersion?: unknown};
-    return typeof parsed.specVersion === "string" ? parsed.specVersion : null;
-  } catch {
-    // Unparseable/legacy marker => treat as stale and redownload
-    return null;
-  }
+  return fs.readFileSync(markerPath, "utf8").trim();
 }
 
 /** Find all `tests/<preset>/<fork>/fork_choice_compliance` dirs under `root` */
diff --git a/packages/spec-test-util/test/unit/downloadComptests.test.ts b/packages/spec-test-util/test/unit/downloadComptests.test.ts
index 490e00fd03f8..fc8f48f371e5 100644
--- a/packages/spec-test-util/test/unit/downloadComptests.test.ts
+++ b/packages/spec-test-util/test/unit/downloadComptests.test.ts
@@ -76,9 +76,7 @@ describe("downloadComptests", () => {
     for (const fork of ["altair", "deneb"]) {
       expect(fs.existsSync(path.join(outputDir, "tests/minimal", fork, "fork_choice_compliance"))).toBe(true);
     }
-    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
-      specVersion: "v1.7.0-alpha.12",
-    });
+    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
     // Junk dirs from the tarball are not merged
     expect(fs.existsSync(path.join(outputDir, "tests/core"))).toBe(false);
   });
@@ -96,9 +94,7 @@ describe("downloadComptests", () => {
     expect(fs.readdirSync(altairCompliance)).toEqual(["new_case"]);
     // bellatrix dropped upstream => no stale cases left behind
     expect(fs.existsSync(path.join(outputDir, "tests/minimal/bellatrix/fork_choice_compliance"))).toBe(false);
-    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
-      specVersion: "v1.7.0-alpha.12",
-    });
+    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
   });
 
   it("cache hit does not fetch", async () => {
@@ -127,20 +123,16 @@ describe("downloadComptests", () => {
     expect(
       fs.existsSync(path.join(outputDir, "tests/minimal/altair/fork_choice_compliance/block_tree_test/good_case"))
     ).toBe(true);
-    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
-      specVersion: "v1.7.0-alpha.11",
-    });
+    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.11");
   });
 
-  it("unparseable marker is treated as stale and redownloads", async () => {
-    fs.writeFileSync(path.join(outputDir, "comptests-version.json"), "v1.7.0-alpha.12"); // legacy plain text
+  it("marker with a different version is treated as stale and redownloads", async () => {
+    fs.writeFileSync(path.join(outputDir, "comptests-version.txt"), "v1.7.0-alpha.11\n");
     mockFetchTarball(makeTarball({altair: ["case_a"]}));
 
     await downloadComptests(opts("v1.7.0-alpha.12"));
 
     expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(JSON.parse(fs.readFileSync(path.join(outputDir, "comptests-version.json"), "utf8"))).toEqual({
-      specVersion: "v1.7.0-alpha.12",
-    });
+    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
   });
 });

From d27b1d23c467bdd7257a7b433cc6e56448030eac Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 13:52:38 -0700
Subject: [PATCH 16/23] refactor: comptests fixtures in a standalone sibling
 directory
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Compliance vectors now live in spec-tests-comptests/ with their own
version.txt, downloaded via the plain generic downloader — a flow fully
parallel to the standard spec tests, sharing only the fork-choice test
runner. download-spec-tests and download-comptests are order-independent
(previously, a standard-tests version change wiped the shared directory
including the merged compliance vectors).

Deletes the asset-scoped merge downloader and its tests — no longer
needed without a shared directory.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../comptest/fork_choice_compliance.test.ts   |   9 +-
 .../test/spec/downloadComptests.ts            |  18 +--
 .../test/spec/specTestVersioning.ts           |  15 ++
 packages/spec-test-util/package.json          |   5 -
 .../spec-test-util/src/downloadComptests.ts   | 133 -----------------
 .../test/unit/downloadComptests.test.ts       | 138 ------------------
 6 files changed, 26 insertions(+), 292 deletions(-)
 delete mode 100644 packages/spec-test-util/src/downloadComptests.ts
 delete mode 100644 packages/spec-test-util/test/unit/downloadComptests.test.ts

diff --git a/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
index a4d7bb520207..3cc6733d6048 100644
--- a/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
+++ b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
@@ -1,17 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
 import {ACTIVE_PRESET} from "@lodestar/params";
-import {ethereumConsensusSpecsTests} from "../specTestVersioning.js";
+import {comptestsSpecTests} from "../specTestVersioning.js";
 import {forkChoiceTestRunner} from "../utils/forkChoiceTestRunner.js";
 import {specTestIterator} from "../utils/specTestIterator.js";
 import {RunnerType} from "../utils/types.js";
 
-// Fork-choice compliance suite (`pnpm test:comptest`) — its own vitest project, never part of
-// the regular spec runs. Fixtures via `pnpm download-comptests`.
+// Fork-choice compliance suite (`pnpm test:comptest`) — a standalone flow parallel to the
+// standard spec tests: its own vitest project, its own fixture directory
+// (`pnpm download-comptests`), sharing only the fork-choice test runner.
 
 // Zero-test guard: the workspace vitest config sets `passWithNoTests: true`, so without this a
 // run against missing fixtures would silently pass.
-const presetDir = path.join(ethereumConsensusSpecsTests.outputDir, "tests", ACTIVE_PRESET);
+const presetDir = path.join(comptestsSpecTests.outputDir, "tests", ACTIVE_PRESET);
 const hasComplianceFixtures =
   fs.existsSync(presetDir) &&
   fs.readdirSync(presetDir).some((fork) => fs.existsSync(path.join(presetDir, fork, "fork_choice_compliance")));
diff --git a/packages/beacon-node/test/spec/downloadComptests.ts b/packages/beacon-node/test/spec/downloadComptests.ts
index 20d7b578c3c2..2752bec7f3c1 100644
--- a/packages/beacon-node/test/spec/downloadComptests.ts
+++ b/packages/beacon-node/test/spec/downloadComptests.ts
@@ -1,16 +1,10 @@
-import {downloadComptests} from "@lodestar/spec-test-util/downloadComptests";
-import {ethereumConsensusSpecsTests} from "./specTestVersioning.js";
+import {downloadTests} from "@lodestar/spec-test-util/downloadTests";
+import {comptestsSpecTests} from "./specTestVersioning.js";
 
-// Same pin as the standard spec tests (spec-tests-version.json). The comptests.tar.gz release
-// asset exists for every release since v1.7.0-alpha.11 (consensus-specs #5334).
-await downloadComptests(
-  {
-    specVersion: ethereumConsensusSpecsTests.specVersion,
-    outputDir: ethereumConsensusSpecsTests.outputDir,
-    specTestsRepoUrl: ethereumConsensusSpecsTests.specTestsRepoUrl,
-  },
-  console.log
-).catch((e: Error) => {
+// Note: the release asset also packages non-vector content (tests/core, tests/formats,
+// tests/generators) next to tests/minimal — harmless, the spec-test iterator only reads
+// tests/<preset>.
+await downloadTests(comptestsSpecTests, console.log).catch((e: Error) => {
   console.error(e);
   process.exit(1);
 });
diff --git a/packages/beacon-node/test/spec/specTestVersioning.ts b/packages/beacon-node/test/spec/specTestVersioning.ts
index d4726ca26e23..cf0580e2ad71 100644
--- a/packages/beacon-node/test/spec/specTestVersioning.ts
+++ b/packages/beacon-node/test/spec/specTestVersioning.ts
@@ -13,3 +13,18 @@ export const blsSpecTests = {
   ...specTestVersions.blsSpecTests,
   outputDir: path.join(__dirname, "../../", specTestVersions.blsSpecTests.outputDirBase),
 };
+
+/**
+ * Fork-choice compliance vectors (`pnpm download-comptests` / `pnpm test:comptest`).
+ * Standalone flow parallel to the standard spec tests: same version pin and repo, but its own
+ * output directory so the two downloads are fully order-independent (the generic downloader
+ * wipes its whole output directory on a version change).
+ * The `comptests.tar.gz` release asset exists for every release since v1.7.0-alpha.11
+ * (consensus-specs #5334).
+ */
+export const comptestsSpecTests = {
+  specVersion: specTestVersions.ethereumConsensusSpecsTests.specVersion,
+  specTestsRepoUrl: specTestVersions.ethereumConsensusSpecsTests.specTestsRepoUrl,
+  testsToDownload: ["comptests"],
+  outputDir: path.join(__dirname, "../../", "spec-tests-comptests"),
+};
diff --git a/packages/spec-test-util/package.json b/packages/spec-test-util/package.json
index 0dae4a1af096..bab0446f3da4 100644
--- a/packages/spec-test-util/package.json
+++ b/packages/spec-test-util/package.json
@@ -24,11 +24,6 @@
       "bun": "./src/downloadNightlyTests.ts",
       "types": "./lib/downloadNightlyTests.d.ts",
       "import": "./lib/downloadNightlyTests.js"
-    },
-    "./downloadComptests": {
-      "bun": "./src/downloadComptests.ts",
-      "types": "./lib/downloadComptests.d.ts",
-      "import": "./lib/downloadComptests.js"
     }
   },
   "files": [
diff --git a/packages/spec-test-util/src/downloadComptests.ts b/packages/spec-test-util/src/downloadComptests.ts
deleted file mode 100644
index 14ce688666c0..000000000000
--- a/packages/spec-test-util/src/downloadComptests.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import {execFile} from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {pipeline} from "node:stream/promises";
-import {ReadableStream as NodeReadableStream} from "node:stream/web";
-import {promisify} from "node:util";
-import {fetch, retry} from "@lodestar/utils";
-import {defaultSpecTestsRepoUrl} from "./downloadTests.js";
-
-const logEmpty = (): void => {};
-
-export type DownloadComptestsOptions = {
-  specVersion: string;
-  /** Shared spec-tests output dir, the same one the standard downloader extracts into */
-  outputDir: string;
-  /** Root Github URL `https://github.com/ethereum/consensus-specs` */
-  specTestsRepoUrl?: string;
-  fetchInit?: RequestInit;
-};
-
-// Same convention as the standard downloader's version.txt, scoped to the comptests asset
-const MARKER_FILENAME = "comptests-version.txt";
-const COMPTESTS_SUBDIR = "fork_choice_compliance";
-
-/**
- * Download the fork-choice compliance test vectors (`comptests.tar.gz` release asset,
- * consensus-specs #5334) into the shared spec-tests directory.
- *
- * The standard downloader (`downloadGenericSpecTests`) deletes its ENTIRE output directory on a
- * cache miss, so it cannot be pointed at the shared dir for a second asset. This downloader is
- * asset-scoped instead:
- * - extracts into a temporary directory first,
- * - replaces only comptest-owned paths (`tests/<preset>/<fork>/fork_choice_compliance/`),
- * - never deletes the shared output directory,
- * - writes its own marker (`comptests-version.txt`) only after a successful merge, so a failed
- *   download/extraction leaves existing fixtures and marker untouched.
- *
- * Note: a standard-tests version change wipes the whole shared dir including these vectors
- * (correct — new pin needs new vectors); the `test:comptest` zero-test guard catches the absence.
- */
-export async function downloadComptests(
-  {specVersion, outputDir, specTestsRepoUrl, fetchInit}: DownloadComptestsOptions,
-  log: (msg: string) => void = logEmpty
-): Promise<void> {
-  log(`outputDir = ${outputDir}`);
-
-  const markerPath = path.join(outputDir, MARKER_FILENAME);
-  if (readMarkerVersion(markerPath) === specVersion) {
-    return log(`comptests version ${specVersion} already downloaded`);
-  }
-
-  const url = `${specTestsRepoUrl ?? defaultSpecTestsRepoUrl}/releases/download/${specVersion}/comptests.tar.gz`;
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lodestar-comptests-"));
-
-  try {
-    await retry(
-      async () => {
-        const res = await fetch(url, {signal: AbortSignal.timeout(30 * 60 * 1000), ...fetchInit});
-        if (!res.ok) {
-          throw new Error(`Failed to download file from ${url}: ${res.status} ${res.statusText}`);
-        }
-        if (!res.body) {
-          throw new Error("Response body is null");
-        }
-
-        log(`Downloading ${url} - ${res.headers.get("content-length")} bytes`);
-        const tarball = path.join(tmpDir, "comptests.tar.gz");
-        await pipeline(res.body as unknown as NodeReadableStream, fs.createWriteStream(tarball));
-        log(`Downloaded ${url} - ${fs.statSync(tarball).size} bytes`);
-
-        await promisify(execFile)("tar", ["-xzf", tarball, "-C", tmpDir, "--exclude=._*", "--exclude=*/._*"], {
-          maxBuffer: 1000 * 1024 * 1024, // 1 GB
-        });
-        log(`Extracted ${tarball}`);
-        fs.unlinkSync(tarball);
-      },
-      {
-        retries: 3,
-        onRetry: (e, attempt) => {
-          log(`Download attempt ${attempt} for comptests failed: ${e.message}`);
-        },
-      }
-    );
-
-    // Validate the extraction BEFORE touching the shared dir — tar can exit 0 on a truncated
-    // archive, and removing existing fixtures against an empty extraction would destroy them.
-    const extracted = findComptestDirs(tmpDir);
-    if (extracted.length === 0) {
-      throw new Error(`No ${COMPTESTS_SUBDIR} directories found in comptests.tar.gz from ${url}`);
-    }
-
-    // Remove ALL existing comptest-owned paths so forks dropped upstream leave no stale cases
-    for (const dir of findComptestDirs(outputDir)) {
-      fs.rmSync(dir, {recursive: true, force: true});
-    }
-    for (const srcDir of extracted) {
-      const destDir = path.join(outputDir, path.relative(tmpDir, srcDir));
-      fs.mkdirSync(path.dirname(destDir), {recursive: true});
-      fs.cpSync(srcDir, destDir, {recursive: true});
-      log(`Installed ${path.relative(outputDir, destDir)}`);
-    }
-
-    // Marker written only after a fully successful merge
-    fs.writeFileSync(markerPath, specVersion);
-    log(`comptests ${specVersion} ready`);
-  } finally {
-    fs.rmSync(tmpDir, {recursive: true, force: true});
-  }
-}
-
-function readMarkerVersion(markerPath: string): string | null {
-  if (!fs.existsSync(markerPath)) return null;
-  return fs.readFileSync(markerPath, "utf8").trim();
-}
-
-/** Find all `tests/<preset>/<fork>/fork_choice_compliance` dirs under `root` */
-function findComptestDirs(root: string): string[] {
-  const found: string[] = [];
-  const testsDir = path.join(root, "tests");
-  if (!fs.existsSync(testsDir)) return found;
-  for (const preset of fs.readdirSync(testsDir)) {
-    const presetDir = path.join(testsDir, preset);
-    if (!fs.statSync(presetDir).isDirectory()) continue;
-    for (const fork of fs.readdirSync(presetDir)) {
-      const complianceDir = path.join(presetDir, fork, COMPTESTS_SUBDIR);
-      if (fs.existsSync(complianceDir) && fs.statSync(complianceDir).isDirectory()) {
-        found.push(complianceDir);
-      }
-    }
-  }
-  return found;
-}
diff --git a/packages/spec-test-util/test/unit/downloadComptests.test.ts b/packages/spec-test-util/test/unit/downloadComptests.test.ts
deleted file mode 100644
index fc8f48f371e5..000000000000
--- a/packages/spec-test-util/test/unit/downloadComptests.test.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-import {execFileSync} from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {Readable} from "node:stream";
-import {afterEach, beforeEach, describe, expect, it, vi} from "vitest";
-import {downloadComptests} from "../../src/downloadComptests.js";
-
-/* eslint-disable @typescript-eslint/naming-convention */
-
-const fetchMock = vi.hoisted(() => vi.fn());
-
-vi.mock("@lodestar/utils", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@lodestar/utils")>();
-  return {...original, fetch: fetchMock};
-});
-
-describe("downloadComptests", () => {
-  let workDir: string;
-  let outputDir: string;
-
-  beforeEach(() => {
-    workDir = fs.mkdtempSync(path.join(os.tmpdir(), "comptests-test-"));
-    outputDir = path.join(workDir, "spec-tests");
-    fs.mkdirSync(outputDir, {recursive: true});
-    fetchMock.mockReset();
-  });
-
-  afterEach(() => {
-    fs.rmSync(workDir, {recursive: true, force: true});
-  });
-
-  /** Build a comptests.tar.gz containing `tests/minimal/<fork>/fork_choice_compliance/<case>` */
-  function makeTarball(forks: Record<string, string[]>): Uint8Array {
-    const stageDir = path.join(workDir, `stage-${Math.random().toString(36).slice(2)}`);
-    for (const [fork, cases] of Object.entries(forks)) {
-      for (const testCase of cases) {
-        const caseDir = path.join(stageDir, "tests/minimal", fork, "fork_choice_compliance/block_tree_test", testCase);
-        fs.mkdirSync(caseDir, {recursive: true});
-        fs.writeFileSync(path.join(caseDir, "steps.yaml"), `- {tick: 0} # ${fork}/${testCase}`);
-      }
-    }
-    // Junk dirs present in the real asset
-    fs.mkdirSync(path.join(stageDir, "tests/core/pyspec"), {recursive: true});
-    const tarPath = path.join(workDir, `fixture-${Math.random().toString(36).slice(2)}.tar.gz`);
-    execFileSync("tar", ["-czf", tarPath, "-C", stageDir, "tests"]);
-    return fs.readFileSync(tarPath);
-  }
-
-  function mockFetchTarball(bytes: Uint8Array): void {
-    fetchMock.mockResolvedValue({
-      ok: true,
-      headers: {get: () => String(bytes.length)},
-      body: Readable.toWeb(Readable.from([bytes])),
-    });
-  }
-
-  function writeStandardFixture(): string {
-    const standardFile = path.join(outputDir, "tests/minimal/altair/fork_choice/on_block/case_0/steps.yaml");
-    fs.mkdirSync(path.dirname(standardFile), {recursive: true});
-    fs.writeFileSync(standardFile, "- {tick: 0}");
-    fs.writeFileSync(path.join(outputDir, "version.txt"), "v1.7.0-alpha.12");
-    return standardFile;
-  }
-
-  const opts = (specVersion: string) => ({specVersion, outputDir});
-
-  it("installs comptests without touching standard fixtures", async () => {
-    const standardFile = writeStandardFixture();
-    mockFetchTarball(makeTarball({altair: ["case_a"], deneb: ["case_b"]}));
-
-    await downloadComptests(opts("v1.7.0-alpha.12"));
-
-    expect(fs.existsSync(standardFile)).toBe(true);
-    expect(fs.readFileSync(path.join(outputDir, "version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
-    for (const fork of ["altair", "deneb"]) {
-      expect(fs.existsSync(path.join(outputDir, "tests/minimal", fork, "fork_choice_compliance"))).toBe(true);
-    }
-    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
-    // Junk dirs from the tarball are not merged
-    expect(fs.existsSync(path.join(outputDir, "tests/core"))).toBe(false);
-  });
-
-  it("refresh on version change replaces comptest paths, preserves standard, removes stale forks", async () => {
-    const standardFile = writeStandardFixture();
-    mockFetchTarball(makeTarball({altair: ["old_case"], bellatrix: ["stale_case"]}));
-    await downloadComptests(opts("v1.7.0-alpha.11"));
-
-    mockFetchTarball(makeTarball({altair: ["new_case"]}));
-    await downloadComptests(opts("v1.7.0-alpha.12"));
-
-    expect(fs.existsSync(standardFile)).toBe(true);
-    const altairCompliance = path.join(outputDir, "tests/minimal/altair/fork_choice_compliance/block_tree_test");
-    expect(fs.readdirSync(altairCompliance)).toEqual(["new_case"]);
-    // bellatrix dropped upstream => no stale cases left behind
-    expect(fs.existsSync(path.join(outputDir, "tests/minimal/bellatrix/fork_choice_compliance"))).toBe(false);
-    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
-  });
-
-  it("cache hit does not fetch", async () => {
-    mockFetchTarball(makeTarball({altair: ["case_a"]}));
-    await downloadComptests(opts("v1.7.0-alpha.12"));
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-
-    await downloadComptests(opts("v1.7.0-alpha.12"));
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("failed extraction leaves existing fixtures and marker untouched", async () => {
-    const standardFile = writeStandardFixture();
-    mockFetchTarball(makeTarball({altair: ["good_case"]}));
-    await downloadComptests(opts("v1.7.0-alpha.11"));
-
-    // Corrupt tarball on refresh
-    fetchMock.mockResolvedValue({
-      ok: true,
-      headers: {get: () => "12"},
-      body: Readable.toWeb(Readable.from([new Uint8Array([0x1f, 0x8b, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])])),
-    });
-    await expect(downloadComptests(opts("v1.7.0-alpha.12"))).rejects.toThrow();
-
-    expect(fs.existsSync(standardFile)).toBe(true);
-    expect(
-      fs.existsSync(path.join(outputDir, "tests/minimal/altair/fork_choice_compliance/block_tree_test/good_case"))
-    ).toBe(true);
-    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.11");
-  });
-
-  it("marker with a different version is treated as stale and redownloads", async () => {
-    fs.writeFileSync(path.join(outputDir, "comptests-version.txt"), "v1.7.0-alpha.11\n");
-    mockFetchTarball(makeTarball({altair: ["case_a"]}));
-
-    await downloadComptests(opts("v1.7.0-alpha.12"));
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    expect(fs.readFileSync(path.join(outputDir, "comptests-version.txt"), "utf8")).toBe("v1.7.0-alpha.12");
-  });
-});

From 04b9ac312f8d824ff34de8ba801716824a939e15 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 15:34:07 -0700
Subject: [PATCH 17/23] ci: nightly fork-choice compliance test workflow
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Scheduled (03:00 UTC) rather than per-PR: most PRs don't touch fork
choice, and the vectors are pinned — nightly on unstable is the right
cadence to catch regressions. Same pattern as Kurtosis sim tests.
Manual runs via workflow_dispatch.

Also documents download-comptests/test:comptest in AGENTS.md/CLAUDE.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .github/workflows/comptests.yml | 43 +++++++++++++++++++++++++++++++++
 AGENTS.md                       |  6 +++++
 CLAUDE.md                       |  4 +++
 3 files changed, 53 insertions(+)
 create mode 100644 .github/workflows/comptests.yml

diff --git a/.github/workflows/comptests.yml b/.github/workflows/comptests.yml
new file mode 100644
index 000000000000..e9adeb27ee28
--- /dev/null
+++ b/.github/workflows/comptests.yml
@@ -0,0 +1,43 @@
+name: Fork-choice compliance tests
+
+# Don't cancel an in-flight run when the next cron fires
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+on:
+  schedule:
+    # 03:00 UTC — staggered against Kurtosis sim tests (00:00) and Nightly Spec Tests (06:00).
+    # Vectors are the pinned `comptests.tar.gz` release asset, so nightly cadence only tracks
+    # regressions on `unstable`, not upstream vector changes.
+    - cron: "0 3 * * *"
+  workflow_dispatch:
+
+jobs:
+  comptests:
+    name: Fork-choice compliance tests
+    # Don't run scheduled copies of this workflow on forks.
+    if: ${{ github.event_name != 'schedule' || github.repository == 'ChainSafe/lodestar' }}
+    runs-on: warp-ubuntu-2204-x64-4x
+    # Single vitest worker (one test file): ~10 min per fork locally, 6 pre-gloas forks.
+    timeout-minutes: 150
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: "./.github/actions/setup-and-build"
+        with:
+          node: 24
+
+      - name: Restore compliance vectors cache
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: packages/beacon-node/spec-tests-comptests
+          key: comptest-data-${{ hashFiles('packages/beacon-node/test/spec-tests-version.json') }}
+      - name: Download compliance vectors
+        run: pnpm download-comptests
+
+      - name: Fork-choice compliance tests
+        run: pnpm test:comptest
+        working-directory: packages/beacon-node
diff --git a/AGENTS.md b/AGENTS.md
index 2e3ada8d03c6..f0b4ca59295c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -105,6 +105,12 @@ pnpm download-spec-tests 2026-04-14                            # latest successf
 pnpm download-spec-tests latest <owner>/consensus-specs        # fork
 pnpm download-spec-tests latest <owner>/consensus-specs <ref>  # fork + branch
 
+# Fork-choice compliance tests (model-generated vectors, standalone flow;
+# runs nightly in CI, not per-PR). Same version pin as the spec tests.
+pnpm download-comptests
+pnpm test:comptest
+SPEC_FILTER_FORK=deneb pnpm test:comptest   # single fork (from packages/beacon-node)
+
 # Run e2e tests (requires docker environment)
 ./scripts/run_e2e_env.sh start
 pnpm test:e2e
diff --git a/CLAUDE.md b/CLAUDE.md
index 535f1fb86767..d40e872fb640 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -25,6 +25,10 @@ pnpm vitest run --project unit test/unit/path/to/test.test.ts
 pnpm download-spec-tests
 pnpm test:spec
 
+# Fork-choice compliance tests (standalone, nightly CI; download first)
+pnpm download-comptests
+pnpm test:comptest
+
 # Docs lint (markdown)
 pnpm docs:lint
 pnpm docs:lint:fix

From 3f73bb308904efdfab6eb0ecb1f985a9059d7152 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 15:38:35 -0700
Subject: [PATCH 18/23] fix: satisfy ProtoBlock discriminated union in
 getViableHeads test

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../test/unit/protoArray/getViableHeads.test.ts            | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts b/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts
index 5139cc4c98ce..6cf67cd99250 100644
--- a/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts
+++ b/packages/fork-choice/test/unit/protoArray/getViableHeads.test.ts
@@ -78,7 +78,12 @@ describe("ProtoArray.getViableHeads", () => {
     fc.onBlock(
       {
         ...blockFields({slot: 1, blockRoot: "2", parentRoot: "1", payloadStatus: PayloadStatus.PENDING}),
-        ...{executionPayloadBlockHash: "0xeb", executionStatus: ExecutionStatus.Valid},
+        ...{
+          executionPayloadBlockHash: "0xeb",
+          executionPayloadNumber: 1,
+          executionPayloadGasLimit: 30_000_000,
+          executionStatus: ExecutionStatus.Valid,
+        },
         parentBlockHash: "0xea",
       },
       1,

From bcae53bd0894735020559dddd118225191691633 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 15:49:45 -0700
Subject: [PATCH 19/23] refactor: comptests config block in
 spec-tests-version.json

Own outputDirBase and testsToDownload like the other entries; version
and repo URL shared with the standard spec tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .github/workflows/comptests.yml                    |  7 ++-----
 .../spec/comptest/fork_choice_compliance.test.ts   |  2 --
 .../beacon-node/test/spec/downloadComptests.ts     |  3 ---
 .../beacon-node/test/spec/specTestVersioning.ts    | 14 ++++----------
 spec-tests-version.json                            |  6 ++++++
 5 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/comptests.yml b/.github/workflows/comptests.yml
index e9adeb27ee28..d1f1ff03849f 100644
--- a/.github/workflows/comptests.yml
+++ b/.github/workflows/comptests.yml
@@ -10,10 +10,7 @@ permissions:
 
 on:
   schedule:
-    # 03:00 UTC — staggered against Kurtosis sim tests (00:00) and Nightly Spec Tests (06:00).
-    # Vectors are the pinned `comptests.tar.gz` release asset, so nightly cadence only tracks
-    # regressions on `unstable`, not upstream vector changes.
-    - cron: "0 3 * * *"
+    - cron: "0 3 * * *" # Runs at 3am UTC everyday
   workflow_dispatch:
 
 jobs:
@@ -34,7 +31,7 @@ jobs:
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: packages/beacon-node/spec-tests-comptests
-          key: comptest-data-${{ hashFiles('packages/beacon-node/test/spec-tests-version.json') }}
+          key: comptest-data-${{ hashFiles('spec-tests-version.json') }}
       - name: Download compliance vectors
         run: pnpm download-comptests
 
diff --git a/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
index 3cc6733d6048..94f58b3b9a0e 100644
--- a/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
+++ b/packages/beacon-node/test/spec/comptest/fork_choice_compliance.test.ts
@@ -10,8 +10,6 @@ import {RunnerType} from "../utils/types.js";
 // standard spec tests: its own vitest project, its own fixture directory
 // (`pnpm download-comptests`), sharing only the fork-choice test runner.
 
-// Zero-test guard: the workspace vitest config sets `passWithNoTests: true`, so without this a
-// run against missing fixtures would silently pass.
 const presetDir = path.join(comptestsSpecTests.outputDir, "tests", ACTIVE_PRESET);
 const hasComplianceFixtures =
   fs.existsSync(presetDir) &&
diff --git a/packages/beacon-node/test/spec/downloadComptests.ts b/packages/beacon-node/test/spec/downloadComptests.ts
index 2752bec7f3c1..01576b57d7ba 100644
--- a/packages/beacon-node/test/spec/downloadComptests.ts
+++ b/packages/beacon-node/test/spec/downloadComptests.ts
@@ -1,9 +1,6 @@
 import {downloadTests} from "@lodestar/spec-test-util/downloadTests";
 import {comptestsSpecTests} from "./specTestVersioning.js";
 
-// Note: the release asset also packages non-vector content (tests/core, tests/formats,
-// tests/generators) next to tests/minimal — harmless, the spec-test iterator only reads
-// tests/<preset>.
 await downloadTests(comptestsSpecTests, console.log).catch((e: Error) => {
   console.error(e);
   process.exit(1);
diff --git a/packages/beacon-node/test/spec/specTestVersioning.ts b/packages/beacon-node/test/spec/specTestVersioning.ts
index cf0580e2ad71..dafbdae8d8cd 100644
--- a/packages/beacon-node/test/spec/specTestVersioning.ts
+++ b/packages/beacon-node/test/spec/specTestVersioning.ts
@@ -14,17 +14,11 @@ export const blsSpecTests = {
   outputDir: path.join(__dirname, "../../", specTestVersions.blsSpecTests.outputDirBase),
 };
 
-/**
- * Fork-choice compliance vectors (`pnpm download-comptests` / `pnpm test:comptest`).
- * Standalone flow parallel to the standard spec tests: same version pin and repo, but its own
- * output directory so the two downloads are fully order-independent (the generic downloader
- * wipes its whole output directory on a version change).
- * The `comptests.tar.gz` release asset exists for every release since v1.7.0-alpha.11
- * (consensus-specs #5334).
- */
+// Even though comptests is run indepdently from spec test, it still shares the same
+// version and repo url with spec test
 export const comptestsSpecTests = {
+  ...specTestVersions.comptestsSpecTests,
   specVersion: specTestVersions.ethereumConsensusSpecsTests.specVersion,
   specTestsRepoUrl: specTestVersions.ethereumConsensusSpecsTests.specTestsRepoUrl,
-  testsToDownload: ["comptests"],
-  outputDir: path.join(__dirname, "../../", "spec-tests-comptests"),
+  outputDir: path.join(__dirname, "../../", specTestVersions.comptestsSpecTests.outputDirBase),
 };
diff --git a/spec-tests-version.json b/spec-tests-version.json
index 8a46f885ec4f..2f5197d3bfae 100644
--- a/spec-tests-version.json
+++ b/spec-tests-version.json
@@ -16,5 +16,11 @@
     "testsToDownload": [
       "bls_tests_yaml"
     ]
+  },
+  "comptestsSpecTests": {
+    "outputDirBase": "spec-tests-comptests",
+    "testsToDownload": [
+      "comptests"
+    ]
   }
 }

From 48f1f5f479299800efd01d11981edc11f0b7c65d Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 16:11:09 -0700
Subject: [PATCH 20/23] chore: polish comments in compliance suite code

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 configs/vitest.config.spec.ts                          |  2 +-
 .../test/spec/utils/forkChoiceTestRunner.ts            | 10 +++++-----
 .../beacon-node/test/spec/utils/specTestIterator.ts    |  8 +++-----
 packages/fork-choice/src/forkChoice/forkChoice.ts      |  8 +++++---
 packages/fork-choice/src/protoArray/protoArray.ts      |  1 -
 5 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/configs/vitest.config.spec.ts b/configs/vitest.config.spec.ts
index dab6471f7892..00e05d42bbc9 100644
--- a/configs/vitest.config.spec.ts
+++ b/configs/vitest.config.spec.ts
@@ -46,7 +46,7 @@ export const specProjectMainnet = defineProject({
 });
 
 // Fork-choice compliance suite (`pnpm test:comptest`) — deliberately its own project so the
-// regular spec projects never pick it up: ~1472 model-generated cases per fork.
+// regular spec projects never pick it up.
 // Fixtures via `pnpm download-comptests`.
 export const specProjectComptest = defineProject({
   test: {
diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
index 5b5d098a5d0a..372df840ee09 100644
--- a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -668,10 +668,9 @@ export const forkChoiceTestRunner =
                 );
               }
               if (step.checks.viable_for_head_roots_and_weights !== undefined) {
-                // Entries are identified by (root, payload_status, weight) per
-                // https://github.com/ethereum/consensus-specs/pull/5393 — gloas EMPTY/FULL
-                // variants of one block root are separate entries. Pre-gloas vectors omit
-                // payload_status (every pre-gloas node is FULL internally).
+                // Entries are identified by (root, payload_status, weight).
+                // gloas EMPTY/FULL variants of one block root are separate entries.
+                // Pre-gloas vectors omit payload_status (every pre-gloas node is FULL internally).
                 const isGloas = ForkSeq[fork] >= ForkSeq.gloas;
                 const expected = step.checks.viable_for_head_roots_and_weights
                   .map((entry) => ({
@@ -735,7 +734,8 @@ export const forkChoiceTestRunner =
                 for (const [k, act] of actual.entries()) {
                   const exp = expected[k];
                   // TODO GLOAS: boost attribution across payload-status variants of the boosted
-                  // root is Phase 4 work; pre-gloas each root has exactly one entry.
+                  // root should be handled when we set up gloas compliance test.
+                  // Pre-gloas each root has exactly one entry.
                   const isBoosted = exp.root === expectedBoostRoot;
                   const expectedAdjusted = isBoosted
                     ? exp.weightGwei - specBoostGwei + lodestarBoostGwei
diff --git a/packages/beacon-node/test/spec/utils/specTestIterator.ts b/packages/beacon-node/test/spec/utils/specTestIterator.ts
index 7fd89a4575d8..1586f67cf91a 100644
--- a/packages/beacon-node/test/spec/utils/specTestIterator.ts
+++ b/packages/beacon-node/test/spec/utils/specTestIterator.ts
@@ -81,17 +81,15 @@ export const defaultSkipOpts: SkipOpts = {
     // TODO-GLOAS: re-enable after Gloas light client is implemented
     /^gloas\/light_client\/.*/,
     /^gloas\/ssz_static\/LightClient(Bootstrap|FinalityUpdate|Header|OptimisticUpdate|Update)\/.*/,
-    // TODO GLOAS: compliance suite deferred to a follow-up PR — requires should_apply_proposer_boost
-    // (#9233), is_head_weak (#9654) and verifySignatures plumbing for embedded payload attestations.
-    // Baseline on the old artifact was 166/1472 (see PR #9314).
+    // TODO GLOAS: enable this after gloas fork choice is ready
     /^gloas\/fork_choice_compliance\/.*/,
   ],
   skippedTests: [
     // TODO-GLOAS: re-enable after gloas light client is implemented
     /\/gloas_fork$/,
-    // Proposer-boost dependent-root gate uses stale cached head across epoch-boundary ticks;
+    // TODO GLOAS: Proposer-boost dependent-root gate uses stale cached head across epoch-boundary ticks;
     // boost wrongly denied. Fails identically on every pre-gloas fork.
-    // https://github.com/ChainSafe/lodestar/issues/9666
+    // Enable this after https://github.com/ChainSafe/lodestar/issues/9666 is resolved
     /fork_choice_compliance\/block_tree_test\/pyspec_tests\/block_tree_test_16_201284350_1$/,
   ],
   // TODO GLOAS: Investigate why networking tests are failing since alpha.5
diff --git a/packages/fork-choice/src/forkChoice/forkChoice.ts b/packages/fork-choice/src/forkChoice/forkChoice.ts
index 3513e66a0b0f..6d413d38de4a 100644
--- a/packages/fork-choice/src/forkChoice/forkChoice.ts
+++ b/packages/fork-choice/src/forkChoice/forkChoice.ts
@@ -594,15 +594,17 @@ export class ForkChoice implements IForkChoice {
     return this.protoArray.nodes.filter((node) => node.bestChild === undefined);
   }
 
-  /** Weights are in EFFECTIVE_BALANCE_INCREMENT units (NOT Gwei). */
+  /**
+   * weight is in EFFECTIVE_BALANCE_INCREMENTS not gwei.
+   * For compliance test use only
+   */
   getViableHeads(): {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] {
     return this.protoArray.getViableHeads(this.fcStore.currentSlot);
   }
 
   /**
    * The cached justified total active balance, in EFFECTIVE_BALANCE_INCREMENT units.
-   * This is the exact balance source production uses for the proposer boost score
-   * (see getCommitteeFraction); exposed for the spec-test runner's boost emulation.
+   * For compliance test use only
    */
   getJustifiedTotalActiveBalanceByIncrement(): number {
     return this.fcStore.justified.totalBalance;
diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index f4e6aab81d9b..180da0db0ae6 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1552,7 +1552,6 @@ export class ProtoArray {
     const justifiedSlot = justifiedIndex !== undefined ? this.getNodeByIndex(justifiedIndex)?.slot : undefined;
     // Gloas payload-status variants of one blockRoot are distinct nodes in the spec's filtered
     // tree, identified by (root, payload_status, weight) — emit one entry per variant.
-    // https://github.com/ethereum/consensus-specs/pull/5393
     const heads: {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] = [];
     for (const node of this.nodes) {
       if (node.bestChild !== undefined || !this.nodeIsViableForHead(node, currentSlot)) {

From dd3805499c6076d4917d7a445b65971301f16a12 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Thu, 16 Jul 2026 17:09:54 -0700
Subject: [PATCH 21/23] fix: use clock slot for pre-tick attestation
 precondition

tickTime starts at 0, so an attestation step before the first tick
computed slot 0 regardless of the anchor state slot. clock.currentSlot
is initialized from the anchor slot and advanced by tick steps, matching
get_current_slot(store). Also document the ALREADY_KNOWN duplicate-block
accommodation honestly (spec re-processes duplicates; it is not a no-op).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../test/spec/utils/forkChoiceTestRunner.ts        | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
index 372df840ee09..01f6e12d047d 100644
--- a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -195,8 +195,9 @@ export const forkChoiceTestRunner =
               // (an attestation may only influence fork choice from the slot AFTER it was created). Lodestar
               // enforces this 1-slot delay in the gossip/attestation-pool layer, not in `forkChoice.onAttestation`,
               // so replicate the precondition here since the runner calls `onAttestation` directly.
-              const currentSlot = Math.floor(tickTime / (config.SLOT_DURATION_MS / 1000));
-              if (currentSlot < attestation.data.slot + 1) {
+              // `clock.currentSlot` is initialized from the anchor state slot and advanced by tick
+              // steps — matching `get_current_slot(store)` even before the first tick.
+              if (clock.currentSlot < attestation.data.slot + 1) {
                 if (isValid) {
                   throw Error(`Attestation not yet 1 slot old but marked valid at step ${i}`);
                 }
@@ -204,7 +205,7 @@ export const forkChoiceTestRunner =
                   `Step ${i}/${stepsLen} skip attestation: not yet 1 slot old (spec on_attestation rejects)`,
                   {
                     attSlot: attestation.data.slot,
-                    currentSlot,
+                    currentSlot: clock.currentSlot,
                   }
                 );
                 continue;
@@ -516,8 +517,11 @@ export const forkChoiceTestRunner =
                 });
                 if (!isValid) throw Error("Expect error since this is a negative test");
               } catch (e) {
-                // Spec `on_block` is a no-op success on a known block; lodestar's production
-                // import path rejects with ALREADY_KNOWN. Treat as success in the spec runner.
+                // Runner accommodation with a known limitation: the spec re-processes a duplicate
+                // block (re-runs the state transition and may refresh timeliness/boost/checkpoint
+                // state), while lodestar's production import path rejects duplicates with
+                // ALREADY_KNOWN. Treat as success; a vector that relies on duplicate-block side
+                // effects would diverge here.
                 if (isValid && e instanceof BlockError && e.type.code === BlockErrorCode.ALREADY_KNOWN) {
                   logger.debug(`Step ${i}/${stepsLen} block already known — treating as no-op success`, {
                     id: step.block,

From 3f039820b67254de05e79346ae7c98655312db83 Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:09:50 -0700
Subject: [PATCH 22/23] refactor: address review - reuse isDescendant in
 getViableHeads, TODO for getCommitteeFraction divergence

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../test/spec/utils/forkChoiceTestRunner.ts   |  8 +++++
 .../fork-choice/src/protoArray/protoArray.ts  | 31 +++++++------------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
index 01f6e12d047d..27b7f717edf4 100644
--- a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -710,6 +710,14 @@ export const forkChoiceTestRunner =
                 // bugs), normalize the expected weight of the boosted entry by
                 // `- spec_boost + lodestar_boost` and compare exactly.
                 //
+                // TODO: this normalization is a workaround for the root cause: `getCommitteeFraction`
+                // floors in increment units instead of the spec's Gwei-precision `get_proposer_score`
+                // (https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/phase0/fork-choice.md#get_proposer_score).
+                // Computing the boost in Gwei (bigint) and flooring once to increments would shrink
+                // the divergence to <1 ETH, but exact spec weights require Gwei-precision weight
+                // tracking in protoarray (increments exist because Gwei-scale totals overflow 2^53).
+                // Remove this normalization if/when weights match the spec exactly.
+                //
                 // Ordering rules (so normalization cannot mask a wrong boost root):
                 // - `checks.proposer_boost_root` was already asserted above, unadjusted.
                 // - Normalize using the VECTOR's expected boost root, never our actual one.
diff --git a/packages/fork-choice/src/protoArray/protoArray.ts b/packages/fork-choice/src/protoArray/protoArray.ts
index 04328343dcb5..a505d2c7cd9b 100644
--- a/packages/fork-choice/src/protoArray/protoArray.ts
+++ b/packages/fork-choice/src/protoArray/protoArray.ts
@@ -1577,8 +1577,7 @@ export class ProtoArray {
     // that descends from the justified checkpoint block AND is itself viable for head. Iterating
     // all nodes without the justified-descendant filter would wrongly include FFG-viable leaves
     // that hang off the finalized checkpoint on a branch not under the current justified checkpoint.
-    const justifiedIndex = this.getDefaultNodeIndex(this.justifiedRoot);
-    const justifiedSlot = justifiedIndex !== undefined ? this.getNodeByIndex(justifiedIndex)?.slot : undefined;
+    const justifiedVariant = this.getDefaultVariant(this.justifiedRoot);
     // Gloas payload-status variants of one blockRoot are distinct nodes in the spec's filtered
     // tree, identified by (root, payload_status, weight) — emit one entry per variant.
     const heads: {root: RootHex; payloadStatus: PayloadStatus; weight: number}[] = [];
@@ -1586,29 +1585,23 @@ export class ProtoArray {
       if (node.bestChild !== undefined || !this.nodeIsViableForHead(node, currentSlot)) {
         continue;
       }
-      if (this.justifiedEpoch !== GENESIS_EPOCH && !this.descendsFromJustified(node, justifiedSlot)) {
-        continue;
+      if (this.justifiedEpoch !== GENESIS_EPOCH) {
+        // Same-root short-circuit: every payload-status variant of the justified block itself is
+        // in the filtered tree, but `isDescendant` from the default (PENDING) variant does not
+        // reach the sibling EMPTY/FULL variants of the same root.
+        const descendsFromJustified =
+          node.blockRoot === this.justifiedRoot ||
+          (justifiedVariant !== undefined &&
+            this.isDescendant(this.justifiedRoot, justifiedVariant, node.blockRoot, node.payloadStatus));
+        if (!descendsFromJustified) {
+          continue;
+        }
       }
       heads.push({root: node.blockRoot, payloadStatus: node.payloadStatus, weight: node.weight});
     }
     return heads;
   }
 
-  /**
-   * True if `node` is the justified checkpoint block or one of its descendants.
-   * Parent slots are non-increasing, so the walk stops once it passes the justified block's slot.
-   */
-  private descendsFromJustified(node: ProtoNode, justifiedSlot: Slot | undefined): boolean {
-    let current: ProtoNode | undefined = node;
-    while (current !== undefined && (justifiedSlot === undefined || current.slot >= justifiedSlot)) {
-      if (current.blockRoot === this.justifiedRoot) {
-        return true;
-      }
-      current = current.parent !== undefined ? this.getNodeByIndex(current.parent) : undefined;
-    }
-    return false;
-  }
-
   /**
    * Return `true` if `node` is equal to or a descendant of the finalized node.
    * This function helps improve performance of nodeIsViableForHead a lot by avoiding

From 5ad936176c943ab4c58495189f3ec0b6830e2bff Mon Sep 17 00:00:00 2001
From: NC <17676176+ensi321@users.noreply.github.com>
Date: Wed, 22 Jul 2026 22:47:38 -0700
Subject: [PATCH 23/23] chore: link issue #9694 in proposer boost normalization
 TODO

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
index 9d9e3a5a4ee5..25a4a3ebb6ca 100644
--- a/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
+++ b/packages/beacon-node/test/spec/utils/forkChoiceTestRunner.ts
@@ -710,13 +710,13 @@ export const forkChoiceTestRunner =
                 // bugs), normalize the expected weight of the boosted entry by
                 // `- spec_boost + lodestar_boost` and compare exactly.
                 //
-                // TODO: this normalization is a workaround for the root cause: `getCommitteeFraction`
+                // TODO: remove this normalization when https://github.com/ChainSafe/lodestar/issues/9694
+                // is resolved. It is a workaround for the root cause: `getCommitteeFraction`
                 // floors in increment units instead of the spec's Gwei-precision `get_proposer_score`
                 // (https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.12/specs/phase0/fork-choice.md#get_proposer_score).
                 // Computing the boost in Gwei (bigint) and flooring once to increments would shrink
                 // the divergence to <1 ETH, but exact spec weights require Gwei-precision weight
                 // tracking in protoarray (increments exist because Gwei-scale totals overflow 2^53).
-                // Remove this normalization if/when weights match the spec exactly.
                 //
                 // Ordering rules (so normalization cannot mask a wrong boost root):
                 // - `checks.proposer_boost_root` was already asserted above, unadjusted.