Include compRefTests

build.gradle

@@ -541,6 +541,7 @@ def slashingProtectionInterchangeRefTestBaseUrl = 'https://github.com/eth-client
 def refTestDownloadDir = "${buildDir}/refTests/${refTestVersion}"
 def blsRefTestDownloadDir = "${buildDir}/blsRefTests/${blsRefTestVersion}"
 def slashingProtectionInterchangeRefTestDownloadDir = "${buildDir}/slashingProtectionInterchangeRefTests/${slashingProtectionInterchangeRefTestVersion}"
+def compTestDownloadDir = "${buildDir}/compRefTests/${refTestVersion}"
 def refTestExpandDir = "${project.rootDir}/eth-reference-tests/src/referenceTest/resources/consensus-spec-tests/"
 
 def downloadFile(String url, String token, File outputFile) {
@@ -657,8 +658,19 @@ tasks.register('downloadSlashingProtectionInterchangeRefTests', Download) {
 	overwrite false
 }
 
+// comptests.tar.gz is only published alongside tagged consensus-specs releases (not the nightly
+// vector-generation workflow), so it is skipped for nightly builds.
+tasks.register('downloadCompTests', Download) {
+	onlyIf { !nightly }
+	src([
+		"${refTestBaseUrl}/${refTestVersion}/comptests.tar.gz"
+	])
+	dest "${compTestDownloadDir}/comptests.tar.gz"
+	overwrite false
+}
+
 tasks.register('downloadRefTests') {
-	dependsOn downloadEthRefTests, downloadBlsRefTests, downloadSlashingProtectionInterchangeRefTests
+	dependsOn downloadEthRefTests, downloadBlsRefTests, downloadSlashingProtectionInterchangeRefTests, downloadCompTests
 }
 
 tasks.register('cleanRefTestsGeneral', Delete) {
@@ -719,11 +731,31 @@ tasks.register('expandRefTestsSlashingProtectionInterchange', Copy) {
 	into "${refTestExpandDir}/tests/slashing-protection-interchange"
 }
 
+// comptests.tar.gz bundles the whole consensus-specs tests/ tree (pyspec source included, not
+// just vectors), so only the fork_choice_compliance subtree is extracted here rather than the
+// full ~3GB archive.
+tasks.register('cleanRefTestsForkChoiceCompliance', Delete) {
+	delete fileTree(refTestExpandDir) {
+		include "tests/**/fork_choice_compliance/**"
+	}
+}
+
+tasks.register('expandRefTestsForkChoiceCompliance', Copy) {
+	dependsOn cleanRefTestsForkChoiceCompliance, downloadCompTests
+	onlyIf { !nightly }
+	from {
+		tarTree("${compTestDownloadDir}/comptests.tar.gz").matching {
+			include "tests/**/fork_choice_compliance/**"
+		}
+	}
+	into refTestExpandDir
+}
+
 tasks.register('expandRefTests') {
-	dependsOn expandRefTestsGeneral, expandRefTestsMainnet, expandRefTestsMinimal, expandRefTestsBls, expandRefTestsSlashingProtectionInterchange
+	dependsOn expandRefTestsGeneral, expandRefTestsMainnet, expandRefTestsMinimal, expandRefTestsBls, expandRefTestsSlashingProtectionInterchange, expandRefTestsForkChoiceCompliance
 }
 tasks.register('cleanRefTests') {
-	dependsOn cleanRefTestsGeneral, cleanRefTestsMainnet, cleanRefTestsMinimal, cleanRefTestsBls, cleanRefTestsSlashingProtectionInterchange
+	dependsOn cleanRefTestsGeneral, cleanRefTestsMainnet, cleanRefTestsMinimal, cleanRefTestsBls, cleanRefTestsSlashingProtectionInterchange, cleanRefTestsForkChoiceCompliance
 }
 
 tasks.register('deploy') {}

eth-reference-tests/src/referenceTest/java/tech/pegasys/teku/reference/phase0/forkchoice/ForkChoiceTestExecutor.java

@@ -26,6 +26,7 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -40,6 +41,7 @@
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.ssz.SSZ;
 import org.assertj.core.api.Condition;
+import org.junit.jupiter.api.Assertions;
 import org.opentest4j.TestAbortedException;
 import tech.pegasys.teku.bls.BLSSignature;
 import tech.pegasys.teku.bls.BLSSignatureVerifier;
@@ -75,7 +77,6 @@
 import tech.pegasys.teku.spec.datastructures.forkchoice.FastConfirmationStore;
 import tech.pegasys.teku.spec.datastructures.forkchoice.ForkChoiceNode;
 import tech.pegasys.teku.spec.datastructures.forkchoice.ForkChoicePayloadStatus;
-import tech.pegasys.teku.spec.datastructures.forkchoice.ProtoNodeData;
 import tech.pegasys.teku.spec.datastructures.forkchoice.ReadOnlyForkChoiceStrategy;
 import tech.pegasys.teku.spec.datastructures.forkchoice.ReadOnlyStore;
 import tech.pegasys.teku.spec.datastructures.forkchoice.VoteUpdater;
@@ -536,15 +537,12 @@ private void applyAttestation(
         forkChoice.onAttestation(validatableAttestation);
     assertThat(result).isCompleted();
     final AttestationProcessingResult processingResult = safeJoin(result);
-    // A current-slot attestation is valid but deferred by fork choice (stored and applied on the
-    // next tick). The fast confirmation vectors apply such attestations, so treat deferral as an
-    // accepted outcome.
-    final boolean acceptedByForkChoice =
-        processingResult.isSuccessful()
-            || processingResult.getStatus()
-                == AttestationProcessingResult.Status.DEFER_FORK_CHOICE_PROCESSING;
-    assertThat(acceptedByForkChoice)
-        .withFailMessage(processingResult.getInvalidReason())
+    // If a current-slot attestation is valid but deferred by fork choice (stored and applied on the
+    // next tick), reference tests seem to expect it to be considered invalid, so we will not
+    // consider
+    // it a successful attestation
+    assertThat(processingResult.isSuccessful())
+        .withFailMessage("%s failed with processing result: %s", attestationName, processingResult)
         .isEqualTo(valid);
   }
 
@@ -847,27 +845,53 @@ private void applyChecks(
 
           case "viable_for_head_roots_and_weights" -> {
             final List<Map<String, Object>> viableHeadRootsAndWeightsData = get(checks, checkType);
-            final Map<Bytes32, UInt64> viableHeadRootsAndWeights =
+
+            final Set<HeadRootAndWeight> viableHeadRootsAndWeights =
                 viableHeadRootsAndWeightsData.stream()
-                    .collect(
-                        Collectors.toMap(
-                            entry -> Bytes32.fromHexString((String) entry.get("root")),
-                            entry -> UInt64.valueOf(entry.get("weight").toString())));
-            final Map<Bytes32, UInt64> chainHeadRootsAndWeights =
+                    .map(
+                        entry ->
+                            new HeadRootAndWeight(
+                                Bytes32.fromHexString((String) entry.get("root")),
+                                UInt64.valueOf(entry.get("weight").toString()),
+                                Optional.ofNullable((Integer) entry.get("payload_status"))
+                                    .map(this::convertToPayloadStatus)))
+                    .collect(Collectors.toSet());
+            final Set<HeadRootAndWeight> chainHeadRootsAndWeights =
                 recentChainData
                     .getForkChoiceStrategy()
                     .map(ReadOnlyForkChoiceStrategy::getChainHeads)
                     .orElse(Collections.emptyList())
                     .stream()
-                    .collect(Collectors.toMap(ProtoNodeData::getRoot, ProtoNodeData::getWeight));
-
-            assertThat(chainHeadRootsAndWeights.keySet())
-                .containsAll(viableHeadRootsAndWeights.keySet());
-
-            for (Bytes32 root : viableHeadRootsAndWeights.keySet()) {
-              UInt64 weight = viableHeadRootsAndWeights.get(root);
-              UInt64 actualWeight = chainHeadRootsAndWeights.get(root);
-              assertThat(actualWeight).describedAs("block %s's weight", root).isEqualTo(weight);
+                    .map(
+                        protoNodeData ->
+                            new HeadRootAndWeight(
+                                protoNodeData.getRoot(),
+                                protoNodeData.getWeight(),
+                                Optional.ofNullable(protoNodeData.getPayloadStatus())))
+                    .collect(Collectors.toSet());
+
+            for (HeadRootAndWeight headRootAndWeight : viableHeadRootsAndWeights) {
+              boolean notPresent =
+                  chainHeadRootsAndWeights.stream()
+                      .noneMatch(
+                          (chainHeadRootAndWeight) -> {
+                            if (headRootAndWeight.root.equals(chainHeadRootAndWeight.root)
+                                && headRootAndWeight.weight.equals(chainHeadRootAndWeight.weight)) {
+                              // an unset payload status means we don't need to check if payload
+                              // status is correct
+                              if (headRootAndWeight.payloadStatus.isPresent()) {
+                                return headRootAndWeight.payloadStatus.equals(
+                                    chainHeadRootAndWeight.payloadStatus);
+                              } else {
+                                return true;
+                              }
+                            }
+                            return false;
+                          });
+              Assertions.assertFalse(
+                  notPresent,
+                  String.format(
+                      "Unable to find %s in %s", headRootAndWeight, chainHeadRootsAndWeights));
             }
           }
 
@@ -1142,4 +1166,14 @@ public BlsSetting getBlsSetting() {
       return BlsSetting.forCode(blsSetting);
     }
   }
+
+  private ForkChoicePayloadStatus convertToPayloadStatus(final int payloadStatus) {
+    return Arrays.stream(ForkChoicePayloadStatus.values())
+        .filter(fcps -> fcps.getValue() == payloadStatus)
+        .findAny()
+        .get();
+  }
+
+  private record HeadRootAndWeight(
+      Bytes32 root, UInt64 weight, Optional<ForkChoicePayloadStatus> payloadStatus) {}
 }

ethereum/spec/src/main/java/tech/pegasys/teku/spec/datastructures/attestation/AttestationSource.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright Consensys Software Inc., 2026
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package tech.pegasys.teku.spec.datastructures.attestation;
+
+public enum AttestationSource {
+  GOSSIP,
+  BLOCK
+}

ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/common/util/ForkChoiceUtil.java

@@ -28,6 +28,7 @@
 import tech.pegasys.teku.spec.config.SpecConfig;
 import tech.pegasys.teku.spec.config.SpecConfigAltair;
 import tech.pegasys.teku.spec.config.SpecConfigBellatrix;
+import tech.pegasys.teku.spec.datastructures.attestation.AttestationSource;
 import tech.pegasys.teku.spec.datastructures.attestation.ValidatableAttestation;
 import tech.pegasys.teku.spec.datastructures.blobs.versions.deneb.BlobSidecar;
 import tech.pegasys.teku.spec.datastructures.blocks.BeaconBlock;
@@ -536,13 +537,15 @@ private AttestationProcessingResult validateOnAttestation(
     UInt64 currentEpoch = miscHelpers.computeEpochAtSlot(getCurrentSlot(store));
     final ReadOnlyForkChoiceStrategy forkChoiceStrategy = store.getForkChoiceStrategy();
 
-    return validateOnAttestation(forkChoiceStrategy, currentEpoch, attestationData);
+    return validateOnAttestation(
+        forkChoiceStrategy, currentEpoch, attestationData, AttestationSource.GOSSIP);
   }
 
   public AttestationProcessingResult validateOnAttestation(
       final ReadOnlyForkChoiceStrategy forkChoiceStrategy,
       final UInt64 currentEpoch,
-      final AttestationData attestationData) {
+      final AttestationData attestationData,
+      final AttestationSource attestationSource) {
     final Checkpoint target = attestationData.getTarget();
 
     // Use GENESIS_EPOCH for previous when genesis to avoid underflow
@@ -551,9 +554,11 @@ public AttestationProcessingResult validateOnAttestation(
             ? currentEpoch.minus(UInt64.ONE)
             : SpecConfig.GENESIS_EPOCH;
 
-    if (!target.getEpoch().equals(previousEpoch) && !target.getEpoch().equals(currentEpoch)) {
-      return AttestationProcessingResult.invalid(
-          "Attestations must be from the current or previous epoch");
+    if (attestationSource == AttestationSource.GOSSIP) {
+      if (!target.getEpoch().equals(previousEpoch) && !target.getEpoch().equals(currentEpoch)) {
+        return AttestationProcessingResult.invalid(
+            "Attestations must be from the current or previous epoch");
+      }
     }
 
     if (!target.getEpoch().equals(miscHelpers.computeEpochAtSlot(attestationData.getSlot()))) {
@@ -923,10 +928,10 @@ public boolean shouldNotifyForkChoiceUpdatedOnBlock() {
   }
 
   public boolean shouldApplyProposerBoost(
+      final ForkChoiceReorgContext context,
       final Bytes32 proposerBoostRoot,
       final ReadOnlyForkChoiceStrategy forkChoiceStrategy,
-      final UInt64 reorgThreshold,
-      final BeaconState justifiedState) {
+      final UInt64 reorgThreshold) {
     return true;
   }
 

ethereum/spec/src/main/java/tech/pegasys/teku/spec/logic/versions/gloas/util/ForkChoiceUtilGloas.java

@@ -270,24 +270,20 @@ public Optional<ForkChoiceUtilGloas> toVersionGloas() {
    * If the boosted block's parent was weak and from the previous slot, boost only applies if there
    * are no timely equivocations from the same proposer.
    *
-   * <p>Implementation note: the proposer-equivocation branch is intentionally not implemented yet.
-   * The current code records both block timeliness flags, but it does not yet consume the PTC
-   * timeliness bit here to suppress proposer boost on same-proposer equivocations. Because that
-   * branch is still deferred, the weak-parent check has no effect on the return value and is
-   * intentionally skipped here.
+   * <p>Spec mapping: {@code should_apply_proposer_boost(store)}.
    *
+   * @param context the fork choice reorg context, used to look up blocks and PTC timeliness
    * @param proposerBoostRoot the current proposer boost root, empty if none
    * @param forkChoiceStrategy the fork choice strategy for looking up block data
    * @param reorgThreshold the threshold for the head weakness check
-   * @param justifiedState unused until the proposer-equivocation branch is implemented
    * @return true if proposer boost should be applied
    */
   @Override
   public boolean shouldApplyProposerBoost(
+      final ForkChoiceReorgContext context,
       final Bytes32 proposerBoostRoot,
       final ReadOnlyForkChoiceStrategy forkChoiceStrategy,
-      final UInt64 reorgThreshold,
-      final BeaconState justifiedState) {
+      final UInt64 reorgThreshold) {
     final Optional<Bytes32> maybeParentRoot = forkChoiceStrategy.blockParentRoot(proposerBoostRoot);
     final Optional<UInt64> maybeBlockSlot = forkChoiceStrategy.blockSlot(proposerBoostRoot);
     if (maybeParentRoot.isEmpty() || maybeBlockSlot.isEmpty()) {
@@ -299,21 +295,57 @@ public boolean shouldApplyProposerBoost(
     if (maybeParentSlot.isEmpty()) {
       return true;
     }
+    final UInt64 parentSlot = maybeParentSlot.get();
     // Apply proposer boost if parent is not from the previous slot
-    if (maybeParentSlot.get().increment().isLessThan(blockSlot)) {
+    if (parentSlot.increment().isLessThan(blockSlot)) {
       return true;
     }
-    // TODO-GLOAS: implement the Gloas equivocation suppression branch from
-    // should_apply_proposer_boost
-    // using recorded PTC timeliness instead of routing a predicate through ForkChoice.
-    // The complication is that we need to have a good interaction with gossip datastructures to
-    // detect equivocations. Spec should probably be updated.
-    // NOTE: there is no point in implementing the following check without implementing
-    // equivocation.
-    // # Apply proposer boost if `parent` is not weak
-    //    if not is_head_weak(store, parent_root):
-    //        return True
-    return true;
+    final ReadOnlyStore store = context.getStore();
+    // Apply proposer boost if `parent` is not weak
+    if (!isHeadWeak(store, parentRoot, reorgThreshold)) {
+      return true;
+    }
+    // If `parent` is weak and from the previous slot, apply
+    // proposer boost if there are no early equivocations
+    return !hasTimelyEquivocatingSiblingProposal(
+        context, forkChoiceStrategy, parentRoot, parentSlot);
+  }
+
+  /**
+   * Spec mapping: the {@code equivocations} list comprehension inside {@code
+   * should_apply_proposer_boost}.
+   *
+   * <p>Looks for another block proposed at the same slot as {@code parentRoot}, by the same
+   * proposer, whose PTC-timeliness bit is set. Finding one means the parent's proposer equivocated
+   * in a way that was seen in time by the PTC, which should suppress proposer boost on an
+   * otherwise-weak parent.
+   */
+  private boolean hasTimelyEquivocatingSiblingProposal(
+      final ForkChoiceReorgContext context,
+      final ReadOnlyForkChoiceStrategy forkChoiceStrategy,
+      final Bytes32 parentRoot,
+      final UInt64 parentSlot) {
+    final ReadOnlyStore store = context.getStore();
+    final Optional<UInt64> maybeParentProposerIndex =
+        store.getBlockIfAvailable(parentRoot).map(block -> block.getMessage().getProposerIndex());
+    if (maybeParentProposerIndex.isEmpty()) {
+      return false;
+    }
+    final UInt64 parentProposerIndex = maybeParentProposerIndex.get();
+    return forkChoiceStrategy.getBlockRootsAtSlot(parentSlot).stream()
+        .filter(siblingRoot -> !siblingRoot.equals(parentRoot))
+        .anyMatch(
+            siblingRoot ->
+                context
+                        .getBlockTimeliness(siblingRoot)
+                        .map(BlockTimeliness::isTimelyPtc)
+                        .orElse(false)
+                    && store
+                        .getBlockIfAvailable(siblingRoot)
+                        .map(
+                            block ->
+                                block.getMessage().getProposerIndex().equals(parentProposerIndex))
+                        .orElse(false));
   }
 
   /**