@lodestar/beacon-node 1.41.0 → 1.42.0-dev.1d50253953

package/src/chain/regen/regen.ts

@@ -1,6 +1,6 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
-import {SLOTS_PER_EPOCH} from "@lodestar/params";
+import {IForkChoice, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
+import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
   DataAvailabilityStatus,
@@ -111,9 +111,20 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     const {blockRoot} = block;
     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)
-      : checkpointStateCache.getLatest(blockRoot, epoch);
+      ? await checkpointStateCache.getOrReloadLatest(blockRoot, epoch, payloadPresent)
+      : checkpointStateCache.getLatest(blockRoot, epoch, payloadPresent);
 
     // 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
@@ -166,9 +177,19 @@ export class StateRegenerator implements IStateRegeneratorInternal {
       const lastBlockToReplay = blocksToReplay.at(-1);
       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)
-        : checkpointStateCache.getLatest(b.blockRoot, epoch);
+        ? await checkpointStateCache.getOrReloadLatest(b.blockRoot, epoch, payloadPresent)
+        : checkpointStateCache.getLatest(b.blockRoot, epoch, payloadPresent);
       if (state) {
         break;
       }
@@ -332,6 +353,11 @@ 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: {
@@ -374,7 +400,11 @@ 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);
-    checkpointStateCache.add(cp, 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 = checkpointState.config.getForkSeq(checkpointState.slot) < ForkSeq.gloas;
+    checkpointStateCache.add(cp, checkpointState, isPayloadPresent);
     // consumers should not mutate state ever
     emitter?.emit(ChainEvent.checkpoint, cp, checkpointState);
 

package/src/chain/seenCache/index.ts

@@ -3,5 +3,5 @@ export {SeenBlockProposers} from "./seenBlockProposers.js";
 export {SeenSyncCommitteeMessages} from "./seenCommittee.js";
 export {SeenContributionAndProof} from "./seenCommitteeContribution.js";
 export {SeenExecutionPayloadBids} from "./seenExecutionPayloadBids.js";
-export {SeenExecutionPayloadEnvelopes} from "./seenExecutionPayloadEnvelope.js";
 export {SeenBlockInput} from "./seenGossipBlockInput.js";
+export {PayloadEnvelopeInput, SeenPayloadEnvelopeInput} from "./seenPayloadEnvelopeInput.js";

package/src/chain/seenCache/seenGossipBlockInput.ts

@@ -180,7 +180,7 @@ export class SeenBlockInput {
       blockInput = this.blockInputs.get(parentRootHex ?? "");
       parentRootHex = blockInput?.parentRootHex;
     }
-    this.logger?.debug(`BlockInputCache.prune deleted ${deletedCount} cached BlockInputs`);
+    this.logger?.debug("BlockInputCache.prune deleted cached BlockInputs", {deletedCount});
     this.pruneToMaxSize();
   }
 
@@ -193,7 +193,7 @@ export class SeenBlockInput {
         this.evictBlockInput(blockInput);
       }
     }
-    this.logger?.debug(`BlockInputCache.onFinalized deleted ${deletedCount} cached BlockInputs`);
+    this.logger?.debug("BlockInputCache.onFinalized deleted cached BlockInputs", {deletedCount});
     this.pruneToMaxSize();
   };
 

package/src/chain/seenCache/seenPayloadEnvelopeInput.ts

