@lodestar/beacon-node 1.36.0-dev.793f92c091 → 1.36.0-dev.9dbc67b579

package/package.json

@@ -11,55 +11,67 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.36.0-dev.793f92c091",
+  "version": "1.36.0-dev.9dbc67b579",
   "type": "module",
   "exports": {
     ".": {
       "bun": "./src/index.ts",
+      "types": "./lib/index.d.ts",
       "import": "./lib/index.js"
     },
     "./api": {
       "bun": "./src/api/index.ts",
+      "types": "./lib/api/index.d.ts",
       "import": "./lib/api/index.js"
     },
     "./chain": {
       "bun": "./src/chain/index.ts",
+      "types": "./lib/chain/index.d.ts",
       "import": "./lib/chain/index.js"
     },
     "./constants": {
       "bun": "./src/constants/index.ts",
+      "types": "./lib/constants/index.d.ts",
       "import": "./lib/constants/index.js"
     },
     "./db": {
       "bun": "./src/db/index.ts",
+      "types": "./lib/db/index.d.ts",
       "import": "./lib/db/index.js"
     },
     "./eth1": {
       "bun": "./src/eth1/index.ts",
+      "types": "./lib/eth1/index.d.ts",
       "import": "./lib/eth1/index.js"
     },
     "./metrics": {
       "bun": "./src/metrics/index.ts",
+      "types": "./lib/metrics/index.d.ts",
       "import": "./lib/metrics/index.js"
     },
     "./monitoring": {
       "bun": "./src/monitoring/index.ts",
+      "types": "./lib/monitoring/index.d.ts",
       "import": "./lib/monitoring/index.js"
     },
     "./network": {
       "bun": "./src/network/index.ts",
+      "types": "./lib/network/index.d.ts",
       "import": "./lib/network/index.js"
     },
     "./node": {
       "bun": "./src/node/index.ts",
+      "types": "./lib/node/index.d.ts",
       "import": "./lib/node/index.js"
     },
     "./sync": {
       "bun": "./src/sync/index.ts",
+      "types": "./lib/sync/index.d.ts",
       "import": "./lib/sync/index.js"
     },
     "./util": {
       "bun": "./src/util/index.ts",
+      "types": "./lib/util/index.d.ts",
       "import": "./lib/util/index.js"
     }
   },
@@ -73,16 +85,6 @@
       "default": "datastore-level"
     }
   },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "*",
-        "lib/*",
-        "lib/*/index"
-      ]
-    }
-  },
-  "types": "./lib/index.d.ts",
   "files": [
     "src",
     "lib",
@@ -138,18 +140,18 @@
     "@libp2p/peer-id": "^5.1.0",
     "@libp2p/prometheus-metrics": "^4.3.15",
     "@libp2p/tcp": "^10.1.8",
-    "@lodestar/api": "1.36.0-dev.793f92c091",
-    "@lodestar/config": "1.36.0-dev.793f92c091",
-    "@lodestar/db": "1.36.0-dev.793f92c091",
-    "@lodestar/fork-choice": "1.36.0-dev.793f92c091",
-    "@lodestar/light-client": "1.36.0-dev.793f92c091",
-    "@lodestar/logger": "1.36.0-dev.793f92c091",
-    "@lodestar/params": "1.36.0-dev.793f92c091",
-    "@lodestar/reqresp": "1.36.0-dev.793f92c091",
-    "@lodestar/state-transition": "1.36.0-dev.793f92c091",
-    "@lodestar/types": "1.36.0-dev.793f92c091",
-    "@lodestar/utils": "1.36.0-dev.793f92c091",
-    "@lodestar/validator": "1.36.0-dev.793f92c091",
+    "@lodestar/api": "1.36.0-dev.9dbc67b579",
+    "@lodestar/config": "1.36.0-dev.9dbc67b579",
+    "@lodestar/db": "1.36.0-dev.9dbc67b579",
+    "@lodestar/fork-choice": "1.36.0-dev.9dbc67b579",
+    "@lodestar/light-client": "1.36.0-dev.9dbc67b579",
+    "@lodestar/logger": "1.36.0-dev.9dbc67b579",
+    "@lodestar/params": "1.36.0-dev.9dbc67b579",
+    "@lodestar/reqresp": "1.36.0-dev.9dbc67b579",
+    "@lodestar/state-transition": "1.36.0-dev.9dbc67b579",
+    "@lodestar/types": "1.36.0-dev.9dbc67b579",
+    "@lodestar/utils": "1.36.0-dev.9dbc67b579",
+    "@lodestar/validator": "1.36.0-dev.9dbc67b579",
     "@multiformats/multiaddr": "^12.1.3",
     "datastore-core": "^10.0.2",
     "datastore-fs": "^10.0.6",
@@ -185,5 +187,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "77b9473f42e62290ea090af8b4e3cbd9eb7084b3"
+  "gitHead": "3f729ae94a582b5f66f65f3dd9149e64137436bd"
 }

