@lodestar/fork-choice 1.43.0-dev.6641fd750e → 1.43.0-dev.7622a1076c

package/src/forkChoice/forkChoice.ts

@@ -1,5 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {ForkSeq, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   DataAvailabilityStatus,
   EffectiveBalanceIncrements,
@@ -11,7 +11,6 @@ import {
   getAttesterSlashableIndices,
   isExecutionBlockBodyType,
   isStatePostBellatrix,
-  isStatePostGloas,
 } from "@lodestar/state-transition";
 import {
   AttesterSlashing,
@@ -53,7 +52,7 @@ import {
   NotReorgedReason,
   ShouldOverrideForkChoiceUpdateResult,
 } from "./interface.js";
-import {CheckpointWithPayloadStatus, IForkChoiceStore, JustifiedBalances, toCheckpointWithPayload} from "./store.js";
+import {CheckpointWithHex, IForkChoiceStore, JustifiedBalances, toCheckpointWithHex} from "./store.js";
 
 export type ForkChoiceOpts = {
   proposerBoost?: boolean;
@@ -311,6 +310,14 @@ export class ForkChoice implements IForkChoice {
     return this.proposerBoostRoot ?? HEX_ZERO_HASH;
   }
 
+  /**
+   * Decides whether to extend an available payload from the previous slot,
+   * corresponding to the beacon block `blockRoot`.
+   */
+  shouldExtendPayload(blockRoot: RootHex): boolean {
+    return this.protoArray.shouldExtendPayload(blockRoot, this.proposerBoostRoot);
+  }
+
   /**
    * To predict the proposer head of the next slot. That is, to predict if proposer-boost-reorg could happen.
    * Reason why we can't be certain is because information of the head block is not fully available yet
@@ -556,11 +563,11 @@ export class ForkChoice implements IForkChoice {
     return this.protoArray.nodes;
   }
 
-  getFinalizedCheckpoint(): CheckpointWithPayloadStatus {
+  getFinalizedCheckpoint(): CheckpointWithHex {
     return this.fcStore.finalizedCheckpoint;
   }
 
-  getJustifiedCheckpoint(): CheckpointWithPayloadStatus {
+  getJustifiedCheckpoint(): CheckpointWithHex {
     return this.fcStore.justified.checkpoint;
   }
 
@@ -641,10 +648,7 @@ export class ForkChoice implements IForkChoice {
     // Check block is a descendant of the finalized block at the checkpoint finalized slot.
     const blockAncestorNode = this.getAncestor(parentRootHex, finalizedSlot);
     const fcStoreFinalized = this.fcStore.finalizedCheckpoint;
-    if (
-      blockAncestorNode.blockRoot !== fcStoreFinalized.rootHex ||
-      blockAncestorNode.payloadStatus !== fcStoreFinalized.payloadStatus
-    ) {
+    if (blockAncestorNode.blockRoot !== fcStoreFinalized.rootHex) {
       throw new ForkChoiceError({
         code: ForkChoiceErrorCode.INVALID_BLOCK,
         err: {
@@ -670,18 +674,10 @@ export class ForkChoice implements IForkChoice {
       this.proposerBoostRoot = blockRootHex;
     }
 
-    // Get justified checkpoint with payload status for Gloas
-    const justifiedPayloadStatus = getCheckpointPayloadStatus(
-      this.config,
-      state,
-      state.currentJustifiedCheckpoint.epoch
-    );
-    const justifiedCheckpoint = toCheckpointWithPayload(state.currentJustifiedCheckpoint, justifiedPayloadStatus);
+    const justifiedCheckpoint = toCheckpointWithHex(state.currentJustifiedCheckpoint);
     const stateJustifiedEpoch = justifiedCheckpoint.epoch;
 
-    // Get finalized checkpoint with payload status for Gloas
-    const finalizedPayloadStatus = getCheckpointPayloadStatus(this.config, state, state.finalizedCheckpoint.epoch);
-    const finalizedCheckpoint = toCheckpointWithPayload(state.finalizedCheckpoint, finalizedPayloadStatus);
+    const finalizedCheckpoint = toCheckpointWithHex(state.finalizedCheckpoint);
 
     // Justified balances for `justifiedCheckpoint` are new to the fork-choice. Compute them on demand only if
     // the justified checkpoint changes
@@ -703,61 +699,29 @@ export class ForkChoice implements IForkChoice {
     // This is an optimization. It should reduce the amount of times we run
     // `process_justification_and_finalization` by approximately 1/3rd when the chain is
     // performing optimally.
-    let unrealizedJustifiedCheckpoint: CheckpointWithPayloadStatus;
-    let unrealizedFinalizedCheckpoint: CheckpointWithPayloadStatus;
+    let unrealizedJustifiedCheckpoint: CheckpointWithHex;
+    let unrealizedFinalizedCheckpoint: CheckpointWithHex;
     if (this.opts?.computeUnrealized) {
       if (
         parentBlock.unrealizedJustifiedEpoch === blockEpoch &&
         parentBlock.unrealizedFinalizedEpoch + 1 >= blockEpoch
       ) {
         // reuse from parent, happens at 1/3 last blocks of epoch as monitored in mainnet
-        // Get payload status for unrealized justified checkpoint
-        const unrealizedJustifiedPayloadStatus = getCheckpointPayloadStatus(
-          this.config,
-          state,
-          parentBlock.unrealizedJustifiedEpoch
-        );
         unrealizedJustifiedCheckpoint = {
           epoch: parentBlock.unrealizedJustifiedEpoch,
           root: fromHex(parentBlock.unrealizedJustifiedRoot),
           rootHex: parentBlock.unrealizedJustifiedRoot,
-          payloadStatus: unrealizedJustifiedPayloadStatus,
         };
-        // Get payload status for unrealized finalized checkpoint
-        const unrealizedFinalizedPayloadStatus = getCheckpointPayloadStatus(
-          this.config,
-          state,
-          parentBlock.unrealizedFinalizedEpoch
-        );
         unrealizedFinalizedCheckpoint = {
           epoch: parentBlock.unrealizedFinalizedEpoch,
           root: fromHex(parentBlock.unrealizedFinalizedRoot),
           rootHex: parentBlock.unrealizedFinalizedRoot,
-          payloadStatus: unrealizedFinalizedPayloadStatus,
         };
       } else {
         // compute new, happens 2/3 first blocks of epoch as monitored in mainnet
         const unrealized = state.computeUnrealizedCheckpoints();
-        // Get payload status for unrealized justified checkpoint
-        const unrealizedJustifiedPayloadStatus = getCheckpointPayloadStatus(
-          this.config,
-          state,
-          unrealized.justifiedCheckpoint.epoch
-        );
-        unrealizedJustifiedCheckpoint = toCheckpointWithPayload(
-          unrealized.justifiedCheckpoint,
-          unrealizedJustifiedPayloadStatus
-        );
-        // Get payload status for unrealized finalized checkpoint
-        const unrealizedFinalizedPayloadStatus = getCheckpointPayloadStatus(
-          this.config,
-          state,
-          unrealized.finalizedCheckpoint.epoch
-        );
-        unrealizedFinalizedCheckpoint = toCheckpointWithPayload(
-          unrealized.finalizedCheckpoint,
-          unrealizedFinalizedPayloadStatus
-        );
+        unrealizedJustifiedCheckpoint = toCheckpointWithHex(unrealized.justifiedCheckpoint);
+        unrealizedFinalizedCheckpoint = toCheckpointWithHex(unrealized.finalizedCheckpoint);
       }
     } else {
       unrealizedJustifiedCheckpoint = justifiedCheckpoint;
@@ -983,7 +947,6 @@ export class ForkChoice implements IForkChoice {
     blockRoot: RootHex,
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
-    executionPayloadStateRoot: RootHex,
     executionStatus: PayloadExecutionStatus
   ): void {
     this.protoArray.onExecutionPayload(
@@ -991,7 +954,6 @@ export class ForkChoice implements IForkChoice {
       this.fcStore.currentSlot,
       executionPayloadBlockHash,
       executionPayloadNumber,
-      executionPayloadStateRoot,
       this.proposerBoostRoot,
       executionStatus
     );
@@ -1122,8 +1084,8 @@ export class ForkChoice implements IForkChoice {
   }
 
   getJustifiedBlock(): ProtoBlock {
-    const {rootHex, payloadStatus} = this.fcStore.justified.checkpoint;
-    const block = this.getBlockHex(rootHex, payloadStatus);
+    const {rootHex} = this.fcStore.justified.checkpoint;
+    const block = this.getBlockHexDefaultStatus(rootHex);
     if (!block) {
       throw new ForkChoiceError({
         code: ForkChoiceErrorCode.MISSING_PROTO_ARRAY_BLOCK,
@@ -1134,8 +1096,8 @@ export class ForkChoice implements IForkChoice {
   }
 
   getFinalizedBlock(): ProtoBlock {
-    const {rootHex, payloadStatus} = this.fcStore.finalizedCheckpoint;
-    const block = this.getBlockHex(rootHex, payloadStatus);
+    const {rootHex} = this.fcStore.finalizedCheckpoint;
+    const block = this.getBlockHexDefaultStatus(rootHex);
     if (!block) {
       throw new ForkChoiceError({
         code: ForkChoiceErrorCode.MISSING_PROTO_ARRAY_BLOCK,
@@ -1228,18 +1190,33 @@ export class ForkChoice implements IForkChoice {
 
   /**
    * Returns both ancestor and non-ancestor blocks in a single traversal.
+   *
+   * `ancestors` is the raw walk and includes the previous finalized block as its last element —
+   * callers that don't want the boundary should slice it off themselves.
+   * Post-gloas for each block root, it returns exactly one variant of it.
    */
   getAllAncestorAndNonAncestorBlocks(
     blockRoot: RootHex,
     payloadStatus: PayloadStatus
   ): {ancestors: ProtoBlock[]; nonAncestors: ProtoBlock[]} {
-    const {ancestors, nonAncestors} = this.protoArray.getAllAncestorAndNonAncestorNodes(blockRoot, payloadStatus);
+    return this.protoArray.getAllAncestorAndNonAncestorNodes(blockRoot, payloadStatus);
+  }
 
-    return {
-      // the last node is the previous finalized one, it's there to check onBlock finalized checkpoint only.
-      ancestors: ancestors.slice(0, ancestors.length - 1),
-      nonAncestors,
-    };
+  /**
+   * Same to getAllAncestorAndNonAncestorBlocks with default variant of ${blockRoot} to start with
+   */
+  getAllAncestorAndNonAncestorBlocksDefaultStatus(blockRoot: RootHex): {
+    ancestors: ProtoBlock[];
+    nonAncestors: ProtoBlock[];
+  } {
+    const defaultStatus = this.protoArray.getDefaultVariant(blockRoot);
+    if (defaultStatus === undefined) {
+      throw new ForkChoiceError({
+        code: ForkChoiceErrorCode.MISSING_PROTO_ARRAY_BLOCK,
+        root: blockRoot,
+      });
+    }
+    return this.getAllAncestorAndNonAncestorBlocks(blockRoot, defaultStatus);
   }
 
   getCanonicalBlockByRoot(blockRoot: Root): ProtoBlock | null {
@@ -1311,6 +1288,17 @@ export class ForkChoice implements IForkChoice {
     }
   }
 
+  forwardIterateDescendantsDefaultStatus(blockRoot: RootHex): IterableIterator<ProtoBlock> {
+    const defaultStatus = this.protoArray.getDefaultVariant(blockRoot);
+    if (defaultStatus === undefined) {
+      throw new ForkChoiceError({
+        code: ForkChoiceErrorCode.MISSING_PROTO_ARRAY_BLOCK,
+        root: blockRoot,
+      });
+    }
+    return this.forwardIterateDescendants(blockRoot, defaultStatus);
+  }
+
   /** Very expensive function, iterates the entire ProtoArray. TODO: Is this function even necessary? */
   getBlockSummariesByParentRoot(parentRoot: RootHex): ProtoBlock[] {
     return this.protoArray.nodes.filter((node) => node.parentRoot === parentRoot);
@@ -1497,12 +1485,12 @@ export class ForkChoice implements IForkChoice {
    *
    * **`on_tick`**
    * May need the justified balances of:
-   * - unrealizedJustified: Already available in `CheckpointWithPayloadAndBalance`
+   * - unrealizedJustified: Already available in `CheckpointWithBalance`
    * Since this balances are already available the getter is just `() => balances`, without cache interaction
    */
   private updateCheckpoints(
-    justifiedCheckpoint: CheckpointWithPayloadStatus,
-    finalizedCheckpoint: CheckpointWithPayloadStatus,
+    justifiedCheckpoint: CheckpointWithHex,
+    finalizedCheckpoint: CheckpointWithHex,
     getJustifiedBalances: () => JustifiedBalances
   ): void {
     // Update justified checkpoint.
@@ -1522,8 +1510,8 @@ export class ForkChoice implements IForkChoice {
    * Update unrealized checkpoints in store if necessary
    */
   private updateUnrealizedCheckpoints(
-    unrealizedJustifiedCheckpoint: CheckpointWithPayloadStatus,
-    unrealizedFinalizedCheckpoint: CheckpointWithPayloadStatus,
+    unrealizedJustifiedCheckpoint: CheckpointWithHex,
+    unrealizedFinalizedCheckpoint: CheckpointWithHex,
     getJustifiedBalances: () => JustifiedBalances
   ): void {
     if (unrealizedJustifiedCheckpoint.epoch > this.fcStore.unrealizedJustified.checkpoint.epoch) {
@@ -1898,38 +1886,3 @@ export function getCommitteeFraction(
   const committeeWeight = Math.floor(justifiedTotalActiveBalanceByIncrement / config.slotsPerEpoch);
   return Math.floor((committeeWeight * config.committeePercent) / 100);
 }
-
-/**
- * Get the payload status for a checkpoint.
- *
- * Pre-Gloas: always FULL (payload embedded in block)
- * Gloas: determined by state.execution_payload_availability
- *
- * @param config - The chain fork config to determine fork at checkpoint slot
- * @param state - The state to check execution_payload_availability
- * @param checkpointEpoch - The epoch of the checkpoint
- */
-export function getCheckpointPayloadStatus(
-  config: ChainForkConfig,
-  state: IBeaconStateView,
-  checkpointEpoch: number
-): PayloadStatus {
-  // Compute checkpoint slot first to determine the correct fork
-  const checkpointSlot = computeStartSlotAtEpoch(checkpointEpoch);
-  const fork = config.getForkSeq(checkpointSlot);
-
-  // Pre-Gloas: always FULL
-  if (fork < ForkSeq.gloas) {
-    return PayloadStatus.FULL;
-  }
-  if (!isStatePostGloas(state)) {
-    throw new Error(`Expected gloas+ state for checkpoint payload status, got fork=${state.forkName}`);
-  }
-
-  // For Gloas, check state.execution_payload_availability
-  // - For non-skipped slots at checkpoint: returns false (EMPTY) since payload hasn't arrived yet
-  // - For skipped slots at checkpoint: returns the actual availability status from state
-  const payloadAvailable = state.executionPayloadAvailability.get(checkpointSlot % SLOTS_PER_HISTORICAL_ROOT);
-
-  return payloadAvailable ? PayloadStatus.FULL : PayloadStatus.EMPTY;
-}

package/src/forkChoice/interface.ts

@@ -9,7 +9,7 @@ import {
   ProtoNode,
 } from "../protoArray/interface.js";
 import {UpdateAndGetHeadOpt} from "./forkChoice.js";
-import {CheckpointWithHex, CheckpointWithPayloadStatus} from "./store.js";
+import {CheckpointWithHex} from "./store.js";
 
 export type CheckpointHex = {
   epoch: Epoch;
@@ -21,12 +21,12 @@ export type CheckpointsWithHex = {
   finalizedCheckpoint: CheckpointWithHex;
 };
 
-export type CheckpointWithPayloadAndBalance = {
-  checkpoint: CheckpointWithPayloadStatus;
+export type CheckpointWithBalance = {
+  checkpoint: CheckpointWithHex;
   balances: EffectiveBalanceIncrements;
 };
 
-export type CheckpointWithPayloadAndTotalBalance = CheckpointWithPayloadAndBalance & {
+export type CheckpointWithTotalBalance = CheckpointWithBalance & {
   totalBalance: number;
 };
 
@@ -121,8 +121,8 @@ export interface IForkChoice {
    * Retrieve all nodes for the debug API.
    */
   getAllNodes(): ProtoNode[];
-  getFinalizedCheckpoint(): CheckpointWithPayloadStatus;
-  getJustifiedCheckpoint(): CheckpointWithPayloadStatus;
+  getFinalizedCheckpoint(): CheckpointWithHex;
+  getJustifiedCheckpoint(): CheckpointWithHex;
   /**
    * Add `block` to the fork choice DAG.
    *
@@ -198,13 +198,11 @@ export interface IForkChoice {
    * @param blockRoot - The beacon block root for which the payload arrived
    * @param executionPayloadBlockHash - The block hash of the execution payload
    * @param executionPayloadNumber - The block number of the execution payload
-   * @param executionPayloadStateRoot - The execution payload state root ie. the root of post-state after processExecutionPayloadEnvelope()
    */
   onExecutionPayload(
     blockRoot: RootHex,
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
-    executionPayloadStateRoot: RootHex,
     executionStatus: PayloadExecutionStatus
   ): void;
   /**
@@ -241,6 +239,7 @@ export interface IForkChoice {
   getBlockDefaultStatus(blockRoot: Root): ProtoBlock | null;
   getBlockHexDefaultStatus(blockRoot: RootHex): ProtoBlock | null;
   getBlockHexAndBlockHash(blockRoot: RootHex, blockHash: RootHex): ProtoBlock | null;
+  shouldExtendPayload(blockRoot: RootHex): boolean;
   getFinalizedBlock(): ProtoBlock;
   getJustifiedBlock(): ProtoBlock;
   getFinalizedCheckpointSlot(): Slot;
@@ -272,11 +271,23 @@ export interface IForkChoice {
   getAllNonAncestorBlocks(blockRoot: RootHex, payloadStatus: PayloadStatus): ProtoBlock[];
   /**
    * Returns both ancestor and non-ancestor blocks in a single traversal.
+   *
+   * `ancestors` is the raw walk and includes the previous finalized block as its last element —
+   * callers that don't want the boundary should slice it off themselves.
    */
   getAllAncestorAndNonAncestorBlocks(
     blockRoot: RootHex,
     payloadStatus: PayloadStatus
   ): {ancestors: ProtoBlock[]; nonAncestors: ProtoBlock[]};
+  /**
+   * Same as `getAllAncestorAndNonAncestorBlocks` but resolves the default payload-status variant
+   * (FULL pre-Gloas, PENDING for Gloas) for the given root. Use when the caller holds a
+   * `CheckpointWithHex` / finalized root without a specific payload-status variant in mind.
+   */
+  getAllAncestorAndNonAncestorBlocksDefaultStatus(blockRoot: RootHex): {
+    ancestors: ProtoBlock[];
+    nonAncestors: ProtoBlock[];
+  };
   getCanonicalBlockByRoot(blockRoot: Root): ProtoBlock | null;
   getCanonicalBlockAtSlot(slot: Slot): ProtoBlock | null;
   getCanonicalBlockClosestLteSlot(slot: Slot): ProtoBlock | null;
@@ -288,6 +299,12 @@ export interface IForkChoice {
    * Iterates forward descendants of blockRoot. Does not yield blockRoot itself
    */
   forwardIterateDescendants(blockRoot: RootHex, payloadStatus: PayloadStatus): IterableIterator<ProtoBlock>;
+  /**
+   * Same as `forwardIterateDescendants` but resolves the default payload-status variant
+   * (FULL pre-Gloas, PENDING for Gloas) for the given root. Use when the caller holds a
+   * `CheckpointWithHex` / finalized root without a specific payload-status variant in mind.
+   */
+  forwardIterateDescendantsDefaultStatus(blockRoot: RootHex): IterableIterator<ProtoBlock>;
   getBlockSummariesByParentRoot(parentRoot: RootHex): ProtoBlock[];
   getBlockSummariesAtSlot(slot: Slot): ProtoBlock[];
   /** Returns the distance of common ancestor of nodes to the max of the newNode and the prevNode. */

package/src/forkChoice/store.ts

@@ -1,8 +1,7 @@
 import {EffectiveBalanceIncrements, IBeaconStateView} from "@lodestar/state-transition";
 import {RootHex, Slot, ValidatorIndex, phase0} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
-import {PayloadStatus} from "../protoArray/interface.js";
-import {CheckpointWithPayloadAndBalance, CheckpointWithPayloadAndTotalBalance} from "./interface.js";
+import {CheckpointWithBalance, CheckpointWithTotalBalance} from "./interface.js";
 
 /**
  * Stores checkpoints in a hybrid format:
@@ -11,15 +10,6 @@ import {CheckpointWithPayloadAndBalance, CheckpointWithPayloadAndTotalBalance} f
  */
 export type CheckpointWithHex = phase0.Checkpoint & {rootHex: RootHex};
 
-/**
- * Checkpoint with payload status for Gloas fork choice.
- * Used to track which variant (EMPTY or FULL) of the finalized/justified block to use.
- *
- * Pre-Gloas: payloadStatus is always FULL (payload embedded in block)
- * Gloas: determined by state.execution_payload_availability
- */
-export type CheckpointWithPayloadStatus = CheckpointWithHex & {payloadStatus: PayloadStatus};
-
 export type JustifiedBalances = EffectiveBalanceIncrements;
 
 /**
@@ -29,7 +19,7 @@ export type JustifiedBalances = EffectiveBalanceIncrements;
  * @param blockState state that declares justified checkpoint `checkpoint`
  */
 export type JustifiedBalancesGetter = (
-  checkpoint: CheckpointWithPayloadStatus,
+  checkpoint: CheckpointWithHex,
   blockState: IBeaconStateView
 ) => JustifiedBalances;
 
@@ -47,11 +37,11 @@ export type JustifiedBalancesGetter = (
  */
 export interface IForkChoiceStore {
   currentSlot: Slot;
-  get justified(): CheckpointWithPayloadAndTotalBalance;
-  set justified(justified: CheckpointWithPayloadAndBalance);
-  unrealizedJustified: CheckpointWithPayloadAndBalance;
-  finalizedCheckpoint: CheckpointWithPayloadStatus;
-  unrealizedFinalizedCheckpoint: CheckpointWithPayloadStatus;
+  get justified(): CheckpointWithTotalBalance;
+  set justified(justified: CheckpointWithBalance);
+  unrealizedJustified: CheckpointWithBalance;
+  finalizedCheckpoint: CheckpointWithHex;
+  unrealizedFinalizedCheckpoint: CheckpointWithHex;
   justifiedBalancesGetter: JustifiedBalancesGetter;
   equivocatingIndices: Set<ValidatorIndex>;
 }
@@ -60,10 +50,10 @@ export interface IForkChoiceStore {
  * IForkChoiceStore implementer which emits forkChoice events on updated justified and finalized checkpoints.
  */
 export class ForkChoiceStore implements IForkChoiceStore {
-  private _justified: CheckpointWithPayloadAndTotalBalance;
-  unrealizedJustified: CheckpointWithPayloadAndBalance;
-  private _finalizedCheckpoint: CheckpointWithPayloadStatus;
-  unrealizedFinalizedCheckpoint: CheckpointWithPayloadStatus;
+  private _justified: CheckpointWithTotalBalance;
+  unrealizedJustified: CheckpointWithBalance;
+  private _finalizedCheckpoint: CheckpointWithHex;
+  unrealizedFinalizedCheckpoint: CheckpointWithHex;
   equivocatingIndices = new Set<ValidatorIndex>();
   justifiedBalancesGetter: JustifiedBalancesGetter;
   currentSlot: Slot;
@@ -74,49 +64,37 @@ export class ForkChoiceStore implements IForkChoiceStore {
     finalizedCheckpoint: phase0.Checkpoint,
     justifiedBalances: EffectiveBalanceIncrements,
     justifiedBalancesGetter: JustifiedBalancesGetter,
-    /**
-     * Payload status for justified checkpoint.
-     * Pre-Gloas: always FULL
-     * Gloas: determined by state.execution_payload_availability
-     */
-    justifiedPayloadStatus: PayloadStatus,
-    /**
-     * Payload status for finalized checkpoint.
-     * Pre-Gloas: always FULL
-     * Gloas: determined by state.execution_payload_availability
-     */
-    finalizedPayloadStatus: PayloadStatus,
     private readonly events?: {
-      onJustified: (cp: CheckpointWithPayloadStatus) => void;
-      onFinalized: (cp: CheckpointWithPayloadStatus) => void;
+      onJustified: (cp: CheckpointWithHex) => void;
+      onFinalized: (cp: CheckpointWithHex) => void;
     }
   ) {
     this.justifiedBalancesGetter = justifiedBalancesGetter;
     this.currentSlot = currentSlot;
     const justified = {
-      checkpoint: toCheckpointWithPayload(justifiedCheckpoint, justifiedPayloadStatus),
+      checkpoint: toCheckpointWithHex(justifiedCheckpoint),
       balances: justifiedBalances,
       totalBalance: computeTotalBalance(justifiedBalances),
     };
     this._justified = justified;
     this.unrealizedJustified = justified;
-    this._finalizedCheckpoint = toCheckpointWithPayload(finalizedCheckpoint, finalizedPayloadStatus);
+    this._finalizedCheckpoint = toCheckpointWithHex(finalizedCheckpoint);
     this.unrealizedFinalizedCheckpoint = this._finalizedCheckpoint;
   }
 
-  get justified(): CheckpointWithPayloadAndTotalBalance {
+  get justified(): CheckpointWithTotalBalance {
     return this._justified;
   }
-  set justified(justified: CheckpointWithPayloadAndBalance) {
+  set justified(justified: CheckpointWithBalance) {
     this._justified = {...justified, totalBalance: computeTotalBalance(justified.balances)};
     this.events?.onJustified(justified.checkpoint);
   }
 
-  get finalizedCheckpoint(): CheckpointWithPayloadStatus {
+  get finalizedCheckpoint(): CheckpointWithHex {
     return this._finalizedCheckpoint;
   }
-  set finalizedCheckpoint(checkpoint: CheckpointWithPayloadStatus) {
-    const cp = toCheckpointWithPayload(checkpoint, checkpoint.payloadStatus);
+  set finalizedCheckpoint(checkpoint: CheckpointWithHex) {
+    const cp = toCheckpointWithHex(checkpoint);
     this._finalizedCheckpoint = cp;
     this.events?.onFinalized(cp);
   }
@@ -133,16 +111,6 @@ export function toCheckpointWithHex(checkpoint: phase0.Checkpoint): CheckpointWi
   };
 }
 
-export function toCheckpointWithPayload(
-  checkpoint: phase0.Checkpoint,
-  payloadStatus: PayloadStatus
-): CheckpointWithPayloadStatus {
-  return {
-    ...toCheckpointWithHex(checkpoint),
-    payloadStatus,
-  };
-}
-
 export function equalCheckpointWithHex(a: CheckpointWithHex, b: CheckpointWithHex): boolean {
   return a.epoch === b.epoch && a.rootHex === b.rootHex;
 }

package/src/index.ts

@@ -6,17 +6,12 @@ export {
   type InvalidBlock,
   InvalidBlockCode,
 } from "./forkChoice/errors.js";
-export {
-  ForkChoice,
-  type ForkChoiceOpts,
-  UpdateHeadOpt,
-  getCheckpointPayloadStatus,
-} from "./forkChoice/forkChoice.js";
+export {ForkChoice, type ForkChoiceOpts, UpdateHeadOpt} from "./forkChoice/forkChoice.js";
 export {
   type AncestorResult,
   AncestorStatus,
-  type CheckpointWithPayloadAndBalance,
-  type CheckpointWithPayloadAndTotalBalance,
+  type CheckpointWithBalance,
+  type CheckpointWithTotalBalance,
   EpochDifference,
   type IForkChoice,
   NotReorgedReason,
@@ -24,7 +19,6 @@ export {
 export * from "./forkChoice/safeBlocks.js";
 export {
   type CheckpointWithHex,
-  type CheckpointWithPayloadStatus,
   ForkChoiceStore,
   type IForkChoiceStore,
   type JustifiedBalancesGetter,

package/src/protoArray/protoArray.ts

@@ -111,7 +111,7 @@ export class ProtoArray {
 
     // Anchor block PTC votes must be all-true per spec get_forkchoice_store:
     // payload_timeliness_vote={anchor_root: Vector[boolean, PTC_SIZE](True for _ in range(PTC_SIZE))}
-    // Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.4/specs/gloas/fork-choice.md#modified-get_forkchoice_store
+    // Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.5/specs/gloas/fork-choice.md#modified-get_forkchoice_store
     if (protoArray.ptcVotes.has(block.blockRoot)) {
       protoArray.ptcVotes.set(block.blockRoot, BitArray.fromBoolArray(Array.from({length: PTC_SIZE}, () => true)));
     }
@@ -362,9 +362,15 @@ export class ProtoArray {
         continue;
       }
 
-      const currentBoost = proposerBoost && proposerBoost.root === node.blockRoot ? proposerBoost.score : 0;
+      // For Gloas blocks, PENDING/EMPTY/FULL all share the same blockRoot.
+      // Only apply proposer boost to PENDING (for Gloas) or FULL (for pre-Gloas) — to avoid
+      // double-counting the boost across variants during delta back-propagation, and to keep
+      // the boost neutral with respect to EMPTY vs FULL selection.
+      const isBoostVariant = isGloasBlock(node) ? node.payloadStatus === PayloadStatus.PENDING : true; // pre-Gloas has only FULL, always boost
+      const currentBoost =
+        proposerBoost && proposerBoost.root === node.blockRoot && isBoostVariant ? proposerBoost.score : 0;
       const previousBoost =
-        this.previousProposerBoost && this.previousProposerBoost.root === node.blockRoot
+        this.previousProposerBoost && this.previousProposerBoost.root === node.blockRoot && isBoostVariant
           ? this.previousProposerBoost.score
           : 0;
 
@@ -549,7 +555,6 @@ export class ProtoArray {
     currentSlot: Slot,
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
-    executionPayloadStateRoot: RootHex,
     proposerBoostRoot: RootHex | null,
     executionStatus: PayloadExecutionStatus
   ): void {
@@ -605,7 +610,6 @@ export class ProtoArray {
       executionStatus,
       executionPayloadBlockHash,
       executionPayloadNumber,
-      stateRoot: executionPayloadStateRoot,
     };
 
     const fullIndex = this.nodes.length;
@@ -684,7 +688,7 @@ export class ProtoArray {
    * Determine if we should extend the payload (prefer FULL over EMPTY)
    * Spec: gloas/fork-choice.md#new-should_extend_payload
    *
-   * Returns true if:
+   * Returns true if payload is verified (FULL variant exists) AND:
    * 1. Payload is timely, OR
    * 2. No proposer boost root (empty/zero hash), OR
    * 3. Proposer boost root's parent is not this block, OR
@@ -694,6 +698,10 @@ export class ProtoArray {
    * @param proposerBoostRoot - Current proposer boost root (from ForkChoice)
    */
   shouldExtendPayload(blockRoot: RootHex, proposerBoostRoot: RootHex | null): boolean {
+    if (!this.hasPayload(blockRoot)) {
+      return false;
+    }
+
     // Condition 1: Payload is timely
     if (this.isPayloadTimely(blockRoot)) {
       return true;
@@ -1486,9 +1494,16 @@ export class ProtoArray {
    */
   private getParentNodeIndex(node: ProtoNode): number | undefined {
     if (isGloasBlock(node)) {
-      // Use getParentPayloadStatus for Gloas blocks to get correct EMPTY/FULL variant
-      const parentPayloadStatus = this.getParentPayloadStatus(node);
-      return this.getNodeIndexByRootAndStatus(node.parentRoot, parentPayloadStatus);
+      // Traversal may reach the finalized ProtoBlock, should not throw error in that case
+      try {
+        const parentPayloadStatus = this.getParentPayloadStatus(node);
+        return this.getNodeIndexByRootAndStatus(node.parentRoot, parentPayloadStatus);
+      } catch (e) {
+        if (e instanceof ProtoArrayError && e.type.code === ProtoArrayErrorCode.UNKNOWN_PARENT_BLOCK) {
+          return undefined;
+        }
+        throw e;
+      }
     }
     // Simple parent traversal for pre-Gloas blocks (includes fork transition)
     return node.parent;
@@ -1642,10 +1657,9 @@ export class ProtoArray {
     const ancestors: ProtoNode[] = [];
     const nonAncestors: ProtoNode[] = [];
 
-    // Include starting node if it's not PENDING (i.e., pre-Gloas or EMPTY/FULL variant post-Gloas)
-    if (node.payloadStatus !== PayloadStatus.PENDING) {
-      ancestors.push(node);
-    }
+    // caller of this method may pass default status
+    // this is the only node that we accept PENDING
+    ancestors.push(node);
 
     let nodeIndex = startIndex;
     while (node.parent !== undefined) {