@lodestar/beacon-node 1.47.0-dev.da8dfeabda → 1.47.0-dev.e73f1f5165

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.47.0-dev.da8dfeabda",
+  "version": "1.47.0-dev.e73f1f5165",
   "type": "module",
   "exports": {
     ".": {
@@ -116,35 +116,35 @@
     "@fastify/cors": "^10.0.1",
     "@fastify/swagger": "^9.0.0",
     "@fastify/swagger-ui": "^5.0.1",
-    "@libp2p/bootstrap": "^12.0.14",
-    "@libp2p/crypto": "^5.1.13",
-    "@libp2p/gossipsub": "^16.0.2",
-    "@libp2p/identify": "^4.0.13",
-    "@libp2p/interface": "^3.1.0",
-    "@libp2p/mdns": "^12.0.14",
-    "@libp2p/mplex": "^12.0.14",
-    "@libp2p/peer-id": "^6.0.4",
-    "@libp2p/prometheus-metrics": "^5.0.14",
-    "@libp2p/tcp": "^11.0.13",
-    "@lodestar/api": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/config": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/db": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/fork-choice": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/logger": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/params": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/reqresp": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/state-transition": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/types": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/utils": "^1.47.0-dev.da8dfeabda",
-    "@lodestar/validator": "^1.47.0-dev.da8dfeabda",
+    "@libp2p/bootstrap": "^12.0.30",
+    "@libp2p/crypto": "^5.1.23",
+    "@libp2p/gossipsub": "^16.1.1",
+    "@libp2p/identify": "^4.1.13",
+    "@libp2p/interface": "^3.3.0",
+    "@libp2p/mdns": "^12.0.30",
+    "@libp2p/mplex": "^12.0.30",
+    "@libp2p/peer-id": "^6.0.15",
+    "@libp2p/prometheus-metrics": "^5.0.28",
+    "@libp2p/tcp": "^11.0.27",
+    "@lodestar/api": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/config": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/db": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/fork-choice": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/logger": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/params": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/reqresp": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/state-transition": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/types": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/utils": "^1.47.0-dev.e73f1f5165",
+    "@lodestar/validator": "^1.47.0-dev.e73f1f5165",
     "@multiformats/multiaddr": "^13.0.1",
-    "datastore-core": "^11.0.2",
-    "datastore-level": "^12.0.2",
+    "datastore-core": "^12.0.1",
+    "datastore-level": "^13.0.1",
     "deepmerge": "^4.3.1",
     "fastify": "^5.8.1",
-    "interface-datastore": "^9.0.2",
+    "interface-datastore": "^10.0.1",
     "jwt-simple": "0.5.6",
-    "libp2p": "3.1.6",
+    "libp2p": "3.3.9",
     "multiformats": "^13.4.2",
     "prom-client": "^15.1.0",
     "qs": "^6.14.2",
@@ -155,10 +155,10 @@
   },
   "devDependencies": {
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@libp2p/interface-internal": "^3.0.13",
-    "@libp2p/logger": "^6.2.2",
-    "@libp2p/utils": "^7.0.13",
-    "@lodestar/spec-test-util": "^1.47.0-dev.da8dfeabda",
+    "@libp2p/interface-internal": "^3.1.12",
+    "@libp2p/logger": "^6.2.13",
+    "@libp2p/utils": "^7.4.0",
+    "@lodestar/spec-test-util": "^1.47.0-dev.e73f1f5165",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -175,5 +175,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "ca798baa4a35b53638f98f64eacac48a3ad82df7"
+  "gitHead": "f904f0debe8a23fe85fe084e09e2247110d0717f"
 }

package/src/api/impl/beacon/blocks/index.ts

@@ -128,7 +128,8 @@ export function getBeaconBlockApi({
         forkName: fork,
         sampledColumns: chain.custodyConfig.sampledColumns,
         custodyColumns: chain.custodyConfig.custodyColumns,
-        timeCreatedSec: seenTimestampSec,
+        seenTimestampSec,
+        source: PayloadEnvelopeInputSource.api,
       });
     }
 

package/src/api/impl/beacon/pool/index.ts