@@ -0,0 +1,106 @@
+import {CheckpointWithHex} 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 {SerializedCache} from "../../util/serializedCache.js";
+import {CreateFromBlockProps, PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+import {ChainEvent, ChainEventEmitter} from "../emitter.js";
+
+export type {PayloadEnvelopeInputState} from "../blocks/payloadEnvelopeInput/index.js";
+export {PayloadEnvelopeInput} from "../blocks/payloadEnvelopeInput/index.js";
+
+export type SeenPayloadEnvelopeInputModules = {
+  chainEvents: ChainEventEmitter;
+  signal: AbortSignal;
+  serializedCache: SerializedCache;
+  metrics: Metrics | null;
+  logger?: Logger;
+};
+
+/**
+ * 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.
+ */
+export class SeenPayloadEnvelopeInput {
+  private readonly chainEvents: ChainEventEmitter;
+  private readonly signal: AbortSignal;
+  private readonly serializedCache: SerializedCache;
+  private readonly metrics: Metrics | null;
+  private readonly logger?: Logger;
+  private payloadInputs = new Map<RootHex, PayloadEnvelopeInput>();
+
+  constructor({chainEvents, signal, serializedCache, metrics, logger}: SeenPayloadEnvelopeInputModules) {
+    this.chainEvents = chainEvents;
+    this.signal = signal;
+    this.serializedCache = serializedCache;
+    this.metrics = metrics;
+    this.logger = logger;
+
+    if (metrics) {
+      metrics.seenCache.payloadEnvelopeInput.count.addCollect(() => {
+        metrics.seenCache.payloadEnvelopeInput.count.set(this.payloadInputs.size);
+        metrics.seenCache.payloadEnvelopeInput.serializedObjectRefs.set(
+          Array.from(this.payloadInputs.values()).reduce(
+            (count, payloadInput) => count + payloadInput.getSerializedCacheKeys().length,
+            0
+          )
+        );
+      });
+    }
+
+    this.chainEvents.on(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    this.signal.addEventListener("abort", () => {
+      this.chainEvents.off(ChainEvent.forkChoiceFinalized, this.onFinalized);
+    });
+  }
+
+  private onFinalized = (checkpoint: CheckpointWithHex): void => {
+    // Prune all entries with slot < finalized slot
+    const finalizedSlot = computeStartSlotAtEpoch(checkpoint.epoch);
+    let deletedCount = 0;
+    for (const [, input] of this.payloadInputs) {
+      if (input.slot < finalizedSlot) {
+        this.evictPayloadInput(input);
+        deletedCount++;
+      }
+    }
+    this.logger?.debug("SeenPayloadEnvelopeInput.onFinalized deleted cached entries", {deletedCount});
+  };
+
+  add(props: CreateFromBlockProps): PayloadEnvelopeInput {
+    if (this.payloadInputs.has(props.blockRootHex)) {
+      throw new Error(`PayloadEnvelopeInput already exists for block ${props.blockRootHex}`);
+    }
+    const input = PayloadEnvelopeInput.createFromBlock(props);
+    this.payloadInputs.set(props.blockRootHex, input);
+    this.metrics?.seenCache.payloadEnvelopeInput.created.inc();
+    return input;
+  }
+
+  get(blockRootHex: RootHex): PayloadEnvelopeInput | undefined {
+    return this.payloadInputs.get(blockRootHex);
+  }
+
+  has(blockRootHex: RootHex): boolean {
+    return this.payloadInputs.has(blockRootHex);
+  }
+
+  prune(blockRootHex: RootHex): void {
+    const payloadInput = this.payloadInputs.get(blockRootHex);
+    if (payloadInput) {
+      this.evictPayloadInput(payloadInput);
+    }
+  }
+
+  size(): number {
+    return this.payloadInputs.size;
+  }
+
+  private evictPayloadInput(payloadInput: PayloadEnvelopeInput): void {
+    this.serializedCache.delete(payloadInput.getSerializedCacheKeys());
+    this.payloadInputs.delete(payloadInput.blockRootHex);
+  }
+}

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} from "@lodestar/utils";
+import {MapDef, byteArrayEquals} 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): Promise<DatastoreKey> {
-    const serializedCheckpoint = checkpointToDatastoreKey(cpKey);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
+    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
     await this.db.checkpointState.putBinary(serializedCheckpoint, stateBytes);
     return serializedCheckpoint;
   }
@@ -40,18 +40,30 @@ 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(key);
+  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;
 }
 
-export function checkpointToDatastoreKey(cp: phase0.Checkpoint): DatastoreKey {
-  return ssz.phase0.Checkpoint.serialize(cp);
+function isPayloadCheckpointState(key: DatastoreKey): boolean {
+  return key.at(-1) === 1;
 }
 
 /**
- * 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
+ * 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)
  *   - state slot should be at epoch boundary
  *   - state slot should be equal to epoch * SLOTS_PER_EPOCH
  *
@@ -70,9 +82,20 @@ 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,12 +1,13 @@
 import path from "node:path";
-import {phase0, ssz} from "@lodestar/types";
+import {phase0} from "@lodestar/types";
 import {fromHex, toHex} from "@lodestar/utils";
 import {ensureDir, readFile, readFileNames, removeFile, writeIfNotExist} from "../../../util/file.js";
-import {getLatestSafeDatastoreKey} from "./db.js";
+import {checkpointToDatastoreKey, getLatestSafeDatastoreKey} from "./db.js";
 import {CPStateDatastore, DatastoreKey} from "./types.js";
 
 const CHECKPOINT_STATES_FOLDER = "checkpoint_states";
-const CHECKPOINT_FILE_NAME_LENGTH = 82;
+/** 41 bytes (40 checkpoint + 1 payloadPresent) = 82 hex chars + "0x" prefix = 84 */
+const CHECKPOINT_FILE_NAME_LENGTH = 84;
 
 /**
  * Implementation of CPStateDatastore using file system, this is beneficial for debugging.
@@ -28,8 +29,8 @@ export class FileCPStateDatastore implements CPStateDatastore {
     }
   }
 
-  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array): Promise<DatastoreKey> {
-    const serializedCheckpoint = ssz.phase0.Checkpoint.serialize(cpKey);
+  async write(cpKey: phase0.Checkpoint, stateBytes: Uint8Array, payloadPresent: boolean): Promise<DatastoreKey> {
+    const serializedCheckpoint = checkpointToDatastoreKey(cpKey, payloadPresent);
     const filePath = path.join(this.folderPath, toHex(serializedCheckpoint));
     await writeIfNotExist(filePath, stateBytes);
     return serializedCheckpoint;

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

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

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -20,6 +20,11 @@ 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
@@ -41,10 +46,7 @@ export const DEFAULT_MAX_BLOCK_STATES = 64;
  * The maintained key order would be: 11 -> 13 -> 12 -> 10, and state 10 will be pruned first.
  */
 export class FIFOBlockStateCache implements BlockStateCache {
-  /**
-   * Max number of states allowed in the cache
-   */
-  readonly maxStates: number;
+  private maxStates: number;
 
   private readonly cache: MapTracker<string, CachedBeaconStateAllForks>;
   /**
@@ -170,6 +172,10 @@ 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