package/src/api/impl/config/constants.ts

@@ -1,5 +1,7 @@
 import {
   ATTESTATION_SUBNET_COUNT,
+  ATTESTATION_SUBNET_EXTRA_BITS,
+  ATTESTATION_SUBNET_PREFIX_BITS,
   BASE_REWARDS_PER_EPOCH,
   BLOB_TX_TYPE,
   BLS_WITHDRAWAL_PREFIX,
@@ -25,15 +27,15 @@ import {
   DOMAIN_SYNC_COMMITTEE,
   DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF,
   DOMAIN_VOLUNTARY_EXIT,
-  EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION,
   ETH1_ADDRESS_WITHDRAWAL_PREFIX,
   FAR_FUTURE_EPOCH,
   FULL_EXIT_REQUEST_AMOUNT,
   GENESIS_EPOCH,
   GENESIS_SLOT,
   JUSTIFICATION_BITS_LENGTH,
+  MAX_CONCURRENT_REQUESTS,
+  NODE_ID_BITS,
   PROPOSER_WEIGHT,
-  RANDOM_SUBNETS_PER_VALIDATOR,
   SYNC_COMMITTEE_SUBNET_COUNT,
   SYNC_REWARD_WEIGHT,
   TARGET_AGGREGATORS_PER_COMMITTEE,
@@ -84,9 +86,13 @@ export const specConstants = {
 
   // phase0/validator.md
   TARGET_AGGREGATORS_PER_COMMITTEE,
-  RANDOM_SUBNETS_PER_VALIDATOR,
-  EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION,
+
+  // phase0/p2p-interface.md
+  NODE_ID_BITS,
+  MAX_CONCURRENT_REQUESTS,
   ATTESTATION_SUBNET_COUNT,
+  ATTESTATION_SUBNET_EXTRA_BITS,
+  ATTESTATION_SUBNET_PREFIX_BITS,
 
   // altair/beacon-chain.md
   // ## Participation flag indices

package/src/api/impl/lodestar/index.ts

@@ -1,5 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
 import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
@@ -8,13 +6,16 @@ import {Repository} from "@lodestar/db";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {BeaconStateCapella, getLatestWeakSubjectivityCheckpointEpoch, loadState} from "@lodestar/state-transition";
 import {ssz} from "@lodestar/types";
-import {toHex, toRootHex} from "@lodestar/utils";
+import {Checkpoint} from "@lodestar/types/phase0";
+import {fromHex, toHex, toRootHex} from "@lodestar/utils";
 import {BeaconChain} from "../../../chain/index.js";
 import {QueuedStateRegenerator, RegenRequest} from "../../../chain/regen/index.js";
 import {IBeaconDb} from "../../../db/interface.js";
 import {GossipType} from "../../../network/index.js";
-import {profileNodeJS, writeHeapSnapshot} from "../../../util/profile.js";
+import {getStateSlotFromBytes} from "../../../util/multifork.js";
+import {ProfileThread, profileThread, writeHeapSnapshot} from "../../../util/profile.js";
 import {getStateResponseWithRegen} from "../beacon/state/utils.js";
+import {ApiError} from "../errors.js";
 import {ApiModules} from "../types.js";
 
 export function getLodestarApi({
@@ -26,7 +27,9 @@ export function getLodestarApi({
 }: Pick<ApiModules, "chain" | "config" | "db" | "network" | "sync">): ApplicationMethods<routes.lodestar.Endpoints> {
   let writingHeapdump = false;
   let writingProfile = false;
-  const defaultProfileMs = SLOTS_PER_EPOCH * config.SLOT_DURATION_MS;
+  // for NodeJS, profile the whole epoch
+  // for Bun, profile 1 slot. Otherwise it will either crash the app, and/or inspector cannot render the profile
+  const defaultProfileMs = globalThis.Bun ? config.SLOT_DURATION_MS : SLOTS_PER_EPOCH * config.SLOT_DURATION_MS;
 
   return {
     async writeHeapdump({thread = "main", dirpath = "."}) {
@@ -63,7 +66,6 @@ export function getLodestarApi({
 
       try {
         let filepath: string;
-        let profile: string;
         switch (thread) {
           case "network":
             filepath = await network.writeNetworkThreadProfile(duration, dirpath);
@@ -73,12 +75,10 @@ export function getLodestarApi({
             break;
           default:
             // main thread
-            profile = await profileNodeJS(duration);
-            filepath = path.join(dirpath, `main_thread_${new Date().toISOString()}.cpuprofile`);
-            fs.writeFileSync(filepath, profile);
+            filepath = await profileThread(ProfileThread.MAIN, duration, dirpath);
             break;
         }
-        return {data: {filepath}};
+        return {data: {result: filepath}};
       } finally {
         writingProfile = false;
       }
@@ -218,6 +218,26 @@ export function getLodestarApi({
         meta: {executionOptimistic, finalized, version: fork},
       };
     },
+
+    // the optional checkpoint is in root:epoch format
+    async getPersistedCheckpointState({checkpointId}) {
+      const checkpoint = checkpointId ? getCheckpointFromArg(checkpointId) : undefined;
+      const stateBytes = await chain.getPersistedCheckpointState(checkpoint);
+      if (stateBytes === null) {
+        throw new ApiError(
+          404,
+          checkpointId ? `Checkpoint state not found for id ${checkpointId}` : "Latest safe checkpoint state not found"
+        );
+      }
+
+      const slot = getStateSlotFromBytes(stateBytes);
+      return {
+        data: stateBytes,
+        meta: {
+          version: config.getForkName(slot),
+        },
+      };
+    },
   };
 }
 
@@ -247,6 +267,18 @@ function regenRequestToJson(config: ChainForkConfig, regenRequest: RegenRequest)
   }
 }
 
+const CHECKPOINT_REGEX = /^(?:0x)?([0-9a-f]{64}):([0-9]+)$/;
+/**
+ * Extract a checkpoint from a string in the format `rootHex:epoch`.
+ */
+export function getCheckpointFromArg(checkpointStr: string): Checkpoint {
+  const match = CHECKPOINT_REGEX.exec(checkpointStr.toLowerCase());
+  if (!match) {
+    throw new ApiError(400, `Could not parse checkpoint string: ${checkpointStr}`);
+  }
+  return {root: fromHex(match[1]), epoch: parseInt(match[2])};
+}
+
 function stringifyKeys(keys: (Uint8Array | number | string)[]): string[] {
   return keys.map((key) => {
     if (key instanceof Uint8Array) {

package/src/api/impl/node/utils.ts

@@ -10,7 +10,7 @@ export function formatNodePeer(peerIdStr: string, connections: Connection[]): ro
   return {
     peerId: conn ? conn.remotePeer.toString() : peerIdStr,
     // TODO: figure out how to get enr of peer
-    enr: "",
+    enr: null,
     lastSeenP2pAddress: conn ? conn.remoteAddr.toString() : "",
     direction: conn ? (conn.direction as routes.node.PeerDirection) : null,
     state: conn ? getPeerState(conn.status) : "disconnected",

package/src/api/impl/validator/index.ts

@@ -179,10 +179,13 @@ export function getValidatorApi(
   /**
    * Validator clock may be advanced from beacon's clock. If the validator requests a resource in a
    * future slot, wait some time instead of rejecting the request because it's in the future.
-   * This value is the same to MAXIMUM_GOSSIP_CLOCK_DISPARITY_SEC.
+   * This value is the same to MAXIMUM_GOSSIP_CLOCK_DISPARITY.
    * For very fast networks, reduce clock disparity to half a slot.
    */
-  const MAX_API_CLOCK_DISPARITY_SEC = Math.min(0.5, config.SLOT_DURATION_MS / 2000);
+  const MAX_API_CLOCK_DISPARITY_SEC = Math.min(
+    config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000,
+    config.SLOT_DURATION_MS / 2000
+  );
   const MAX_API_CLOCK_DISPARITY_MS = MAX_API_CLOCK_DISPARITY_SEC * 1000;
 
   /** Compute and cache the genesis block root */

package/src/chain/archiveStore/archiveStore.ts

@@ -25,6 +25,16 @@ type ArchiveStoreModules = {
 
 type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {finalizedCheckpoint: Checkpoint}};
 
+export enum ArchiveStoreTask {
+  ArchiveBlocks = "archive_blocks",
+  PruneHistory = "prune_history",
+  OnFinalizedCheckpoint = "on_finalized_checkpoint",
+  MaybeArchiveState = "maybe_archive_state",
+  RegenPruneOnFinalized = "regen_prune_on_finalized",
+  ForkchoicePrune = "forkchoice_prune",
+  UpdateBackfillRange = "update_backfill_range",
+}
+
 /**
  * Used for running tasks that depends on some events or are executed
  * periodically.
@@ -176,6 +186,8 @@ export class ArchiveStore {
     try {
       const finalizedEpoch = finalized.epoch;
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
+
+      let timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await archiveBlocks(
         this.chain.config,
         this.db,
@@ -188,7 +200,10 @@ export class ArchiveStore {
         this.chain.opts.persistOrphanedBlocks,
         this.chain.opts.persistOrphanedBlocksDir
       );
+      timer?.({source: ArchiveStoreTask.ArchiveBlocks});
+
       if (this.opts.pruneHistory) {
+        timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
         await pruneHistory(
           this.chain.config,
           this.db,
@@ -197,18 +212,30 @@ export class ArchiveStore {
           finalizedEpoch,
           this.chain.clock.currentEpoch
         );
+        timer?.({source: ArchiveStoreTask.PruneHistory});
       }
 
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await this.statesArchiverStrategy.onFinalizedCheckpoint(finalized, this.metrics);
+      timer?.({source: ArchiveStoreTask.OnFinalizedCheckpoint});
 
       // should be after ArchiveBlocksTask to handle restart cleanly
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await this.statesArchiverStrategy.maybeArchiveState(finalized, this.metrics);
+      timer?.({source: ArchiveStoreTask.MaybeArchiveState});
 
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       this.chain.regen.pruneOnFinalized(finalizedEpoch);
+      timer?.({source: ArchiveStoreTask.RegenPruneOnFinalized});
 
       // tasks rely on extended fork choice
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       const prunedBlocks = this.chain.forkChoice.prune(finalized.rootHex);
+      timer?.({source: ArchiveStoreTask.ForkchoicePrune});
+
+      timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
       await updateBackfillRange({chain: this.chain, db: this.db, logger: this.logger}, finalized);
+      timer?.({source: ArchiveStoreTask.UpdateBackfillRange});
 
       this.logger.verbose("Finish processing finalized checkpoint", {
         epoch: finalizedEpoch,

package/src/chain/archiveStore/strategies/frequencyStateArchiveStrategy.ts

@@ -17,6 +17,15 @@ import {StateArchiveStrategy, StatesArchiveOpts} from "../interface.js";
  */
 export const PERSIST_TEMP_STATE_EVERY_EPOCHS = 32;
 
+export enum FrequencyStateArchiveStep {
+  LoadLastStoredSlot = "load_last_stored_slot",
+  GetFinalizedState = "get_finalized_state",
+  // SerializeState is tracked via stateSerializeDuration metric
+  PersistState = "persist_state",
+  LoadStoredSlotsToDelete = "load_stored_slots_to_delete",
+  DeleteOldStates = "delete_old_states",
+}
+
 /**
  * Archives finalized states from active bucket to archive bucket.
  *
@@ -47,11 +56,16 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    * ```
    */
   async maybeArchiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
+    let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
     const lastStoredSlot = await this.db.stateArchive.lastKey();
+    timer?.({step: FrequencyStateArchiveStep.LoadLastStoredSlot});
+
     const lastStoredEpoch = computeEpochAtSlot(lastStoredSlot ?? 0);
     const {archiveStateEpochFrequency} = this.opts;
 
+    const logCtx = {finalizedEpoch: finalized.epoch, lastStoredEpoch, archiveStateEpochFrequency};
     if (finalized.epoch - lastStoredEpoch >= Math.min(PERSIST_TEMP_STATE_EVERY_EPOCHS, archiveStateEpochFrequency)) {
+      this.logger.verbose("Start archiving state", logCtx);
       await this.archiveState(finalized, metrics);
 
       // Only check the current and previous intervals
@@ -60,23 +74,29 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
         (Math.floor(finalized.epoch / archiveStateEpochFrequency) - 1) * archiveStateEpochFrequency
       );
 
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       const storedStateSlots = await this.db.stateArchive.keys({
         lt: computeStartSlotAtEpoch(finalized.epoch),
         gte: computeStartSlotAtEpoch(minEpoch),
       });
+      timer?.({step: FrequencyStateArchiveStep.LoadStoredSlotsToDelete});
 
       const statesSlotsToDelete = computeStateSlotsToDelete(storedStateSlots, archiveStateEpochFrequency);
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       if (statesSlotsToDelete.length > 0) {
         await this.db.stateArchive.batchDelete(statesSlotsToDelete);
       }
+      timer?.({step: FrequencyStateArchiveStep.DeleteOldStates});
 
       // More logs to investigate the rss spike issue https://github.com/ChainSafe/lodestar/issues/5591
       this.logger.verbose("Archived state completed", {
-        finalizedEpoch: finalized.epoch,
+        ...logCtx,
         minEpoch,
         storedStateSlots: storedStateSlots.join(","),
         statesSlotsToDelete: statesSlotsToDelete.join(","),
       });
+    } else {
+      this.logger.verbose("Skip archiving state", logCtx);
     }
   }
 
@@ -86,24 +106,31 @@ export class FrequencyStateArchiveStrategy implements StateArchiveStrategy {
    */
   async archiveState(finalized: CheckpointWithHex, metrics?: Metrics | null): Promise<void> {
     // starting from Mar 2024, the finalized state could be from disk or in memory
+    let timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
     const finalizedStateOrBytes = await this.regen.getCheckpointStateOrBytes(finalized);
+    timer?.({step: FrequencyStateArchiveStep.GetFinalizedState});
+
     const {rootHex} = finalized;
     if (!finalizedStateOrBytes) {
       throw Error(`No state in cache for finalized checkpoint state epoch #${finalized.epoch} root ${rootHex}`);
     }
     if (finalizedStateOrBytes instanceof Uint8Array) {
       const slot = getStateSlotFromBytes(finalizedStateOrBytes);
+      timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
       await this.db.stateArchive.putBinary(slot, finalizedStateOrBytes);
+      timer?.({step: FrequencyStateArchiveStep.PersistState});
       this.logger.verbose("Archived finalized state bytes", {epoch: finalized.epoch, slot, root: rootHex});
     } else {
       // serialize state using BufferPool if provided
-      const timer = metrics?.stateSerializeDuration.startTimer({source: AllocSource.ARCHIVE_STATE});
+      const sszTimer = metrics?.stateSerializeDuration.startTimer({source: AllocSource.ARCHIVE_STATE});
       await serializeState(
         finalizedStateOrBytes,
         AllocSource.ARCHIVE_STATE,
-        (stateBytes) => {
-          timer?.();
-          return this.db.stateArchive.putBinary(finalizedStateOrBytes.slot, stateBytes);
+        async (stateBytes) => {
+          sszTimer?.();
+          timer = metrics?.processFinalizedCheckpoint.frequencyStateArchive.startTimer();
+          await this.db.stateArchive.putBinary(finalizedStateOrBytes.slot, stateBytes);
+          timer?.({step: FrequencyStateArchiveStep.PersistState});
         },
         this.bufferPool
       );

package/src/chain/beaconProposerCache.ts

@@ -1,18 +1,14 @@
 import {routes} from "@lodestar/api";
 import {Epoch} from "@lodestar/types";
-import {MapDef} from "@lodestar/utils";
 
 const PROPOSER_PRESERVE_EPOCHS = 2;
 
 export type ProposerPreparationData = routes.validator.ProposerPreparationData;
 
 export class BeaconProposerCache {
-  private readonly feeRecipientByValidatorIndex: MapDef<number, {epoch: Epoch; feeRecipient: string}>;
-  constructor(opts: {suggestedFeeRecipient: string}) {
-    this.feeRecipientByValidatorIndex = new MapDef(() => ({
-      epoch: 0,
-      feeRecipient: opts.suggestedFeeRecipient,
-    }));
+  private readonly feeRecipientByValidatorIndex: Map<number, {epoch: Epoch; feeRecipient: string}>;
+  constructor(readonly opts: {suggestedFeeRecipient: string}) {
+    this.feeRecipientByValidatorIndex = new Map();
   }
 
   add(epoch: Epoch, {validatorIndex, feeRecipient}: ProposerPreparationData): void {
@@ -30,7 +26,7 @@ export class BeaconProposerCache {
   }
 
   getOrDefault(proposerIndex: number): string {
-    return this.feeRecipientByValidatorIndex.getOrDefault(proposerIndex).feeRecipient;
+    return this.feeRecipientByValidatorIndex.get(proposerIndex)?.feeRecipient ?? this.opts.suggestedFeeRecipient;
   }
 
   get(proposerIndex: number): string | undefined {

package/src/chain/chain.ts

@@ -37,6 +37,7 @@ import {
   ValidatorIndex,
   Wei,
   isBlindedBeaconBlock,
+  phase0,
 } from "@lodestar/types";
 import {Logger, fromHex, gweiToWei, isErrorAborted, pruneSetToMax, sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
@@ -95,11 +96,13 @@ import {SeenBlockAttesters} from "./seenCache/seenBlockAttesters.js";
 import {SeenBlockInput} from "./seenCache/seenGossipBlockInput.js";
 import {ShufflingCache} from "./shufflingCache.js";
 import {BlockStateCacheImpl} from "./stateCache/blockStateCacheImpl.js";
-import {DbCPStateDatastore} from "./stateCache/datastore/db.js";
+import {DbCPStateDatastore, checkpointToDatastoreKey} from "./stateCache/datastore/db.js";
 import {FileCPStateDatastore} from "./stateCache/datastore/file.js";
+import {CPStateDatastore} from "./stateCache/datastore/types.js";
 import {FIFOBlockStateCache} from "./stateCache/fifoBlockStateCache.js";
 import {InMemoryCheckpointStateCache} from "./stateCache/inMemoryCheckpointsCache.js";
 import {PersistentCheckpointStateCache} from "./stateCache/persistentCheckpointsCache.js";
+import {CheckpointStateCache} from "./stateCache/types.js";
 import {ValidatorMonitor} from "./validatorMonitor.js";
 
 /**
@@ -181,6 +184,8 @@ export class BeaconChain implements IBeaconChain {
 
   protected readonly blockProcessor: BlockProcessor;
   protected readonly db: IBeaconDb;
+  // this is only available if nHistoricalStates is enabled
+  private readonly cpStateDatastore?: CPStateDatastore;
   private abortController = new AbortController();
   private processShutdownCallback: ProcessShutdownCallback;
   private _earliestAvailableSlot: Slot;
@@ -210,6 +215,7 @@ export class BeaconChain implements IBeaconChain {
       metrics,
       validatorMonitor,
       anchorState,
+      isAnchorStateFinalized,
       eth1,
       executionEngine,
       executionBuilder,
@@ -226,6 +232,7 @@ export class BeaconChain implements IBeaconChain {
       metrics: Metrics | null;
       validatorMonitor: ValidatorMonitor | null;
       anchorState: BeaconStateAllForks;
+      isAnchorStateFinalized: boolean;
       eth1: IEth1ForBlockProduction;
       executionEngine: IExecutionEngine;
       executionBuilder?: IExecutionBuilder;
@@ -257,7 +264,7 @@ export class BeaconChain implements IBeaconChain {
     this.attestationPool = new AttestationPool(config, clock, this.opts?.preaggregateSlotDistance, metrics);
     this.aggregatedAttestationPool = new AggregatedAttestationPool(this.config, metrics);
     this.syncCommitteeMessagePool = new SyncCommitteeMessagePool(config, clock, this.opts?.preaggregateSlotDistance);
-    this.syncContributionAndProofPool = new SyncContributionAndProofPool(clock, metrics, logger);
+    this.syncContributionAndProofPool = new SyncContributionAndProofPool(config, clock, metrics, logger);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
     this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -326,23 +333,26 @@ export class BeaconChain implements IBeaconChain {
     this.bufferPool = this.opts.nHistoricalStates
       ? new BufferPool(anchorState.type.tree_serializedSize(anchorState.node), metrics)
       : null;
-    const checkpointStateCache = this.opts.nHistoricalStates
-      ? new PersistentCheckpointStateCache(
-          {
-            metrics,
-            logger,
-            clock,
-            blockStateCache,
-            bufferPool: this.bufferPool,
-            datastore: fileDataStore
-              ? // debug option if we want to investigate any issues with the DB
-                new FileCPStateDatastore(dataDir)
-              : // production option
-                new DbCPStateDatastore(this.db),
-          },
-          this.opts
-        )
-      : new InMemoryCheckpointStateCache({metrics});
+
+    let checkpointStateCache: CheckpointStateCache;
+    this.cpStateDatastore = undefined;
+    if (this.opts.nHistoricalStates) {
+      this.cpStateDatastore = fileDataStore ? new FileCPStateDatastore(dataDir) : new DbCPStateDatastore(this.db);
+      checkpointStateCache = new PersistentCheckpointStateCache(
+        {
+          metrics,
+          logger,
+          clock,
+          blockStateCache,
+          bufferPool: this.bufferPool,
+          datastore: this.cpStateDatastore,
+        },
+        this.opts
+      );
+    } else {
+      checkpointStateCache = new InMemoryCheckpointStateCache({metrics});
+    }
+
     const {checkpoint} = computeAnchorCheckpoint(config, anchorState);
     blockStateCache.add(cachedState);
     blockStateCache.setHeadState(cachedState);
@@ -353,6 +363,7 @@ export class BeaconChain implements IBeaconChain {
       emitter,
       clock.currentSlot,
       cachedState,
+      isAnchorStateFinalized,
       opts,
       this.justifiedBalancesGetter.bind(this),
       metrics,
@@ -372,7 +383,7 @@ export class BeaconChain implements IBeaconChain {
     });
 
     if (!opts.disableLightClientServer) {
-      this.lightClientServer = new LightClientServer(opts, {config, db, metrics, emitter, logger});
+      this.lightClientServer = new LightClientServer(opts, {config, clock, db, metrics, emitter, logger});
     }
 
     this.reprocessController = new ReprocessController(this.metrics);
@@ -604,6 +615,20 @@ export class BeaconChain implements IBeaconChain {
     return data && {state: data, executionOptimistic: false, finalized: true};
   }
 
+  async getPersistedCheckpointState(checkpoint?: phase0.Checkpoint): Promise<Uint8Array | null> {
+    if (!this.cpStateDatastore) {
+      throw new Error("n-historical-state flag is not enabled");
+    }
+
+    if (checkpoint == null) {
+      // return the last safe checkpoint state by default
+      return this.cpStateDatastore.readLatestSafe();
+    }
+
+    const persistedKey = checkpointToDatastoreKey(checkpoint);
+    return this.cpStateDatastore.read(persistedKey);
+  }
+
   getStateByCheckpoint(
     checkpoint: CheckpointWithHex
   ): {state: BeaconStateAllForks; executionOptimistic: boolean; finalized: boolean} | null {

package/src/chain/errors/dataColumnSidecarError.ts

@@ -8,6 +8,7 @@ export enum DataColumnSidecarErrorCode {
   MISMATCHED_LENGTHS = "DATA_COLUMN_SIDECAR_ERROR_MISMATCHED_LENGTHS",
   INVALID_SUBNET = "DATA_COLUMN_SIDECAR_ERROR_INVALID_SUBNET",
   INVALID_KZG_PROOF = "DATA_COLUMN_SIDECAR_ERROR_INVALID_KZG_PROOF",
+  TOO_MANY_KZG_COMMITMENTS = "DATA_COLUMN_SIDECAR_ERROR_TOO_MANY_KZG_COMMITMENTS",
 
   // Validation errors when validating against an existing block
 
@@ -43,6 +44,13 @@ export type DataColumnSidecarErrorType =
       proofsLength: number;
     }
   | {code: DataColumnSidecarErrorCode.INVALID_SUBNET; columnIdx: number; gossipSubnet: SubnetID}
+  | {
+      code: DataColumnSidecarErrorCode.TOO_MANY_KZG_COMMITMENTS;
+      slot: number;
+      columnIdx: number;
+      count: number;
+      limit: number;
+    }
   | {code: DataColumnSidecarErrorCode.ALREADY_KNOWN; columnIdx: number; slot: Slot}
   | {code: DataColumnSidecarErrorCode.FUTURE_SLOT; blockSlot: Slot; currentSlot: Slot}
   | {code: DataColumnSidecarErrorCode.WOULD_REVERT_FINALIZED_SLOT; blockSlot: Slot; finalizedSlot: Slot}