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

package/lib/chain/stateCache/persistentCheckpointsCache.d.ts

@@ -1,6 +1,5 @@
 import { routes } from "@lodestar/api";
 import { BeaconConfig } from "@lodestar/config";
-import { CheckpointWithPayloadStatus } from "@lodestar/fork-choice";
 import { IBeaconStateView } from "@lodestar/state-transition";
 import { Epoch, RootHex, phase0 } from "@lodestar/types";
 import { Logger } from "@lodestar/utils";
@@ -8,7 +7,7 @@ import { Metrics } from "../../metrics/index.js";
 import { BufferPool } from "../../util/bufferPool.js";
 import { IClock } from "../../util/clock.js";
 import { CPStateDatastore, DatastoreKey } from "./datastore/index.js";
-import { BlockStateCache, CheckpointHexPayload, CheckpointStateCache } from "./types.js";
+import { BlockStateCache, CheckpointHex, CheckpointStateCache } from "./types.js";
 export type PersistentCheckpointStateCacheOpts = {
     /** Keep max n state epochs in memory, persist the rest to disk */
     maxCPStateEpochsInMemory?: number;
@@ -78,7 +77,7 @@ export declare const DEFAULT_MAX_CP_STATE_ON_DISK: number;
  */
 export declare class PersistentCheckpointStateCache implements CheckpointStateCache {
     private readonly cache;
-    /** Epoch -> Map<blockRoot, PayloadAvailability bitmask> */
+    /** Epoch -> Set<blockRoot> */
     private readonly epochIndex;
     private readonly config;
     private readonly metrics;
@@ -104,29 +103,27 @@ export declare class PersistentCheckpointStateCache implements CheckpointStateCa
      * - Get block for processing
      * - Regen head state
      */
-    getOrReload(cp: CheckpointHexPayload): Promise<IBeaconStateView | null>;
+    getOrReload(cp: CheckpointHex): Promise<IBeaconStateView | null>;
     /**
      * Return either state or state bytes loaded from db.
      */
-    getStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null>;
+    getStateOrBytes(cp: CheckpointHex): Promise<IBeaconStateView | Uint8Array | null>;
     /**
      * Return either state or state bytes with persisted key loaded from db.
      */
-    getStateOrLoadDb(cp: CheckpointHexPayload): Promise<IBeaconStateView | LoadedStateBytesData | null>;
+    getStateOrLoadDb(cp: CheckpointHex): Promise<IBeaconStateView | LoadedStateBytesData | null>;
     /**
      * Similar to get() api without reloading from disk
      */
-    get(cpOrKey: CheckpointHexPayload | CacheKey): IBeaconStateView | null;
+    get(cpOrKey: CheckpointHex | CacheKey): IBeaconStateView | null;
     /**
      * Add a state of a checkpoint to this cache, prune from memory if necessary.
-     * @param payloadPresent - For Gloas: true if this is payload state, false if block state.
-     *                         Always true for pre-Gloas.
      */
-    add(cp: phase0.Checkpoint, state: IBeaconStateView, payloadPresent: boolean): void;
+    add(cp: phase0.Checkpoint, state: IBeaconStateView): void;
     /**
      * Searches in-memory state for the latest cached state with a `root` without reload, starting with `epoch` and descending
      */
-    getLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): IBeaconStateView | null;
+    getLatest(rootHex: RootHex, maxEpoch: Epoch): IBeaconStateView | null;
     /**
      * Searches state for the latest cached state with a `root`, reload if needed, starting with `epoch` and descending
      * This is expensive api, should only be called in some important flows:
@@ -134,14 +131,12 @@ export declare class PersistentCheckpointStateCache implements CheckpointStateCa
      * - Get block for processing
      * - Regen head state
      */
-    getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): Promise<IBeaconStateView | null>;
+    getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch): Promise<IBeaconStateView | null>;
     /**
      * Update the precomputed checkpoint and return the number of hits for the
      * previous one (if any).
-     * @param payloadPresent - For Gloas: true if head block has FULL payload, false if EMPTY.
-     *                         Always true for pre-Gloas.
      */