@@ -179,7 +179,21 @@ export function getBeaconPoolApi({
     },
 
     async submitPoolVoluntaryExit({signedVoluntaryExit}) {
-      await validateApiVoluntaryExit(chain, signedVoluntaryExit);
+      const result = await validateApiVoluntaryExit(chain, signedVoluntaryExit);
+
+      if (result.status === "deferred") {
+        const currentEpoch = chain.clock.currentEpoch;
+        const inserted = chain.deferredVoluntaryExitPool.insert(signedVoluntaryExit, result.validity, currentEpoch);
+        if (!inserted) {
+          throw new ApiError(400, "Deferred voluntary exit pool is full or already contains this validator");
+        }
+        logger.info("Voluntary exit deferred until transient conditions are met", {
+          validatorIndex: signedVoluntaryExit.message.validatorIndex,
+          reason: result.validity,
+        });
+        return;
+      }
+
       chain.opPool.insertVoluntaryExit(signedVoluntaryExit);
       chain.emitter.emit(routes.events.EventType.voluntaryExit, signedVoluntaryExit);
       await network.publishVoluntaryExit(signedVoluntaryExit);

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

@@ -14,7 +14,9 @@ export function getEventsApi({
         // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
         const handler = (data: any): void => {
           try {
-            onEvent({type: topic, message: data});
+            // TS only relates `{type, message}` to the `BeaconEvent` discriminated union while
+            // `EventType` stays within its ~25-member cap; without the cast, adding events trips TS2345.
+            onEvent({type: topic, message: data} as routes.events.BeaconEvent);
           } catch (e) {
             // `chain.emitter` emits synchronously, a throwing listener would propagate the error to
             // whoever emitted the event, e.g. a gossip handler, and skip the remaining listeners.

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

@@ -147,7 +147,7 @@ export function getLodestarApi({
     },
 
     async dropStateCache() {
-      chain.regen.dropCache();
+      await chain.regen.dropCache();
     },
 
     async connectPeer({peerId, multiaddrs}) {

package/src/api/rest/base.ts

@@ -104,6 +104,13 @@ export class RestApiServer {
 
     // To parse our ApiError -> statusCode
     server.setErrorHandler<FastifyError | Error>((err, _req, res) => {
+      if (res.raw.headersSent) {
+        // A status code can no longer be written, e.g. if a long-lived SSE stream failed mid-flight.
+        // End the response instead, else the socket is left open and the client never notices.
+        if (!res.raw.writableEnded && !res.raw.destroyed) res.raw.end();
+        return;
+      }
+
       const stacktraces = opts.stacktraces ? err.stack?.split("\n") : undefined;
       if ("validation" in err && err.validation) {
         const {instancePath = "unknown", message} = err.validation?.[0] ?? {};

package/src/chain/archiveStore/archiveStore.ts

@@ -192,7 +192,7 @@ export class ArchiveStore {
 
   private onCheckpoint = (): void => {
     const headStateRoot = this.chain.forkChoice.getHead().stateRoot;
-    this.chain.regen.pruneOnCheckpoint(
+    this.chain.regen.onCheckpoint(
       this.chain.forkChoice.getFinalizedCheckpoint().epoch,
       this.chain.forkChoice.getJustifiedCheckpoint().epoch,
       headStateRoot

package/src/chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.ts

@@ -9,6 +9,7 @@ import {
   ColumnWithSource,
   CreateFromBidProps,
   CreateFromBlockProps,
+  PayloadEnvelopeInputSource,
   SourceMeta,
 } from "./types.js";
 
@@ -71,6 +72,7 @@ export class PayloadEnvelopeInput {
   readonly bid: gloas.ExecutionPayloadBid;
   readonly versionedHashes: VersionedHashes;
   readonly daOutOfRange: boolean;
+  readonly source: PayloadEnvelopeInputSource;
 
   private columnsCache = new Map<ColumnIndex, ColumnWithSource>();
 
@@ -95,6 +97,7 @@ export class PayloadEnvelopeInput {
     custodyColumns: ColumnIndex[];
     timeCreatedSec: number;
     daOutOfRange: boolean;
+    source: PayloadEnvelopeInputSource;
   }) {
     this.blockRootHex = props.blockRootHex;
     this.slot = props.slot;
@@ -106,6 +109,7 @@ export class PayloadEnvelopeInput {
     this.custodyColumns = props.custodyColumns;
     this.timeCreatedSec = props.timeCreatedSec;
     this.daOutOfRange = props.daOutOfRange;
+    this.source = props.source;
     this.payloadEnvelopeDataPromise = createPromise();
     this.allDataPromise = createPromise();
     this.columnsDataPromise = createPromise();
@@ -133,8 +137,9 @@ export class PayloadEnvelopeInput {
       bid,
       sampledColumns: props.sampledColumns,
       custodyColumns: props.custodyColumns,
-      timeCreatedSec: props.timeCreatedSec,
+      timeCreatedSec: props.seenTimestampSec,
       daOutOfRange: props.daOutOfRange,
+      source: props.source,
     });
   }
 
@@ -153,8 +158,9 @@ export class PayloadEnvelopeInput {
       bid: props.bid,
       sampledColumns: props.sampledColumns,
       custodyColumns: props.custodyColumns,
-      timeCreatedSec: props.timeCreatedSec,
+      timeCreatedSec: props.seenTimestampSec,
       daOutOfRange: props.daOutOfRange,
+      source: props.source,
     });
   }
 

package/src/chain/blocks/payloadEnvelopeInput/types.ts

@@ -7,9 +7,24 @@ export enum PayloadEnvelopeInputSource {
   engine = "engine",
   byRange = "req_resp_by_range",
   byRoot = "req_resp_by_root",
+  // Data-column reconstruction (KZG cell recovery), NOT a cache reload
   recovery = "recovery",
+  // Entry reconstructed from the hot DB by SeenPayloadEnvelopeInput.getOrReload
+  reload = "reload",
+  // Entry seeded from a checkpoint anchor state's latestExecutionPayloadBid at chain init
+  anchorState = "anchor_state",
 }
 
+/**
+ * Reason a PayloadEnvelopeInput is evicted from SeenPayloadEnvelopeInput. Used for the `pruned` metric
+ * label and the eviction log.
+ * - belowParent: pruned below the new head's parent (canonical, FULL, all-columns)
+ * - finalized: below the finalized slot
+ * - prune: explicit prune by root
+ * - cap: insertion-order backstop cap (MAX_PAYLOAD_ENVELOPE_INPUT_CACHE_SIZE)
+ */
+export type PayloadEnvelopeInputPruneReason = "belowParent" | "finalized" | "prune" | "cap";
+
 export type SourceMeta = {
   source: PayloadEnvelopeInputSource;
   seenTimestampSec: number;
@@ -20,13 +35,12 @@ export type ColumnWithSource = SourceMeta & {
   columnSidecar: gloas.DataColumnSidecar;
 };
 
-export type CreateFromBlockProps = {
+export type CreateFromBlockProps = SourceMeta & {
   blockRootHex: RootHex;
   block: SignedBeaconBlock<ForkPostGloas>;
   forkName: ForkName;
   sampledColumns: ColumnIndex[];
   custodyColumns: ColumnIndex[];
-  timeCreatedSec: number;
   daOutOfRange: boolean;
 };
 
@@ -35,7 +49,7 @@ export type CreateFromBlockProps = {
  * the chain from a checkpoint anchor state — we have the bid via the state but not the
  * full SignedBeaconBlock).
  */
-export type CreateFromBidProps = {
+export type CreateFromBidProps = SourceMeta & {
   blockRootHex: RootHex;
   slot: number;
   forkName: ForkName;
@@ -43,7 +57,6 @@ export type CreateFromBidProps = {
   bid: gloas.ExecutionPayloadBid;
   sampledColumns: ColumnIndex[];
   custodyColumns: ColumnIndex[];
-  timeCreatedSec: number;
   daOutOfRange: boolean;
 };
 

package/src/chain/chain.ts

@@ -79,6 +79,7 @@ import {CheckpointBalancesCache} from "./balancesCache.js";
 import {BeaconProposerCache} from "./beaconProposerCache.js";
 import {IBlockInput, isBlockInputBlobs, isBlockInputColumns} from "./blocks/blockInput/index.js";
 import {BlockProcessor, ImportBlockOpts} from "./blocks/index.js";
+import {PayloadEnvelopeInputSource} from "./blocks/payloadEnvelopeInput/index.js";
 import {PayloadEnvelopeProcessor} from "./blocks/payloadEnvelopeProcessor.js";
 import {ImportPayloadOpts} from "./blocks/types.js";
 import {persistBlockInput} from "./blocks/writeBlockInputToDb.js";
@@ -94,6 +95,7 @@ import {LightClientServer} from "./lightClient/index.js";
 import {
   AggregatedAttestationPool,
   AttestationPool,
+  DeferredVoluntaryExitPool,
   ExecutionPayloadBidPool,
   OpPool,
   PayloadAttestationPool,
@@ -193,6 +195,7 @@ export class BeaconChain implements IBeaconChain {
   readonly payloadAttestationPool: PayloadAttestationPool;
   readonly proposerPreferencesPool = new ProposerPreferencesPool();
   readonly opPool: OpPool;
+  readonly deferredVoluntaryExitPool: DeferredVoluntaryExitPool;
 
   // Gossip seen cache
   readonly seenAttesters = new SeenAttesters();
@@ -320,6 +323,7 @@ export class BeaconChain implements IBeaconChain {
     this.executionPayloadBidPool = new ExecutionPayloadBidPool();
     this.payloadAttestationPool = new PayloadAttestationPool(config, clock, metrics);
     this.opPool = new OpPool(config);
+    this.deferredVoluntaryExitPool = new DeferredVoluntaryExitPool(logger);
 
     this.seenAggregatedAttestations = new SeenAggregatedAttestations(metrics);
     this.seenContributionAndProof = new SeenContributionAndProof(metrics);
@@ -451,6 +455,9 @@ export class BeaconChain implements IBeaconChain {
       chainEvents: emitter,
       signal,
       serializedCache: this.serializedCache,
+      db,
+      seenBlockInputCache: this.seenBlockInputCache,
+      custodyConfig: this.custodyConfig,
       metrics,
       logger,
     });
@@ -466,7 +473,8 @@ export class BeaconChain implements IBeaconChain {
         bid: anchorBid,
         sampledColumns: this.custodyConfig.sampledColumns,
         custodyColumns: this.custodyConfig.custodyColumns,
-        timeCreatedSec: Math.floor(Date.now() / 1000),
+        seenTimestampSec: Date.now() / 1000,
+        source: PayloadEnvelopeInputSource.anchorState,
       });
     }
 
@@ -1569,6 +1577,7 @@ export class BeaconChain implements IBeaconChain {
     // aggregatedAttestationPool tracks metrics on its own
     metrics.opPool.attestationPool.size.set(this.attestationPool.getAttestationCount());
     metrics.opPool.attesterSlashingPoolSize.set(this.opPool.attesterSlashingsSize);
+    metrics.opPool.deferredVoluntaryExitPool.size.set(this.deferredVoluntaryExitPool.size());
     metrics.opPool.proposerSlashingPoolSize.set(this.opPool.proposerSlashingsSize);
     metrics.opPool.voluntaryExitPoolSize.set(this.opPool.voluntaryExitsSize);
     metrics.opPool.syncCommitteeMessagePoolSize.set(this.syncCommitteeMessagePool.size);

package/src/chain/forkChoice/index.ts

@@ -134,6 +134,8 @@ export function initializeForkChoiceFromFinalizedState(
         stateRoot: toRootHex(blockHeader.stateRoot),
         blockRoot: toRootHex(checkpoint.root),
         timeliness: true, // Optimistically assume is timely
+        ptcTimeliness: true, // Spec: block_timeliness for anchor = [True, True]
+        proposerIndex: blockHeader.proposerIndex,
 
         justifiedEpoch: justifiedCheckpoint.epoch,
         justifiedRoot: toRootHex(justifiedCheckpoint.root),
@@ -230,6 +232,8 @@ export function initializeForkChoiceFromUnfinalizedState(
     blockRoot: headRoot,
     targetRoot: headRoot,
     timeliness: true, // Optimistically assume is timely
+    ptcTimeliness: true, // Spec: block_timeliness for anchor = [True, True]
+    proposerIndex: blockHeader.proposerIndex,
 
     justifiedEpoch: justifiedCheckpoint.epoch,
     justifiedRoot: toRootHex(justifiedCheckpoint.root),

package/src/chain/interface.ts

@@ -45,6 +45,7 @@ import {LightClientServer} from "./lightClient/index.js";
 import {AggregatedAttestationPool} from "./opPools/aggregatedAttestationPool.js";
 import {
   AttestationPool,
+  DeferredVoluntaryExitPool,
   ExecutionPayloadBidPool,
   OpPool,
   PayloadAttestationPool,
@@ -128,6 +129,7 @@ export interface IBeaconChain {
   readonly payloadAttestationPool: PayloadAttestationPool;
   readonly proposerPreferencesPool: ProposerPreferencesPool;
   readonly opPool: OpPool;
+  readonly deferredVoluntaryExitPool: DeferredVoluntaryExitPool;
 
   // Gossip seen cache
   readonly seenAttesters: SeenAttesters;

package/src/chain/opPools/deferredVoluntaryExitPool.ts

@@ -0,0 +1,65 @@
+import {Logger} from "@lodestar/logger";
+import {IBeaconStateView, VoluntaryExitValidity} from "@lodestar/state-transition";
+import {Epoch, ValidatorIndex} from "@lodestar/types";
+import {SignedVoluntaryExit} from "@lodestar/types/phase0";
+import {isTransientExitValidity} from "../validation/voluntaryExit.js";
+
+type DeferredEntry = {
+  exit: SignedVoluntaryExit;
+  validity: VoluntaryExitValidity;
+  insertedAtEpoch: Epoch;
+};
+
+export class DeferredVoluntaryExitPool {
+  private pool = new Map<ValidatorIndex, DeferredEntry>();
+
+  constructor(
+    private readonly logger: Logger,
+    private readonly maxSize = 1024,
+    private readonly maxDeferEpochs = 4096
+  ) {}
+
+  insert(exit: SignedVoluntaryExit, validity: VoluntaryExitValidity, currentEpoch: Epoch): boolean {
+    if (!isTransientExitValidity(validity)) return false;
+    if (this.pool.size === this.maxSize) return false;
+    if (this.pool.has(exit.message.validatorIndex)) return false;
+
+    this.pool.set(exit.message.validatorIndex, {exit, validity, insertedAtEpoch: currentEpoch});
+
+    return true;
+  }
+
+  drainProcessableExits(state: IBeaconStateView): SignedVoluntaryExit[] {
+    const epoch = state.epoch;
+    const validExits: SignedVoluntaryExit[] = [];
+    for (const [validatorIndex, entry] of this.pool) {
+      try {
+        if (epoch - entry.insertedAtEpoch > this.maxDeferEpochs) {
+          this.pool.delete(validatorIndex);
+          this.logger.debug("Deferred voluntary exit expired", {validatorIndex, lastValidity: entry.validity});
+          continue;
+        }
+        const validity = state.getVoluntaryExitValidity(entry.exit, true);
+        if (validity === VoluntaryExitValidity.valid) {
+          validExits.push(entry.exit);
+          this.pool.delete(validatorIndex);
+        } else if (!isTransientExitValidity(validity)) {
+          this.logger.debug("Deferred voluntary exit became permanently invalid", {validatorIndex, validity});
+          this.pool.delete(validatorIndex);
+        }
+        // Else if still transient - keep
+      } catch (e) {
+        this.logger.debug("Processing deferred voluntary exit failed", {validatorIndex}, e as Error);
+      }
+    }
+    return validExits;
+  }
+
+  has(validatorIndex: ValidatorIndex): boolean {
+    return this.pool.has(validatorIndex);
+  }
+
+  size(): number {
+    return this.pool.size;
+  }
+}

package/src/chain/opPools/index.ts

@@ -1,5 +1,6 @@
 export {AggregatedAttestationPool} from "./aggregatedAttestationPool.js";
 export {AttestationPool} from "./attestationPool.js";
+export {DeferredVoluntaryExitPool} from "./deferredVoluntaryExitPool.js";
 export {ExecutionPayloadBidPool} from "./executionPayloadBidPool.js";
 export {OpPool} from "./opPool.js";
 export {PayloadAttestationPool} from "./payloadAttestationPool.js";

package/src/chain/prepareNextSlot.ts

@@ -151,23 +151,38 @@ export class PrepareNextSlotScheduler {
         const proposerIndex = await getProposerIndex();
         feeRecipient = this.chain.beaconProposerCache.get(proposerIndex);
 
-        if (feeRecipient) {
-          // If we are proposing next slot, we need to predict if we can proposer-boost-reorg or not
+        // Predict the proposer head of the next slot when either:
+        //  - we are proposing the next slot (single-slot proposer-boost-reorg), or
+        //  - this is an epoch transition: post-Fulu the next proposer may reorg a weak
+        //    last-block-of-epoch and build slot 0 on the strong parent (epoch-boundary reorg),
+        //    so we should dial the strong parent through the boundary instead of the weak head.
+        if (feeRecipient || isEpochTransition) {
           const proposerHead = this.chain.predictProposerHead(clockSlot);
           const {slot: proposerHeadSlot, blockRoot: proposerHeadRoot} = proposerHead;
 
-          // If we predict we can reorg, we build on the proposer head (parent) block instead
+          // If we predict a reorg, we build the epoch transition on the proposer head (parent) instead
           if (proposerHeadRoot !== headRoot || proposerHeadSlot !== headSlot) {
-            this.logger.verbose("Weak head detected. May build on parent block instead", {
+            // feeRecipient set => WE propose the next slot and may reorg it out ourselves;
+            // otherwise it's a predicted reorg by another proposer (epoch-boundary reorg).
+            const logMessage = feeRecipient
+              ? "Weak head detected. We may build on parent block instead"
+              : "Weak head detected. Another proposer may build on parent block instead";
+            this.logger.verbose(logMessage, {
               proposerHeadSlot,
               proposerHeadRoot,
               headSlot,
               headRoot,
+              isEpochTransition,
             });
             this.metrics?.weakHeadDetected.inc();
+            if (isEpochTransition) {
+              this.metrics?.precomputeNextEpochTransition.predictedReorg.inc();
+            }
             updatedHead = proposerHead;
           }
+        }
 
+        if (feeRecipient) {
           if (isForkPostGloas(fork)) {
             this.chain.builderCircuitBreaker.update(clockSlot, updatedHead);
           } else {
@@ -182,6 +197,7 @@ export class PrepareNextSlotScheduler {
         }
 
         // post-fulu we'll always reach here because preparedState is undefined
+        // we may run epoch transition not with headBlock if it's weak
         if (preparedState === undefined || updatedHead !== headBlock) {
           preparedState = await this.chain.regen.getBlockSlotState(
             updatedHead,
@@ -280,7 +296,7 @@ export class PrepareNextSlotScheduler {
       //  + if next slot is a skipped slot, it'd help getting target checkpoint state faster to validate attestations
       if (isEpochTransition) {
         this.metrics?.precomputeNextEpochTransition.count.inc({result: "success"}, 1);
-        const previousHits = this.chain.regen.updatePreComputedCheckpoint(headRoot, nextEpoch);
+        const previousHits = this.chain.regen.updatePreComputedCheckpoint(updatedHead.blockRoot, nextEpoch);
         if (previousHits === 0) {
           this.metrics?.precomputeNextEpochTransition.waste.inc();
         }
@@ -289,6 +305,8 @@ export class PrepareNextSlotScheduler {
         this.logger.verbose("Completed PrepareNextSlotScheduler epoch transition", {
           nextEpoch,
           headSlot,
+          headRoot,
+          updatedHeadRoot: updatedHead.blockRoot,
           prepareSlot,
           previousHits,
           durationMs: Date.now() - start,

package/src/chain/regen/interface.ts

@@ -21,6 +21,8 @@ export enum RegenCaller {
   validateGossipAggregateAndProof = "validateGossipAggregateAndProof",
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
+  validateApiVoluntaryExit = "validateApiVoluntaryExit",
+  publishDeferredVoluntaryExits = "publishDeferredVoluntaryExits",
   validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
   validateGossipPayloadAttestationMessage = "validateGossipPayloadAttestationMessage",
   validateGossipProposerPreferences = "validateGossipProposerPreferences",
@@ -39,14 +41,14 @@ export type StateRegenerationOpts = {
 };
 
 export interface IStateRegenerator extends IStateRegeneratorInternal {
-  dropCache(): void;
+  dropCache(): Promise<void>;
   dumpCacheSummary(): routes.lodestar.StateCacheItem[];
   getStateSync(stateRoot: RootHex): IBeaconStateView | null;
   getPreStateSync(block: BeaconBlock): 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;
+  onCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void;
   processState(blockRootHex: RootHex, postState: IBeaconStateView): void;
   addCheckpointState(cp: phase0.Checkpoint, item: IBeaconStateView): void;
   updateHeadState(newHead: ProtoBlock, maybeHeadState: IBeaconStateView): void;

package/src/chain/regen/queued.ts

@@ -67,9 +67,9 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return this.jobQueue.jobLen < REGEN_CAN_ACCEPT_WORK_THRESHOLD;
   }
 
-  dropCache(): void {
+  async dropCache(): Promise<void> {
     this.blockStateCache.clear();
-    this.checkpointStateCache.clear();
+    await this.checkpointStateCache.clear();
   }
 
   dumpCacheSummary(): routes.lodestar.StateCacheItem[] {
@@ -138,9 +138,9 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return this.checkpointStateCache.getLatest(head.blockRoot, Infinity) || this.blockStateCache.get(head.stateRoot);
   }
 
-  pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void {
-    this.checkpointStateCache.prune(finalizedEpoch, justifiedEpoch);
-    this.blockStateCache.prune(headStateRoot);
+  onCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void {
+    this.checkpointStateCache.onCheckpoint(finalizedEpoch, justifiedEpoch);
+    this.blockStateCache.onCheckpoint(headStateRoot);
   }
 
   processState(blockRootHex: RootHex, postState: IBeaconStateView): void {