@lodestar/beacon-node 1.43.0-dev.aef3645690 → 1.43.0-dev.b05ea98d04

package/src/chain/regen/interface.ts

@@ -2,7 +2,7 @@ import {routes} from "@lodestar/api";
 import {ProtoBlock} from "@lodestar/fork-choice";
 import {IBeaconStateView} from "@lodestar/state-transition";
 import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
-import {CheckpointHexPayload} from "../stateCache/types.js";
+import {CheckpointHex} from "../stateCache/types.js";
 
 export enum RegenCaller {
   getDuties = "getDuties",
@@ -21,6 +21,7 @@ export enum RegenCaller {
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
   validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
+  validateGossipProposerPreferences = "validateGossipProposerPreferences",
   onForkChoiceFinalized = "onForkChoiceFinalized",
   restApi = "restApi",
 }
@@ -40,21 +41,15 @@ export interface IStateRegenerator extends IStateRegeneratorInternal {
   dumpCacheSummary(): routes.lodestar.StateCacheItem[];
   getStateSync(stateRoot: RootHex): IBeaconStateView | null;
   getPreStateSync(block: BeaconBlock): IBeaconStateView | null;
-  getCheckpointStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null>;
-  getCheckpointStateSync(cp: CheckpointHexPayload): IBeaconStateView | null;
+  getCheckpointStateOrBytes(cp: CheckpointHex): Promise<IBeaconStateView | Uint8Array | null>;
+  getCheckpointStateSync(cp: CheckpointHex): IBeaconStateView | null;
   getClosestHeadState(head: ProtoBlock): IBeaconStateView | null;
   pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void;
   pruneOnFinalized(finalizedEpoch: Epoch): void;
-  processBlockState(blockRootHex: RootHex, postState: IBeaconStateView): void;
-  processPayloadState(payloadState: IBeaconStateView): void;
-  /**
-   * payloadPresent is true if this is payload state, false if block state.
-   * payloadPresent is always true for pre-gloas.
-   */
-  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView, payloadPresent: boolean): void;
+  processState(blockRootHex: RootHex, postState: IBeaconStateView): void;
+  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void;
   updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void;
-  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, payloadPresent: boolean): number | null;
-  upgradeForGloas(epoch: Epoch): void;
+  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
 }
 
 /**

package/src/chain/regen/queued.ts

@@ -1,11 +1,11 @@
 import {routes} from "@lodestar/api";
-import {IForkChoice, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
+import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {IBeaconStateView, computeEpochAtSlot} from "@lodestar/state-transition";
-import {BeaconBlock, Epoch, RootHex, Slot, isGloasBeaconBlock, phase0} from "@lodestar/types";
-import {Logger, fromHex, toRootHex} from "@lodestar/utils";
+import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
+import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
-import {BlockStateCache, CheckpointHexPayload, CheckpointStateCache} from "../stateCache/types.js";
+import {BlockStateCache, CheckpointHex, CheckpointStateCache} from "../stateCache/types.js";
 import {RegenError, RegenErrorCode} from "./errors.js";
 import {
   IStateRegenerator,
@@ -88,12 +88,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
    */
   getPreStateSync(block: BeaconBlock): IBeaconStateView | null {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = isGloasBeaconBlock(block)
-      ? this.forkChoice.getBlockHexAndBlockHash(
-          parentRoot,
-          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
-        )
-      : this.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = this.forkChoice.getBlockHexDefaultStatus(parentRoot);
     if (!parentBlock) {
       throw new RegenError({
         code: RegenErrorCode.BLOCK_NOT_IN_FORKCHOICE,
@@ -104,19 +99,9 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     const parentEpoch = computeEpochAtSlot(parentBlock.slot);
     const blockEpoch = computeEpochAtSlot(block.slot);
 
-    // Convert PayloadStatus to payloadPresent boolean
-    if (parentBlock.payloadStatus === PayloadStatus.PENDING) {
-      throw new RegenError({
-        code: RegenErrorCode.UNEXPECTED_PAYLOAD_STATUS,
-        blockRoot: block.parentRoot,
-        payloadStatus: parentBlock.payloadStatus,
-      });
-    }
-    const payloadPresent = parentBlock.payloadStatus === PayloadStatus.FULL;
-
     // Check the checkpoint cache (if the pre-state is a checkpoint state)
     if (parentEpoch < blockEpoch) {
-      const checkpointState = this.checkpointStateCache.getLatest(parentRoot, blockEpoch, payloadPresent);
+      const checkpointState = this.checkpointStateCache.getLatest(parentRoot, blockEpoch);
       if (checkpointState && computeEpochAtSlot(checkpointState.slot) === blockEpoch) {
         return checkpointState;
       }
@@ -135,14 +120,14 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return null;
   }
 
-  async getCheckpointStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null> {
+  async getCheckpointStateOrBytes(cp: CheckpointHex): Promise<IBeaconStateView | Uint8Array | null> {
     return this.checkpointStateCache.getStateOrBytes(cp);
   }
 
   /**
    * Get checkpoint state from cache
    */
-  getCheckpointStateSync(cp: CheckpointHexPayload): IBeaconStateView | null {
+  getCheckpointStateSync(cp: CheckpointHex): IBeaconStateView | null {
     return this.checkpointStateCache.get(cp);
   }
 
@@ -150,19 +135,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
    * Get state closest to head
    */
   getClosestHeadState(head: ProtoBlock): IBeaconStateView | null {
-    // Convert PayloadStatus to payloadPresent boolean
-    if (head.payloadStatus === PayloadStatus.PENDING) {
-      throw new RegenError({
-        code: RegenErrorCode.UNEXPECTED_PAYLOAD_STATUS,
-        blockRoot: fromHex(head.blockRoot),
-        payloadStatus: head.payloadStatus,
-      });
-    }
-    const payloadPresent = head.payloadStatus === PayloadStatus.FULL;
-    return (
-      this.checkpointStateCache.getLatest(head.blockRoot, Infinity, payloadPresent) ||
-      this.blockStateCache.get(head.stateRoot)
-    );
+    return this.checkpointStateCache.getLatest(head.blockRoot, Infinity) || this.blockStateCache.get(head.stateRoot);
   }
 
   pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void {
@@ -175,24 +148,15 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.blockStateCache.deleteAllBeforeEpoch(finalizedEpoch);
   }
 
-  processBlockState(blockRootHex: RootHex, postState: IBeaconStateView): void {
+  processState(blockRootHex: RootHex, postState: IBeaconStateView): void {
     this.blockStateCache.add(postState);
     this.checkpointStateCache.processState(blockRootHex, postState).catch((e) => {
       this.logger.debug("Error processing block state", {blockRootHex, slot: postState.slot}, e);
     });
   }
 
-  /**
-   * Process payload state for caching after importing execution payload.
-   */
-  processPayloadState(payloadState: IBeaconStateView): void {
-    // Add payload state to block state cache (keyed by payload state root)
-    this.blockStateCache.add(payloadState);
-  }
-
-  // TODO GLOAS: This should also be called when importing execution payload after we implement it
-  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView, payloadPresent: boolean): void {
-    this.checkpointStateCache.add(cp, item, payloadPresent);
+  addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void {
+    this.checkpointStateCache.add(cp, item);
   }
 
   updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void {
@@ -228,13 +192,8 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     }
   }
 
-  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, payloadPresent: boolean): number | null {
-    return this.checkpointStateCache.updatePreComputedCheckpoint(rootHex, epoch, payloadPresent);
-  }
-
-  upgradeForGloas(epoch: Epoch): void {
-    this.logger.verbose("Upgrading block state cache for Gloas fork", {epoch});
-    this.blockStateCache.upgradeToGloas();
+  updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null {
+    return this.checkpointStateCache.updatePreComputedCheckpoint(rootHex, epoch);
   }
 
   /**

package/src/chain/regen/regen.ts

@@ -1,6 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {IForkChoice, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
-import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
+import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
@@ -9,7 +9,7 @@ import {
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
 } from "@lodestar/state-transition";
-import {BeaconBlock, RootHex, SignedBeaconBlock, Slot, isGloasBeaconBlock} from "@lodestar/types";
+import {BeaconBlock, RootHex, SignedBeaconBlock, Slot} from "@lodestar/types";
 import {Logger, fromHex, toRootHex} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
 import {Metrics} from "../../metrics/index.js";
@@ -57,12 +57,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     regenCaller: RegenCaller
   ): Promise<IBeaconStateView> {
     const parentRoot = toRootHex(block.parentRoot);
-    const parentBlock = isGloasBeaconBlock(block)
-      ? this.modules.forkChoice.getBlockHexAndBlockHash(
-          parentRoot,
-          toRootHex(block.body.signedExecutionPayloadBid.message.parentBlockHash)
-        )
-      : this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
+    const parentBlock = this.modules.forkChoice.getBlockHexDefaultStatus(parentRoot);
     if (!parentBlock) {
       throw new RegenError({
         code: RegenErrorCode.BLOCK_NOT_IN_FORKCHOICE,
@@ -110,19 +105,9 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     const {checkpointStateCache} = this.modules;
     const epoch = computeEpochAtSlot(slot);
 
-    // Convert PayloadStatus to payloadPresent boolean
-    if (block.payloadStatus === PayloadStatus.PENDING) {
-      throw new RegenError({
-        code: RegenErrorCode.UNEXPECTED_PAYLOAD_STATUS,
-        blockRoot: fromHex(blockRoot),
-        payloadStatus: block.payloadStatus,
-      });
-    }
-    const payloadPresent = block.payloadStatus === PayloadStatus.FULL;
-
     const latestCheckpointStateCtx = allowDiskReload
-      ? await checkpointStateCache.getOrReloadLatest(blockRoot, epoch, payloadPresent)
-      : checkpointStateCache.getLatest(blockRoot, epoch, payloadPresent);
+      ? await checkpointStateCache.getOrReloadLatest(blockRoot, epoch)
+      : checkpointStateCache.getLatest(blockRoot, epoch);
 
     // If a checkpoint state exists with the given checkpoint root, it either is in requested epoch
     // or needs to have empty slots processed until the requested epoch
@@ -176,18 +161,9 @@ export class StateRegenerator implements IStateRegeneratorInternal {
       if (!lastBlockToReplay) continue;
       const epoch = computeEpochAtSlot(lastBlockToReplay.slot - 1);
 
-      // Convert PayloadStatus to payloadPresent boolean
-      if (b.payloadStatus === PayloadStatus.PENDING) {
-        throw new RegenError({
-          code: RegenErrorCode.INTERNAL_ERROR,
-          message: `Unexpected PENDING payloadStatus for ancestor block ${b.blockRoot} at slot ${b.slot}`,
-        });
-      }
-      const payloadPresent = b.payloadStatus === PayloadStatus.FULL;
-
       state = allowDiskReload
-        ? await checkpointStateCache.getOrReloadLatest(b.blockRoot, epoch, payloadPresent)
-        : checkpointStateCache.getLatest(b.blockRoot, epoch, payloadPresent);
+        ? await checkpointStateCache.getOrReloadLatest(b.blockRoot, epoch)
+        : checkpointStateCache.getLatest(b.blockRoot, epoch);
       if (state) {
         break;
       }
@@ -351,11 +327,6 @@ async function processSlotsByCheckpoint(
  * emitting "checkpoint" events after every epoch processed.
  *
  * Stops processing after no more full epochs can be processed.
- *
- * Output state variant:
- * - Post-Gloas: If slots are processed, returns block state (payloadPresent=false).
- *               If no slots processed, returns preState as-is (preserves variant).
- * - Pre-Gloas: Always payloadPresent=true (no block/payload distinction).
  */
 export async function processSlotsToNearestCheckpoint(
   modules: {
@@ -375,7 +346,7 @@ export async function processSlotsToNearestCheckpoint(
   const postSlot = slot;
   const preEpoch = computeEpochAtSlot(preSlot);
   let postState = preState;
-  const {config, checkpointStateCache, emitter, metrics, logger} = modules;
+  const {checkpointStateCache, emitter, metrics, logger} = modules;
   let count = 0;
 
   for (
@@ -399,11 +370,7 @@ export async function processSlotsToNearestCheckpoint(
     // This may becomes the "official" checkpoint state if the 1st block of epoch is skipped
     const checkpointState = postState;
     const cp = getCheckpointFromState(checkpointState);
-    // processSlots() only does epoch transitions, never processes payloads
-    // Pre-Gloas: payloadPresent is always true (execution payload embedded in block)
-    // Post-Gloas: result is a block state (payloadPresent=false)
-    const isPayloadPresent = config.getForkSeq(checkpointState.slot) < ForkSeq.gloas;
-    checkpointStateCache.add(cp, checkpointState, isPayloadPresent);
+    checkpointStateCache.add(cp, checkpointState);
     // consumers should not mutate state ever
     emitter?.emit(ChainEvent.checkpoint, cp, checkpointState);
 

package/src/chain/seenCache/index.ts

@@ -5,3 +5,4 @@ export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
 export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";
 export {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenPayloadEnvelopeInput.js";
+export {SeenProposerPreferences} from "./seenProposerPreferences.js";

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -1,9 +1,12 @@
-import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {ChainForkConfig} from "@lodestar/config";
+import {CheckpointWithHex, IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {RootHex} from "@lodestar/types";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
 import {SerializedCache} from "../../util/serializedCache.js";
+import {isDaOutOfRange} from "../blocks/blockInput/index.js";
 import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../emitter.js";
 
@@ -11,6 +14,9 @@ export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/ind
 export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
 
 export type SeenPayloadEnvelopeInputModules = {
+  config: ChainForkConfig;
+  clock: IClock;
+  forkChoice: IForkChoice;
   chainEvents: ChainEventEmitter;
   signal: AbortSignal;
   serializedCache: SerializedCache;
@@ -21,10 +27,20 @@ export type SeenPayloadEnvelopeInputModules = {
 /**
  * Cache for tracking PayloadEnvelopeInput instances, keyed by beacon block root.
  *
- * Created during block import when a block is processed.
- * Pruned on finalization and after payload is written to DB.
+ * Created during block import when a block is processed. Two pruning paths:
+ *   - `prepareNextSlot` calls `pruneBelow(headParentSlot)` every slot once the head we'll build
+ *     on is known.
+ *   - `onFinalized` calls `pruneBelow(finalizedSlot)` on every finalization for bulk cleanup.
+ *
+ * Steady state (linear chain, healthy progression): the cache holds ~2 entries — the head
+ * (parent for next-slot production) and its parent (proposer-boost-reorg fallback). It can
+ * transiently hold more during forks, range-sync bursts, or when `prepareNextSlot` skips
+ * ticks; subsequent ticks settle it back.
  */
 export class SeenPayloadEnvelopeInput {
+  private readonly config: ChainForkConfig;
+  private readonly clock: IClock;
+  private readonly forkChoice: IForkChoice;
   private readonly chainEvents: ChainEventEmitter;
   private readonly signal: AbortSignal;
   private readonly serializedCache: SerializedCache;
@@ -32,7 +48,19 @@ export class SeenPayloadEnvelopeInput {
   private readonly logger?: Logger;
   private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
 
-  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+  constructor({
+    config,
+    clock,
+    forkChoice,
+    chainEvents,
+    signal,
+    serializedCache,
+    metrics,
+    logger,
+  }: SeenPayloadEnvelopeInputModules) {
+    this.config = config;
+    this.clock = clock;
+    this.forkChoice = forkChoice;
     this.chainEvents = chainEvents;
     this.signal = signal;
     this.serializedCache = serializedCache;
@@ -51,14 +79,13 @@ export class SeenPayloadEnvelopeInput {
       });
     }
 
-    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     this.signal.addEventListener("abort", () => {
-      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
+      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.pruneFinalized);
     });
   }
 
-  private onFinalized = (checkpoint: CheckpointWithHex): void => {
-    // Prune all entries with slot < finalized slot
+  private pruneFinalized = (checkpoint: CheckpointWithHex): void => {
     const finalizedSlot = computeStartSlotAtEpoch(checkpoint.epoch);
     let deletedCount = 0;
     for (const [, input] of this.payloadInputs) {
@@ -67,16 +94,32 @@ export class SeenPayloadEnvelopeInput {
         deletedCount++;
       }
     }
-    this.logger?.debug("SeenPayloadEnvelopeInput.onFinalized deleted cached entries", {deletedCount});
+
+    this.logger?.debug("SeenPayloadEnvelopeInput.pruneFinalized deleted entries", {
+      finalizedSlot,
+      finalizedRoot: checkpoint.rootHex,
+      deletedCount,
+    });
   };
 
-  add(props: CreateFromBlockProps): PayloadEnvelopeInput {
-    if (this.payloadInputs.has(props.blockRootHex)) {
-      throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
+  add(props: Omit<CreateFromBlockProps, "daOutOfRange">): PayloadEnvelopeInput {
+    const existing = this.payloadInputs.get(props.blockRootHex);
+    if (existing !== undefined) {
+      this.logger?.verbose("SeenPayloadEnvelopeInput.add reused existing entry", {
+        slot: existing.slot,
+        root: props.blockRootHex,
+      });
+      return existing;
     }
-    const input = PayloadEnvelopeInput.createFromBlock(props);
+    const daOutOfRange = isDaOutOfRange(this.config, props.forkName, props.block.message.slot, this.clock.currentEpoch);
+    const input = PayloadEnvelopeInput.createFromBlock({...props, daOutOfRange});
     this.payloadInputs.set(props.blockRootHex, input);
     this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    this.logger?.verbose("SeenPayloadEnvelopeInput.add created new entry", {
+      slot: input.slot,
+      root: props.blockRootHex,
+      daOutOfRange,
+    });
     return input;
   }
 
@@ -88,17 +131,25 @@ export class SeenPayloadEnvelopeInput {
     return this.payloadInputs.get(blockRootHex)?.hasPayloadEnvelope() ?? false;
   }
 
-  prune(blockRootHex: RootHex): void {
-    const payloadInput = this.payloadInputs.get(blockRootHex);
-    if (payloadInput) {
-      this.evictPayloadInput(payloadInput);
-    }
-  }
-
   size(): number {
     return this.payloadInputs.size;
   }
 
+  pruneBelowParent(parentBlock: ProtoBlock): void {
+    for (const block of this.forkChoice.getAllAncestorBlocks(parentBlock.blockRoot, parentBlock.payloadStatus)) {
+      if (block.slot < parentBlock.slot) {
+        const input = this.payloadInputs.get(block.blockRoot);
+        if (input) {
+          this.evictPayloadInput(input);
+          this.logger?.verbose("SeenPayloadEnvelopeInput.pruneBelowParent deleted", {
+            slot: block.slot,
+            root: block.blockRoot,
+          });
+        }
+      }
+    }
+  }
+
   private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {
     this.serializedCache.delete(payloadInput.getSerializedCacheKeys());
     this.payloadInputs.delete(payloadInput.blockRootHex);

package/src/chain/seenCache/seenProposerPreferences.ts

@@ -0,0 +1,32 @@
+import {RootHex, Slot, ValidatorIndex} from "@lodestar/types";
+import {MapDef} from "@lodestar/utils";
+
+/**
+ * Tracks signed proposer preferences we've already seen per (dependent_root, proposal_slot, validator_index).
+ */
+export class SeenProposerPreferences {
+  private readonly validatorByDependentRootBySlot = new MapDef<Slot, Map<RootHex, ValidatorIndex>>(
+    () => new Map<RootHex, ValidatorIndex>()
+  );
+
+  isKnown(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): boolean {
+    return this.validatorByDependentRootBySlot.get(proposalSlot)?.get(dependentRoot) === validatorIndex;
+  }
+
+  add(dependentRoot: RootHex, proposalSlot: Slot, validatorIndex: ValidatorIndex): void {
+    this.validatorByDependentRootBySlot.getOrDefault(proposalSlot).set(dependentRoot, validatorIndex);
+  }
+
+  /**
+   * Entries are only load-bearing while `proposal_slot > current_slot`. Once the slot has
+   * passed the `[IGNORE] proposal_slot > current_slot` gossip rule takes over, so drop them
+   * on each slot tick.
+   */
+  prune(currentSlot: Slot): void {
+    for (const slot of this.validatorByDependentRootBySlot.keys()) {
+      if (slot < currentSlot) {
+        this.validatorByDependentRootBySlot.delete(slot);
+      }
+    }
+  }
+}

package/src/chain/stateCache/datastore/db.ts

@@ -1,6 +1,6 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {Epoch, phase0, ssz} from "@lodestar/types";
-import {MapDef, byteArrayEquals} from "@lodestar/utils";
+import {MapDef} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/interface.js";
 import {
   getLastProcessedSlotFromBeaconStateSerialized,
@@ -14,8 +14,8 @@ import {CPStateDatastore, DatastoreKey} from "./types.js";
 export class DbCPStateDatastore implements CPStateDatastore {
   constructor(private readonly db: IBeaconDb) {}
 
-  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
-    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array): Promise<DatastoreKey> {
+    const serializedCheckpoint = checkpointToDatastoreKey(cpKey);
     await this.db.checkpointState.putBinary(serializedCheckpoint, stateBytes);
     return serializedCheckpoint;
   }
@@ -40,30 +40,18 @@ export class DbCPStateDatastore implements CPStateDatastore {
   }
 }
 
-function extractCheckpointBytes(key: DatastoreKey): Uint8Array {
-  const fixedSize = ssz.phase0.Checkpoint.minSize;
-  return key.subarray(0, fixedSize);
-}
-
 export function datastoreKeyToCheckpoint(key: DatastoreKey): phase0.Checkpoint {
-  return ssz.phase0.Checkpoint.deserialize(extractCheckpointBytes(key));
-}
-
-export function checkpointToDatastoreKey(cp: phase0.Checkpoint, payloadPresent: boolean): DatastoreKey {
-  const cpBytes = ssz.phase0.Checkpoint.serialize(cp);
-  const key = new Uint8Array(cpBytes.length + 1);
-  key.set(cpBytes);
-  key[cpBytes.length] = payloadPresent ? 1 : 0;
-  return key;
+  return ssz.phase0.Checkpoint.deserialize(key);
 }
 
-function isPayloadCheckpointState(key: DatastoreKey): boolean {
-  return key.at(-1) === 1;
+export function checkpointToDatastoreKey(cp: phase0.Checkpoint): DatastoreKey {
+  return ssz.phase0.Checkpoint.serialize(cp);
 }
 
 /**
- * Get the latest "safe" checkpoint state the node can use to boot from
- *   - its last processed block slot should be at epoch boundary (CRCS) or last slot of previous epoch (PRCS)
+ * Get the latest safe checkpoint state the node can use to boot from
+ *   - it should be the checkpoint state that's unique in its epoch
+ *   - its last processed block slot should be at epoch boundary or last slot of previous epoch
  *   - state slot should be at epoch boundary
  *   - state slot should be equal to epoch * SLOTS_PER_EPOCH
  *
@@ -82,20 +70,9 @@ export async function getLatestSafeDatastoreKey(
 
   const dataStoreKeyByEpoch: Map<Epoch, DatastoreKey> = new Map();
   for (const [epoch, keys] of checkpointsByEpoch.entries()) {
+    // only consider epochs with a single checkpoint to avoid ambiguity from forks
     if (keys.length === 1) {
-      // PRCS (skipped slot) or CRCS and no payloadPresent
-      // Pre-gloas always fall into this case
       dataStoreKeyByEpoch.set(epoch, keys[0]);
-    } else if (keys.length === 2) {
-      // CRCS without payload and CRCS with payload
-      // ie Two keys for the same checkpoint with different payloadPresent suffix (FULL/EMPTY)
-      // TODO GLOAS: Here we pick FULL key, there is a chance that payload is orphaned hence we not be able to sync
-      const cp0 = extractCheckpointBytes(keys[0]);
-      const cp1 = extractCheckpointBytes(keys[1]);
-      if (byteArrayEquals(cp0, cp1)) {
-        const fullKey = isPayloadCheckpointState(keys[0]) ? keys[0] : keys[1];
-        dataStoreKeyByEpoch.set(epoch, fullKey);
-      }
     }
   }
 

package/src/chain/stateCache/datastore/file.ts

@@ -1,13 +1,12 @@
 import path from "node:path";
-import {phase0} from "@lodestar/types";
+import {phase0, ssz} from "@lodestar/types";
 import {fromHex, toHex} from "@lodestar/utils";
 import {ensureDir, readFile, readFileNames, removeFile, writeIfNotExist} from "../../../util/file.js";
-import {checkpointToDatastoreKey, getLatestSafeDatastoreKey} from "./db.js";
+import {getLatestSafeDatastoreKey} from "./db.js";
 import {CPStateDatastore, DatastoreKey} from "./types.js";
 
 const CHECKPOINT_STATES_FOLDER = "checkpoint_states";
-/** 41 bytes (40 checkpoint + 1 payloadPresent) = 82 hex chars + "0x" prefix = 84 */
-const CHECKPOINT_FILE_NAME_LENGTH = 84;
+const CHECKPOINT_FILE_NAME_LENGTH = 82;
 
 /**
  * Implementation of CPStateDatastore using file system, this is beneficial for debugging.
@@ -29,8 +28,8 @@ export class FileCPStateDatastore implements CPStateDatastore {
     }
   }
 
-  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
-    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array): Promise<DatastoreKey> {
+    const serializedCheckpoint = ssz.phase0.Checkpoint.serialize(cpKey);
     const filePath = path.join(this.folderPath, toHex(serializedCheckpoint));
     await writeIfNotExist(filePath, stateBytes);
     return serializedCheckpoint;

package/src/chain/stateCache/datastore/types.ts

@@ -1,12 +1,11 @@
 import {phase0} from "@lodestar/types";
 
-// With db implementation, persistedKey is serialized data of a checkpoint + 1
-// ie a fixed size of `ssz.phase0.Checkpoint.minSize + 1`
+// With db implementation, persistedKey is serialized data of a checkpoint
 export type DatastoreKey = Uint8Array;
 
 // Make this generic to support testing
 export interface CPStateDatastore {
-  write: (cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean) => Promise<DatastoreKey>;
+  write: (cpKey: phase0.Checkpoint, stateBytes: Uint8Array) => Promise<DatastoreKey>;
   remove: (key: DatastoreKey) => Promise<void>;
   read: (key: DatastoreKey) => Promise<Uint8Array | null>;
   readLatestSafe: () => Promise<Uint8Array | null>;

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -20,11 +20,6 @@ export type FIFOBlockStateCacheOpts = {
  *                                                                                             clock slot
  */
 export const DEFAULT_MAX_BLOCK_STATES = 64;
-/**
- * For Gloas (ePBS), each block can have two states: block state and payload state.
- * Double the cache size to maintain the same effective block depth.
- */
-export const DEFAULT_MAX_BLOCK_STATES_GLOAS = 128;
 
 /**
  * New implementation of BlockStateCache that keeps the most recent n states consistently
@@ -46,7 +41,7 @@ export const DEFAULT_MAX_BLOCK_STATES_GLOAS = 128;
  * The maintained key order would be: 11 -> 13 -> 12 -> 10, and state 10 will be pruned first.
  */
 export class FIFOBlockStateCache implements BlockStateCache {
-  private maxStates: number;
+  readonly maxStates: number;
 
   private readonly cache: MapTracker<string, IBeaconStateView>;
   /**
@@ -172,10 +167,6 @@ export class FIFOBlockStateCache implements BlockStateCache {
     }
   }
 
-  upgradeToGloas(): void {
-    this.maxStates = DEFAULT_MAX_BLOCK_STATES_GLOAS;
-  }
-
   /**
    * No need for this implementation
    * This is only to conform to the old api