-    updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, payloadPresent: boolean): number | null;
+    updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
     /**
      * This is just to conform to the old implementation
      */
@@ -199,9 +194,6 @@ export declare class PersistentCheckpointStateCache implements CheckpointStateCa
      * - 2 then we'll persist {root: b2, epoch n-2} checkpoint state to disk, there are also 2 checkpoint states in memory at epoch n, same to the above (maxEpochsInMemory=1)
      *
      * As of Mar 2024, it takes <=350ms to persist a holesky state on fast server
-     *
-     * For Gloas: Processes both block state and payload state variants together. The decision of which roots to persist/prune
-     * is based on root canonicality (from state's view), not payload presence. Both variants are managed as a unit.
      */
     processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number>;
     /**
@@ -221,11 +213,8 @@ export declare class PersistentCheckpointStateCache implements CheckpointStateCa
      *
      * Use seed state from the block cache if cannot find any seed states within this cache.
      */
-    findSeedStateToReload(reloadedCp: CheckpointHexPayload): IBeaconStateView;
+    findSeedStateToReload(reloadedCp: CheckpointHex): IBeaconStateView;
     clear(): void;
-    private addToEpochIndex;
-    private removeFromEpochIndex;
-    private hasPayloadVariant;
     /** ONLY FOR DEBUGGING PURPOSES. For lodestar debug API */
     dumpSummary(): routes.lodestar.StateCacheItem[];
     getStates(): IterableIterator<IBeaconStateView>;
@@ -246,13 +235,7 @@ export declare class PersistentCheckpointStateCache implements CheckpointStateCa
      */
     private serializeStateValidators;
 }
-export declare function toCheckpointHexPayload(checkpoint: phase0.Checkpoint, payloadPresent: boolean): CheckpointHexPayload;
-/**
- * Convert fork-choice CheckpointWithPayloadStatus to beacon-node CheckpointHexPayload.
- * Maps PayloadStatus enum to boolean payloadPresent.
- * @throws Error if checkpoint has PENDING payload status (ambiguous which variant to use)
- */
-export declare function fcCheckpointToHexPayload(checkpoint: CheckpointWithPayloadStatus): CheckpointHexPayload;
-export declare function toCheckpointKey(cp: CheckpointHexPayload): string;
+export declare function toCheckpointHex(checkpoint: phase0.Checkpoint): CheckpointHex;
+export declare function toCheckpointKey(cp: CheckpointHex): string;
 export {};
 //# sourceMappingURL=persistentCheckpointsCache.d.ts.map

package/lib/chain/stateCache/persistentCheckpointsCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persistentCheckpointsCache.d.ts","sourceRoot":"","sources":["../../../src/chain/stateCache/persistentCheckpointsCache.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"persistentCheckpointsCache.d.ts","sourceRoot":"","sources":["../../../src/chain/stateCache/persistentCheckpointsCache.ts"],"names":[],"mappings":"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"}

package/lib/chain/stateCache/persistentCheckpointsCache.js

@@ -56,19 +56,6 @@ import { AllocSource } from "../../util/bufferPool.js";
 import { serializeState } from "../serializeState.js";
 import { MapTracker } from "./mapMetrics.js";
 import { CacheItemType } from "./types.js";
