@lodestar/fork-choice 1.42.0-dev.4411584fd8 → 1.42.0-dev.47afaa6bb7

package/src/forkChoice/forkChoice.ts

@@ -1,20 +1,18 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
-  CachedBeaconStateGloas,
   DataAvailabilityStatus,
   EffectiveBalanceIncrements,
+  IBeaconStateView,
   ZERO_HASH,
   computeEpochAtSlot,
   computeSlotsSinceEpochStart,
   computeStartSlotAtEpoch,
   getAttesterSlashableIndices,
   isExecutionBlockBodyType,
-  isExecutionEnabled,
-  isExecutionStateType,
+  isStatePostBellatrix,
+  isStatePostGloas,
 } from "@lodestar/state-transition";
-import {computeUnrealizedCheckpoints} from "@lodestar/state-transition/epoch";
 import {
   AttesterSlashing,
   BeaconBlock,
@@ -33,11 +31,12 @@ import {ForkChoiceMetrics} from "../metrics.js";
 import {computeDeltas} from "../protoArray/computeDeltas.js";
 import {ProtoArrayError, ProtoArrayErrorCode} from "../protoArray/errors.js";
 import {
+  BlockExecutionStatus,
   ExecutionStatus,
   HEX_ZERO_HASH,
   LVHExecResponse,
-  MaybeValidExecutionStatus,
   NULL_VOTE_INDEX,
+  PayloadExecutionStatus,
   PayloadStatus,
   ProtoBlock,
   ProtoNode,
@@ -586,10 +585,10 @@ export class ForkChoice implements IForkChoice {
    */
   onBlock(
     block: BeaconBlock,
-    state: CachedBeaconStateAllForks,
+    state: IBeaconStateView,
     blockDelaySec: number,
     currentSlot: Slot,
-    executionStatus: MaybeValidExecutionStatus,
+    executionStatus: BlockExecutionStatus,
     dataAvailabilityStatus: DataAvailabilityStatus
   ): ProtoBlock {
     const {parentRoot, slot} = block;
@@ -672,12 +671,16 @@ export class ForkChoice implements IForkChoice {
     }
 
     // Get justified checkpoint with payload status for Gloas
-    const justifiedPayloadStatus = getCheckpointPayloadStatus(state, state.currentJustifiedCheckpoint.epoch);
+    const justifiedPayloadStatus = getCheckpointPayloadStatus(
+      this.config,
+      state,
+      state.currentJustifiedCheckpoint.epoch
+    );
     const justifiedCheckpoint = toCheckpointWithPayload(state.currentJustifiedCheckpoint, justifiedPayloadStatus);
     const stateJustifiedEpoch = justifiedCheckpoint.epoch;
 
     // Get finalized checkpoint with payload status for Gloas
-    const finalizedPayloadStatus = getCheckpointPayloadStatus(state, state.finalizedCheckpoint.epoch);
+    const finalizedPayloadStatus = getCheckpointPayloadStatus(this.config, state, state.finalizedCheckpoint.epoch);
     const finalizedCheckpoint = toCheckpointWithPayload(state.finalizedCheckpoint, finalizedPayloadStatus);
 
     // Justified balances for `justifiedCheckpoint` are new to the fork-choice. Compute them on demand only if
@@ -710,6 +713,7 @@ export class ForkChoice implements IForkChoice {
         // 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
         );
@@ -721,6 +725,7 @@ export class ForkChoice implements IForkChoice {
         };
         // Get payload status for unrealized finalized checkpoint
         const unrealizedFinalizedPayloadStatus = getCheckpointPayloadStatus(
+          this.config,
           state,
           parentBlock.unrealizedFinalizedEpoch
         );
@@ -732,9 +737,10 @@ export class ForkChoice implements IForkChoice {
         };
       } else {
         // compute new, happens 2/3 first blocks of epoch as monitored in mainnet
-        const unrealized = computeUnrealizedCheckpoints(state);
+        const unrealized = state.computeUnrealizedCheckpoints();
         // Get payload status for unrealized justified checkpoint
         const unrealizedJustifiedPayloadStatus = getCheckpointPayloadStatus(
+          this.config,
           state,
           unrealized.justifiedCheckpoint.epoch
         );
@@ -744,6 +750,7 @@ export class ForkChoice implements IForkChoice {
         );
         // Get payload status for unrealized finalized checkpoint
         const unrealizedFinalizedPayloadStatus = getCheckpointPayloadStatus(
+          this.config,
           state,
           unrealized.finalizedCheckpoint.epoch
         );
@@ -771,7 +778,7 @@ export class ForkChoice implements IForkChoice {
     }
 
     const targetSlot = computeStartSlotAtEpoch(blockEpoch);
-    const targetRoot = slot === targetSlot ? blockRoot : state.blockRoots.get(targetSlot % SLOTS_PER_HISTORICAL_ROOT);
+    const targetRoot = slot === targetSlot ? blockRoot : state.getBlockRootAtSlot(targetSlot);
 
     // This does not apply a vote to the block, it just makes fork choice aware of the block so
     // it can still be identified as the head even if it doesn't have any votes.
@@ -820,7 +827,10 @@ export class ForkChoice implements IForkChoice {
             executionStatus: this.getPostGloasExecStatus(executionStatus),
             dataAvailabilityStatus,
           }
-        : isExecutionBlockBodyType(block.body) && isExecutionStateType(state) && isExecutionEnabled(state, block)
+        : isExecutionBlockBodyType(block.body) &&
+            isStatePostBellatrix(state) &&
+            state.isExecutionStateType &&
+            state.isExecutionEnabled(block)
           ? {
               executionPayloadBlockHash: toRootHex(block.body.executionPayload.blockHash),
               executionPayloadNumber: block.body.executionPayload.blockNumber,
@@ -834,10 +844,6 @@ export class ForkChoice implements IForkChoice {
             }),
 
       payloadStatus: isGloasBeaconBlock(block) ? PayloadStatus.PENDING : PayloadStatus.FULL,
-      builderIndex: isGloasBeaconBlock(block) ? block.body.signedExecutionPayloadBid.message.builderIndex : null,
-      blockHashFromBid: isGloasBeaconBlock(block)
-        ? toRootHex(block.body.signedExecutionPayloadBid.message.blockHash)
-        : null,
       parentBlockHash: parentHashHex,
     };
 
@@ -977,7 +983,8 @@ export class ForkChoice implements IForkChoice {
     blockRoot: RootHex,
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
-    executionPayloadStateRoot: RootHex
+    executionPayloadStateRoot: RootHex,
+    executionStatus: PayloadExecutionStatus
   ): void {
     this.protoArray.onExecutionPayload(
       blockRoot,
@@ -985,7 +992,8 @@ export class ForkChoice implements IForkChoice {
       executionPayloadBlockHash,
       executionPayloadNumber,
       executionPayloadStateRoot,
-      this.proposerBoostRoot
+      this.proposerBoostRoot,
+      executionStatus
     );
   }
 
@@ -1043,19 +1051,34 @@ export class ForkChoice implements IForkChoice {
   }
 
   /**
-   * Same to hasBlock but without checking if the block is a descendant of the finalized root.
+   * Same as hasBlock but without checking if the block is a descendant of the finalized root.
    */
   hasBlockUnsafe(blockRoot: Root): boolean {
     return this.hasBlockHexUnsafe(toRootHex(blockRoot));
   }
 
   /**
-   * Same to hasBlockHex but without checking if the block is a descendant of the finalized root.
+   * Same as hasBlockHex but without checking if the block is a descendant of the finalized root.
    */
   hasBlockHexUnsafe(blockRoot: RootHex): boolean {
     return this.protoArray.hasBlock(blockRoot);
   }
 
+  /**
+   * Returns true if the FULL payload variant (execution payload envelope) exists for this block root,
+   * without checking if the block is a descendant of the finalized root.
+   */
+  hasPayloadUnsafe(blockRoot: Root): boolean {
+    return this.hasPayloadHexUnsafe(toRootHex(blockRoot));
+  }
+
+  /**
+   * Same as hasPayloadUnsafe but accepts a hex-encoded block root.
+   */
+  hasPayloadHexUnsafe(blockRoot: RootHex): boolean {
+    return this.protoArray.hasPayload(blockRoot);
+  }
+
   /**
    * Returns a MUTABLE `ProtoBlock` if the block is known **and** a descendant of the finalized root.
    */
@@ -1425,7 +1448,7 @@ export class ForkChoice implements IForkChoice {
     return secFromSlot * 1000 <= proposerReorgCutoff;
   }
 
-  private getPreMergeExecStatus(executionStatus: MaybeValidExecutionStatus): ExecutionStatus.PreMerge {
+  private getPreMergeExecStatus(executionStatus: BlockExecutionStatus): ExecutionStatus.PreMerge {
     if (executionStatus !== ExecutionStatus.PreMerge)
       throw Error(`Invalid pre-merge execution status: expected: ${ExecutionStatus.PreMerge}, got ${executionStatus}`);
     return executionStatus;
@@ -1440,7 +1463,7 @@ export class ForkChoice implements IForkChoice {
   }
 
   private getPreGloasExecStatus(
-    executionStatus: MaybeValidExecutionStatus
+    executionStatus: BlockExecutionStatus
   ): ExecutionStatus.Valid | ExecutionStatus.Syncing {
     if (executionStatus === ExecutionStatus.PreMerge || executionStatus === ExecutionStatus.PayloadSeparated)
       throw Error(
@@ -1449,7 +1472,7 @@ export class ForkChoice implements IForkChoice {
     return executionStatus;
   }
 
-  private getPostGloasExecStatus(executionStatus: MaybeValidExecutionStatus): ExecutionStatus.PayloadSeparated {
+  private getPostGloasExecStatus(executionStatus: BlockExecutionStatus): ExecutionStatus.PayloadSeparated {
     if (executionStatus !== ExecutionStatus.PayloadSeparated)
       throw Error(
         `Invalid post-gloas execution status: expected: ${ExecutionStatus.PayloadSeparated}, got ${executionStatus}`
@@ -1673,6 +1696,20 @@ export class ForkChoice implements IForkChoice {
       });
     }
 
+    // If attesting for a full node, the payload must be known
+    if (isGloasBlock(block) && attestationData.index === 1) {
+      const fullNodeIndex = this.protoArray.getNodeIndexByRootAndStatus(beaconBlockRootHex, PayloadStatus.FULL);
+      if (fullNodeIndex === undefined) {
+        throw new ForkChoiceError({
+          code: ForkChoiceErrorCode.INVALID_ATTESTATION,
+          err: {
+            code: InvalidAttestationCode.UNKNOWN_PAYLOAD_STATUS,
+            beaconBlockRoot: beaconBlockRootHex,
+          },
+        });
+      }
+    }
+
     this.validatedAttestationDatas.add(attDataRoot);
   }
 
@@ -1855,24 +1892,31 @@ export function getCommitteeFraction(
  * 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(state: CachedBeaconStateAllForks, checkpointEpoch: number): PayloadStatus {
+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 = state.config.getForkSeq(checkpointSlot);
+  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 gloasState = state as CachedBeaconStateGloas;
-  const payloadAvailable = gloasState.executionPayloadAvailability.get(checkpointSlot % SLOTS_PER_HISTORICAL_ROOT);
+  const payloadAvailable = state.executionPayloadAvailability.get(checkpointSlot % SLOTS_PER_HISTORICAL_ROOT);
 
   return payloadAvailable ? PayloadStatus.FULL : PayloadStatus.EMPTY;
 }

package/src/forkChoice/interface.ts

@@ -1,12 +1,9 @@
-import {
-  CachedBeaconStateAllForks,
-  DataAvailabilityStatus,
-  EffectiveBalanceIncrements,
-} from "@lodestar/state-transition";
+import {DataAvailabilityStatus, EffectiveBalanceIncrements, IBeaconStateView} from "@lodestar/state-transition";
 import {AttesterSlashing, BeaconBlock, Epoch, IndexedAttestation, Root, RootHex, Slot} from "@lodestar/types";
 import {
+  BlockExecutionStatus,
   LVHExecResponse,
-  MaybeValidExecutionStatus,
+  PayloadExecutionStatus,
   PayloadStatus,
   ProtoBlock,
   ProtoNode,
@@ -144,10 +141,10 @@ export interface IForkChoice {
    */
   onBlock(
     block: BeaconBlock,
-    state: CachedBeaconStateAllForks,
+    state: IBeaconStateView,
     blockDelaySec: number,
     currentSlot: Slot,
-    executionStatus: MaybeValidExecutionStatus,
+    executionStatus: BlockExecutionStatus,
     dataAvailabilityStatus: DataAvailabilityStatus
   ): ProtoBlock;
   /**
@@ -207,7 +204,8 @@ export interface IForkChoice {
     blockRoot: RootHex,
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
-    executionPayloadStateRoot: RootHex
+    executionPayloadStateRoot: RootHex,
+    executionStatus: PayloadExecutionStatus
   ): void;
   /**
    * Call `onTick` for all slots between `fcStore.getCurrentSlot()` and the provided `currentSlot`.
@@ -228,6 +226,12 @@ export interface IForkChoice {
    */
   hasBlockUnsafe(blockRoot: Root): boolean;
   hasBlockHexUnsafe(blockRoot: RootHex): boolean;
+  /**
+   * Returns true if the FULL payload variant (execution payload envelope) exists for this block root,
+   * without checking if the block is a descendant of the finalized root.
+   */
+  hasPayloadUnsafe(blockRoot: Root): boolean;
+  hasPayloadHexUnsafe(blockRoot: RootHex): boolean;
   getSlotsPresent(windowStart: number): number;
   /**
    * Returns a `ProtoBlock` if the block is known **and** a descendant of the finalized root.

package/src/forkChoice/store.ts

@@ -1,4 +1,4 @@
-import {CachedBeaconStateAllForks, EffectiveBalanceIncrements} from "@lodestar/state-transition";
+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";
@@ -30,7 +30,7 @@ export type JustifiedBalances = EffectiveBalanceIncrements;
  */
 export type JustifiedBalancesGetter = (
   checkpoint: CheckpointWithPayloadStatus,
-  blockState: CachedBeaconStateAllForks
+  blockState: IBeaconStateView
 ) => JustifiedBalances;
 
 /**

package/src/index.ts

@@ -31,10 +31,11 @@ export {
 } from "./forkChoice/store.js";
 export {type ForkChoiceMetrics, getForkChoiceMetrics} from "./metrics.js";
 export type {
+  BlockExecutionStatus,
   BlockExtraMeta,
   LVHInvalidResponse,
   LVHValidResponse,
-  MaybeValidExecutionStatus,
+  PayloadExecutionStatus,
   ProtoBlock,
   ProtoNode,
 } from "./protoArray/interface.js";

package/src/protoArray/interface.ts

@@ -64,7 +64,18 @@ export type LVHInvalidResponse = {
 };
 export type LVHExecResponse = LVHValidResponse | LVHInvalidResponse;
 
-export type MaybeValidExecutionStatus = Exclude<ExecutionStatus, ExecutionStatus.Invalid>;
+/**
+ * Any execution status that is not definitively invalid.
+ * Pre-Gloas: Valid | Syncing | PreMerge
+ * Post-Gloas: execution status must be PayloadSeparated (beacon block imported before its payload arrives via SignedExecutionPayloadEnvelope)
+ */
+export type BlockExecutionStatus = Exclude<ExecutionStatus, ExecutionStatus.Invalid>;
+
+/**
+ * Execution status for a block whose execution payload is present and has been submitted to the EL.
+ * Used post-Gloas when transitioning a PayloadSeparated block to FULL via onExecutionPayload().
+ */
+export type PayloadExecutionStatus = ExecutionStatus.Valid | ExecutionStatus.Syncing;
 
 export type BlockExtraMeta =
   | {
@@ -127,12 +138,6 @@ export type ProtoBlock = BlockExtraMeta & {
   /** Payload status for this node (Gloas fork). Always FULL in pre-gloas */
   payloadStatus: PayloadStatus;
 
-  // GLOAS: The followings are from bids. They are null in pre-gloas
-  // Used for execution payload gossip validation
-  builderIndex: number | null;
-  // Used for execution payload gossip validation. Not to be confused with executionPayloadBlockHash
-  blockHashFromBid: RootHex | null;
-
   // Used to determine if this block extends EMPTY or FULL parent variant
   // Spec: gloas/fork-choice.md#new-get_parent_payload_status
   parentBlockHash: RootHex | null;

package/src/protoArray/protoArray.ts

@@ -9,6 +9,7 @@ import {
   ExecutionStatus,
   HEX_ZERO_HASH,
   LVHExecResponse,
+  PayloadExecutionStatus,
   PayloadStatus,
   ProtoBlock,
   ProtoNode,
@@ -107,6 +108,14 @@ export class ProtoArray {
       currentSlot,
       null
     );
+
+    // 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
+    if (protoArray.ptcVotes.has(block.blockRoot)) {
+      protoArray.ptcVotes.set(block.blockRoot, BitArray.fromBoolArray(Array.from({length: PTC_SIZE}, () => true)));
+    }
+
     return protoArray;
   }
 
@@ -541,7 +550,8 @@ export class ProtoArray {
     executionPayloadBlockHash: RootHex,
     executionPayloadNumber: number,
     executionPayloadStateRoot: RootHex,
-    proposerBoostRoot: RootHex | null
+    proposerBoostRoot: RootHex | null,
+    executionStatus: PayloadExecutionStatus
   ): void {
     // First check if block exists
     const variants = this.indices.get(blockRoot);
@@ -591,7 +601,8 @@ export class ProtoArray {
       weight: 0,
       bestChild: undefined,
       bestDescendant: undefined,
-      executionStatus: ExecutionStatus.Valid,
+      // TODO GLOAS: handle optimistic sync
+      executionStatus,
       executionPayloadBlockHash,
       executionPayloadNumber,
       stateRoot: executionPayloadStateRoot,
@@ -650,9 +661,7 @@ export class ProtoArray {
     }
 
     // If payload is not locally available, it's not timely
-    // In our implementation, payload is locally available if proto array has FULL variant of the block
-    const fullNodeIndex = this.getNodeIndexByRootAndStatus(blockRoot, PayloadStatus.FULL);
-    if (fullNodeIndex === undefined) {
+    if (!this.hasPayload(blockRoot)) {
       return false;
     }
 
@@ -1059,10 +1068,8 @@ export class ProtoArray {
       });
     }
 
-    // Find the minimum index among all variants to ensure we don't prune too much
-    const finalizedIndex = Array.isArray(variants)
-      ? Math.min(...variants.filter((idx) => idx !== undefined))
-      : variants;
+    // For Gloas, PENDING variant (index 0) is always the smallest since it's inserted first
+    const finalizedIndex = Array.isArray(variants) ? variants[PayloadStatus.PENDING] : variants;
 
     if (finalizedIndex < this.pruneThreshold) {
       // Pruning at small numbers incurs more cost than benefit
@@ -1672,6 +1679,16 @@ export class ProtoArray {
     return this.getDefaultNodeIndex(blockRoot) !== undefined;
   }
 
+  /**
+   * Check if a FULL payload variant (execution payload envelope) exists for this block root.
+   * Returns true once the SignedExecutionPayloadEnvelope for this block has been received and processed.
+   */
+  hasPayload(blockRoot: RootHex): boolean {
+    // we should also make sure this blockRoot is a gloas block, however we only call this function
+    // starting from GLOAS_FORK_EPOCH, so we can assume the blockRoot is from gloas block
+    return this.getNodeIndexByRootAndStatus(blockRoot, PayloadStatus.FULL) !== undefined;
+  }
+
   /**
    * Return ProtoNode for blockRoot with explicit payload status
    *