-/** Bitmask for tracking which payload variants exist per root in the epochIndex */
-var PayloadAvailability;
-(function (PayloadAvailability) {
-    PayloadAvailability[PayloadAvailability["NOT_PRESENT"] = 1] = "NOT_PRESENT";
-    PayloadAvailability[PayloadAvailability["PRESENT"] = 2] = "PRESENT";
-})(PayloadAvailability || (PayloadAvailability = {}));
-const PAYLOAD_AVAILABILITY_ALL = [PayloadAvailability.NOT_PRESENT, PayloadAvailability.PRESENT];
-function toPayloadAvailability(payloadPresent) {
-    return payloadPresent ? PayloadAvailability.PRESENT : PayloadAvailability.NOT_PRESENT;
-}
-function fromPayloadAvailability(flag) {
-    return flag === PayloadAvailability.PRESENT;
-}
 /**
  * Before n-historical states, lodestar keeps all checkpoint states since finalized
  * Since Sep 2024, lodestar stores 3 most recent checkpoint states in memory and the rest on disk. The finalized state
@@ -118,8 +105,8 @@ const PROCESS_CHECKPOINT_STATES_BPS = 6667;
  */
 export class PersistentCheckpointStateCache {
     cache;
-    /** Epoch -> Map<blockRoot, PayloadAvailability bitmask> */
-    epochIndex = new MapDef(() => new Map());
+    /** Epoch -> Set<blockRoot> */
+    epochIndex = new MapDef(() => new Set());
     config;
     metrics;
     logger;
@@ -205,12 +192,7 @@ export class PersistentCheckpointStateCache {
             return stateOrStateBytesData ?? null;
         }
         const { persistedKey, stateBytes } = stateOrStateBytesData;
-        const logMeta = {
-            epoch: cp.epoch,
-            rootHex: cp.rootHex,
-            payloadPresent: cp.payloadPresent,
-            persistedKey: toHex(persistedKey),
-        };
+        const logMeta = { persistedKey: toHex(persistedKey) };
         this.logger.debug("Reload: read state successful", logMeta);
         this.metrics?.cpStateCache.stateReloadSecFromSlot.observe(this.clock?.secFromSlot(this.clock?.currentSlot ?? 0) ?? 0);
         const seedState = this.findSeedStateToReload(cp);
@@ -231,7 +213,10 @@ export class PersistentCheckpointStateCache {
                 }
                 sszTimer?.();
                 const timer = this.metrics?.cpStateCache.stateReloadDuration.startTimer();
-                const newCachedState = seedState.loadOtherState(stateBytes, validatorsBytes);
+                // preload validators and balances for faster state transition
+                const newCachedState = seedState.loadOtherState(stateBytes, validatorsBytes, {
+                    preloadValidatorsAndBalances: true,
+                });
                 // hashTreeRoot() calls the commit() inside
                 // there is no modification inside the state, it's just that we want to compute and cache all roots
                 const stateRoot = toRootHex(newCachedState.hashTreeRoot());
@@ -245,7 +230,7 @@ export class PersistentCheckpointStateCache {
                 // only remove persisted state once we reload successfully
                 const cpKey = toCacheKey(cp);
                 this.cache.set(cpKey, { type: CacheItemType.inMemory, state: newCachedState, persistedKey });
-                this.addToEpochIndex(cp.epoch, cp.rootHex, cp.payloadPresent);
+                this.epochIndex.getOrDefault(cp.epoch).add(cp.rootHex);
                 // don't prune from memory here, call it at the last 1/3 of slot 0 of an epoch
                 return newCachedState;
             }
@@ -321,11 +306,9 @@ export class PersistentCheckpointStateCache {
     }
     /**
      * Add a state of a checkpoint to this cache, prune from memory if necessary.
-     * @param payloadPresent - For Gloas: true if this is payload state, false if block state.
-     *                         Always true for pre-Gloas.
      */
-    add(cp, state, payloadPresent) {
-        const cpHex = toCheckpointHexPayload(cp, payloadPresent);
+    add(cp, state) {
+        const cpHex = toCheckpointHex(cp);
         const key = toCacheKey(cpHex);
         const cacheItem = this.cache.get(key);
         this.metrics?.cpStateCache.adds.inc();
@@ -336,32 +319,27 @@ export class PersistentCheckpointStateCache {
             this.logger.verbose("Added checkpoint state to memory but a persisted key existed", {
                 epoch: cp.epoch,
                 rootHex: cpHex.rootHex,
-                payloadPresent,
                 persistedKey: toHex(persistedKey),
             });
         }
         else {
             this.cache.set(key, { type: CacheItemType.inMemory, state });
-            this.logger.verbose("Added checkpoint state to memory", {
-                epoch: cp.epoch,
-                rootHex: cpHex.rootHex,
-                payloadPresent,
-            });
+            this.logger.verbose("Added checkpoint state to memory", { epoch: cp.epoch, rootHex: cpHex.rootHex });
         }
-        this.addToEpochIndex(cp.epoch, cpHex.rootHex, cpHex.payloadPresent);
+        this.epochIndex.getOrDefault(cp.epoch).add(cpHex.rootHex);
         this.prunePersistedStates();
     }
     /**
      * Searches in-memory state for the latest cached state with a `root` without reload, starting with `epoch` and descending
      */
-    getLatest(rootHex, maxEpoch, payloadPresent) {
+    getLatest(rootHex, maxEpoch) {
         // sort epochs in descending order, only consider epochs lte `epoch`
         const epochs = Array.from(this.epochIndex.keys())
             .sort((a, b) => b - a)
             .filter((e) => e <= maxEpoch);
         for (const epoch of epochs) {
-            if (this.hasPayloadVariant(epoch, rootHex, payloadPresent)) {
-                const inMemoryClonedState = this.get({ rootHex, epoch, payloadPresent });
+            if (this.epochIndex.get(epoch)?.has(rootHex)) {
+                const inMemoryClonedState = this.get({ rootHex, epoch });
                 if (inMemoryClonedState) {
                     return inMemoryClonedState;
                 }
@@ -376,21 +354,21 @@ export class PersistentCheckpointStateCache {
      * - Get block for processing
      * - Regen head state
      */
-    async getOrReloadLatest(rootHex, maxEpoch, payloadPresent) {
+    async getOrReloadLatest(rootHex, maxEpoch) {
         // sort epochs in descending order, only consider epochs lte `epoch`
         const epochs = Array.from(this.epochIndex.keys())
             .sort((a, b) => b - a)
             .filter((e) => e <= maxEpoch);
         for (const epoch of epochs) {
-            if (this.hasPayloadVariant(epoch, rootHex, payloadPresent)) {
+            if (this.epochIndex.get(epoch)?.has(rootHex)) {
                 try {
-                    const state = await this.getOrReload({ rootHex, epoch, payloadPresent });
+                    const state = await this.getOrReload({ rootHex, epoch });
                     if (state) {
                         return state;
                     }
                 }
                 catch (e) {
-                    this.logger.debug("Error get or reload state", { epoch, rootHex, payloadPresent }, e);
+                    this.logger.debug("Error get or reload state", { epoch, rootHex }, e);
                 }
             }
         }
@@ -399,12 +377,10 @@ export class PersistentCheckpointStateCache {
     /**
      * Update the precomputed checkpoint and return the number of hits for the
      * previous one (if any).
-     * @param payloadPresent - For Gloas: true if head block has FULL payload, false if EMPTY.
-     *                         Always true for pre-Gloas.
      */
-    updatePreComputedCheckpoint(rootHex, epoch, payloadPresent) {
+    updatePreComputedCheckpoint(rootHex, epoch) {
         const previousHits = this.preComputedCheckpointHits;
-        this.preComputedCheckpoint = toCacheKey({ rootHex, epoch, payloadPresent });
+        this.preComputedCheckpoint = toCacheKey({ rootHex, epoch });
         this.preComputedCheckpointHits = 0;
         return previousHits;
     }
@@ -473,9 +449,6 @@ export class PersistentCheckpointStateCache {
      * - 2 then we'll persist {root: b2, epoch n-2} checkpoint state to disk, there are also 2 checkpoint states in memory at epoch n, same to the above (maxEpochsInMemory=1)
      *
      * As of Mar 2024, it takes <=350ms to persist a holesky state on fast server
-     *
-     * For Gloas: Processes both block state and payload state variants together. The decision of which roots to persist/prune
-     * is based on root canonicality (from state's view), not payload presence. Both variants are managed as a unit.
      */
     async processState(blockRootHex, state) {
         let persistCount = 0;
@@ -550,35 +523,30 @@ export class PersistentCheckpointStateCache {
             if (firstState !== null) {
                 return firstState;
             }
-            for (const [rootHex, bitmask] of this.epochIndex.get(epoch) || []) {
-                for (const flag of PAYLOAD_AVAILABILITY_ALL) {
-                    if (!(bitmask & flag))
-                        continue;
-                    const payloadPresent = fromPayloadAvailability(flag);
-                    const cpKey = toCacheKey({ rootHex, epoch, payloadPresent });
-                    const cacheItem = this.cache.get(cpKey);
-                    if (cacheItem === undefined) {
-                        continue;
+            for (const rootHex of this.epochIndex.get(epoch) || []) {
+                const cpKey = toCacheKey({ rootHex, epoch });
+                const cacheItem = this.cache.get(cpKey);
+                if (cacheItem === undefined) {
+                    continue;
+                }
+                if (isInMemoryCacheItem(cacheItem)) {
+                    const { state } = cacheItem;
+                    if (firstState === null) {
+                        firstState = state;
                     }
-                    if (isInMemoryCacheItem(cacheItem)) {
-                        const { state } = cacheItem;
-                        if (firstState === null) {
-                            firstState = state;
-                        }
-                        const cpLog = { cpEpoch: epoch, cpRoot: rootHex, payloadPresent };
-                        try {
-                            // amongst states of the same epoch, choose the one with the same view of reloadedCp
-                            if (reloadedCpSlot < state.slot &&
-                                toRootHex(state.getBlockRootAtSlot(reloadedCpSlot)) === reloadedCp.rootHex) {
-                                this.logger.verbose("Reload: use checkpoint state as seed state", { ...cpLog, ...logCtx });
-                                return state;
-                            }
-                        }
-                        catch (e) {
-                            // getBlockRootAtSlot may throw error
-                            this.logger.debug("Error finding checkpoint state to reload", { ...cpLog, ...logCtx }, e);
+                    const cpLog = { cpEpoch: epoch, cpRoot: rootHex };
+                    try {
+                        // amongst states of the same epoch, choose the one with the same view of reloadedCp
+                        if (reloadedCpSlot < state.slot &&
+                            toRootHex(state.getBlockRootAtSlot(reloadedCpSlot)) === reloadedCp.rootHex) {
+                            this.logger.verbose("Reload: use checkpoint state as seed state", { ...cpLog, ...logCtx });
+                            return state;
                         }
                     }
+                    catch (e) {
+                        // getBlockRootAtSlot may throw error
+                        this.logger.debug("Error finding checkpoint state to reload", { ...cpLog, ...logCtx }, e);
+                    }
                 }
             }
         }
@@ -591,31 +559,6 @@ export class PersistentCheckpointStateCache {
         this.cache.clear();
         this.epochIndex.clear();
     }
-    addToEpochIndex(epoch, rootHex, payloadPresent) {
-        const rootMap = this.epochIndex.getOrDefault(epoch);
-        rootMap.set(rootHex, (rootMap.get(rootHex) ?? 0) | toPayloadAvailability(payloadPresent));
-    }
-    removeFromEpochIndex(epoch, rootHex, payloadPresent) {
-        const rootMap = this.epochIndex.get(epoch);
-        if (rootMap === undefined)
-            return;
-        const existing = rootMap.get(rootHex);
-        if (existing === undefined)
-            return;
-        const updated = existing & ~toPayloadAvailability(payloadPresent);
-        if (updated === 0) {
-            rootMap.delete(rootHex);
-            if (rootMap.size === 0) {
-                this.epochIndex.delete(epoch);
-            }
-        }
-        else {
-            rootMap.set(rootHex, updated);
-        }
-    }
-    hasPayloadVariant(epoch, rootHex, payloadPresent) {
-        return Boolean((this.epochIndex.get(epoch)?.get(rootHex) ?? 0) & toPayloadAvailability(payloadPresent));
-    }
     /** ONLY FOR DEBUGGING PURPOSES. For lodestar debug API */
     dumpSummary() {
         return Array.from(this.cache.keys()).map((key) => {
@@ -684,81 +627,81 @@ export class PersistentCheckpointStateCache {
         const epochBoundaryHex = toRootHex(epochBoundaryRoot);
         const prevEpochRoot = toRootHex(state.getBlockRootAtSlot(epochBoundarySlot - 1));
         // for each epoch, usually there are 2 rootHexes respective to the 2 checkpoint states: Previous Root Checkpoint State and Current Root Checkpoint State
-        const cpRootHexMap = this.epochIndex.get(epoch) ?? new Map();
+        const cpRootHexes = this.epochIndex.get(epoch) ?? [];
         const persistedRootHexes = new Set();
         // 1) if there is no CRCS, persist PRCS (block 0 of epoch is skipped). In this case prevEpochRoot === epochBoundaryHex
         // 2) if there are PRCS and CRCS, persist CRCS => persist CRCS
         // => this is simplified to always persist epochBoundaryHex
         persistedRootHexes.add(epochBoundaryHex);
         // 3) persist any states with unknown roots to this state
-        for (const rootHex of cpRootHexMap.keys()) {
+        for (const rootHex of cpRootHexes) {
             if (rootHex !== epochBoundaryHex && rootHex !== prevEpochRoot) {
                 persistedRootHexes.add(rootHex);
             }
         }
-        for (const [rootHex, bitmask] of cpRootHexMap) {
-            for (const flag of PAYLOAD_AVAILABILITY_ALL) {
-                if (!(bitmask & flag))
-                    continue;
-                const payloadPresent = fromPayloadAvailability(flag);
-                const cpKey = toCacheKey({ epoch: epoch, rootHex, payloadPresent });
-                const cacheItem = this.cache.get(cpKey);
-                if (cacheItem !== undefined && isInMemoryCacheItem(cacheItem)) {
-                    let { persistedKey } = cacheItem;
-                    const { state } = cacheItem;
-                    const logMeta = {
-                        stateSlot: state.slot,
-                        rootHex,
-                        payloadPresent,
-                        epochBoundaryHex,
-                        persistedKey: persistedKey ? toHex(persistedKey) : "",
-                    };
-                    if (persistedRootHexes.has(rootHex)) {
-                        if (persistedKey) {
-                            // we don't care if the checkpoint state is already persisted
-                            this.logger.verbose("Pruned checkpoint state from memory but no need to persist", logMeta);
-                        }
-                        else {
-                            // persist and do not update epochIndex
-                            this.metrics?.cpStateCache.statePersistSecFromSlot.observe(this.clock?.secFromSlot(this.clock?.currentSlot ?? 0) ?? 0);
-                            const cpPersist = { epoch: epoch, root: fromHex(rootHex) };
-                            // It's not sustainable to allocate ~240MB for each state every epoch, so we use buffer pool to reuse the memory.
-                            // As monitored on holesky as of Jan 2024:
-                            //   - This does not increase heap allocation while gc time is the same
-                            //   - It helps stabilize persist time and save ~300ms in average (1.5s vs 1.2s)
-                            //   - It also helps the state reload to save ~500ms in average (4.3s vs 3.8s)
-                            //   - Also `serializeState.test.ts` perf test shows a lot of differences allocating ~240MB once vs per state serialization
-                            const timer = this.metrics?.stateSerializeDuration.startTimer({
-                                source: AllocSource.PERSISTENT_CHECKPOINTS_CACHE_STATE,
-                            });
-                            persistedKey = await serializeState(state, AllocSource.PERSISTENT_CHECKPOINTS_CACHE_STATE, (stateBytes) => {
-                                timer?.();
-                                return this.datastore.write(cpPersist, stateBytes, payloadPresent);
-                            }, this.bufferPool);
-                            persistCount++;
-                            this.logger.verbose("Pruned checkpoint state from memory and persisted to disk", {
-                                ...logMeta,
-                                persistedKey: toHex(persistedKey),
-                            });
-                        }
-                        // overwrite cpKey, this means the state is deleted from memory
+        for (const rootHex of cpRootHexes) {
+            const cpKey = toCacheKey({ epoch: epoch, rootHex });
+            const cacheItem = this.cache.get(cpKey);
+            if (cacheItem !== undefined && isInMemoryCacheItem(cacheItem)) {
+                let { persistedKey } = cacheItem;
+                const { state } = cacheItem;
+                const logMeta = {
+                    stateSlot: state.slot,
+                    rootHex,
+                    epochBoundaryHex,
+                    persistedKey: persistedKey ? toHex(persistedKey) : "",
+                };
+                if (persistedRootHexes.has(rootHex)) {
+                    if (persistedKey) {
+                        // we don't care if the checkpoint state is already persisted
+                        this.logger.verbose("Pruned checkpoint state from memory but no need to persist", logMeta);
+                    }
+                    else {
+                        // persist and do not update epochIndex
+                        this.metrics?.cpStateCache.statePersistSecFromSlot.observe(this.clock?.secFromSlot(this.clock?.currentSlot ?? 0) ?? 0);
+                        const cpPersist = { epoch: epoch, root: fromHex(rootHex) };
+                        // It's not sustainable to allocate ~240MB for each state every epoch, so we use buffer pool to reuse the memory.
+                        // As monitored on holesky as of Jan 2024:
+                        //   - This does not increase heap allocation while gc time is the same
+                        //   - It helps stabilize persist time and save ~300ms in average (1.5s vs 1.2s)
+                        //   - It also helps the state reload to save ~500ms in average (4.3s vs 3.8s)
+                        //   - Also `serializeState.test.ts` perf test shows a lot of differences allocating ~240MB once vs per state serialization
+                        const timer = this.metrics?.stateSerializeDuration.startTimer({
+                            source: AllocSource.PERSISTENT_CHECKPOINTS_CACHE_STATE,
+                        });
+                        persistedKey = await serializeState(state, AllocSource.PERSISTENT_CHECKPOINTS_CACHE_STATE, (stateBytes) => {
+                            timer?.();
+                            return this.datastore.write(cpPersist, stateBytes);
+                        }, this.bufferPool);
+                        persistCount++;
+                        this.logger.verbose("Pruned checkpoint state from memory and persisted to disk", {
+                            ...logMeta,
+                            persistedKey: toHex(persistedKey),
+                        });
+                    }
+                    // overwrite cpKey, this means the state is deleted from memory
+                    this.cache.set(cpKey, { type: CacheItemType.persisted, value: persistedKey });
+                }
+                else {
+                    if (persistedKey) {
+                        // persisted file will be eventually deleted by the archive task
+                        // this also means the state is deleted from memory
                         this.cache.set(cpKey, { type: CacheItemType.persisted, value: persistedKey });
+                        // do not update epochIndex
                     }
                     else {
-                        if (persistedKey) {
-                            // persisted file will be eventually deleted by the archive task
-                            // this also means the state is deleted from memory
-                            this.cache.set(cpKey, { type: CacheItemType.persisted, value: persistedKey });
-                            // do not update epochIndex
-                        }
-                        else {
-                            // delete the state from memory
-                            this.cache.delete(cpKey);
-                            this.removeFromEpochIndex(epoch, rootHex, payloadPresent);
+                        // delete the state from memory
+                        this.cache.delete(cpKey);
+                        const rootSet = this.epochIndex.get(epoch);
+                        if (rootSet) {
+                            rootSet.delete(rootHex);
+                            if (rootSet.size === 0) {
+                                this.epochIndex.delete(epoch);
+                            }
                         }
-                        this.metrics?.cpStateCache.statePruneFromMemoryCount.inc();
-                        this.logger.verbose("Pruned checkpoint state from memory", logMeta);
                     }
+                    this.metrics?.cpStateCache.statePruneFromMemoryCount.inc();
+                    this.logger.verbose("Pruned checkpoint state from memory", logMeta);
                 }
             }
         }
@@ -769,38 +712,25 @@ export class PersistentCheckpointStateCache {
      */
     async deleteAllEpochItems(epoch) {
         let persistCount = 0;
-        const rootHexMap = this.epochIndex.get(epoch) || new Map();
-        for (const [rootHex, bitmask] of rootHexMap) {
-            for (const flag of PAYLOAD_AVAILABILITY_ALL) {
-                if (!(bitmask & flag))
-                    continue;
-                const payloadPresent = fromPayloadAvailability(flag);
-                const key = toCacheKey({ rootHex, epoch, payloadPresent });
-                const cacheItem = this.cache.get(key);
-                if (cacheItem) {
-                    const persistedKey = isPersistedCacheItem(cacheItem) ? cacheItem.value : cacheItem.persistedKey;
-                    if (persistedKey) {
-                        await this.datastore.remove(persistedKey);
-                        persistCount++;
-                        this.metrics?.cpStateCache.persistedStateRemoveCount.inc();
-                    }
+        const rootHexes = this.epochIndex.get(epoch) || [];
+        for (const rootHex of rootHexes) {
+            const key = toCacheKey({ rootHex, epoch });
+            const cacheItem = this.cache.get(key);
+            if (cacheItem) {
+                const persistedKey = isPersistedCacheItem(cacheItem) ? cacheItem.value : cacheItem.persistedKey;
+                if (persistedKey) {
+                    await this.datastore.remove(persistedKey);
+                    persistCount++;
+                    this.metrics?.cpStateCache.persistedStateRemoveCount.inc();
                 }
-                this.cache.delete(key);
-                this.logger.verbose("Pruned checkpoint state", {
-                    epoch,
-                    rootHex,
-                    payloadPresent,
-                    type: cacheItem ? (isPersistedCacheItem(cacheItem) ? "persisted" : "in-memory") : "missing",
-                });
             }
+            this.cache.delete(key);
         }
         this.epochIndex.delete(epoch);
-        this.logger.verbose("Pruned all checkpoint states for epoch", {
+        this.logger.verbose("Pruned checkpoint states for epoch", {
             epoch,
             persistCount,
-            items: Array.from(rootHexMap.entries())
-                .flatMap(([rootHex, bitmask]) => PAYLOAD_AVAILABILITY_ALL.filter((f) => bitmask & f).map((f) => `${rootHex}:${fromPayloadAvailability(f)}`))
-                .join(","),
+            rootHexes: Array.from(rootHexes).join(","),
         });
     }
     /**
@@ -840,49 +770,23 @@ export class PersistentCheckpointStateCache {
         return null;
     }
 }
-export function toCheckpointHexPayload(checkpoint, payloadPresent) {
+export function toCheckpointHex(checkpoint) {
     return {
         epoch: checkpoint.epoch,
         rootHex: toRootHex(checkpoint.root),
-        payloadPresent,
-    };
-}
-/**
- * Convert fork-choice CheckpointWithPayloadStatus to beacon-node CheckpointHexPayload.
- * Maps PayloadStatus enum to boolean payloadPresent.
- * @throws Error if checkpoint has PENDING payload status (ambiguous which variant to use)
- */
-export function fcCheckpointToHexPayload(checkpoint) {
-    const PayloadStatus = { PENDING: 0, EMPTY: 1, FULL: 2 };
-    if (checkpoint.payloadStatus === PayloadStatus.PENDING) {
-        throw Error(`Cannot convert checkpoint with PENDING payload status at epoch ${checkpoint.epoch} root ${checkpoint.rootHex}`);
-    }
-    return {
-        epoch: checkpoint.epoch,
-        rootHex: checkpoint.rootHex,
-        payloadPresent: checkpoint.payloadStatus === PayloadStatus.FULL,
     };
 }
 export function toCheckpointKey(cp) {
-    return `${cp.rootHex}:${cp.epoch}:${cp.payloadPresent}`;
+    return `${cp.rootHex}:${cp.epoch}`;
 }
-/**
- * Convert checkpoint to cache key string.
- * Format: `{rootHex}_{epoch}_{payloadPresent}`
- */
 function toCacheKey(cp) {
-    return `${cp.rootHex}_${cp.epoch}_${cp.payloadPresent}`;
+    return `${cp.rootHex}_${cp.epoch}`;
 }
 function fromCacheKey(key) {
-    const parts = key.split("_");
-    const rootHex = parts[0];
-    const epoch = Number(parts[1]);
-    // For backward compatibility with old format (rootHex_epoch), default to true
-    const payloadPresent = parts.length > 2 ? parts[2] === "true" : true;
+    const [rootHex, epoch] = key.split("_");
     return {
         rootHex,
-        epoch,
-        payloadPresent,
+        epoch: Number(epoch),
     };
 }
 function isBeaconStateView(stateOrBytes) {