@lodestar/beacon-node 1.39.0 → 1.40.0-dev.1c71f4299a

package/src/chain/opPools/aggregatedAttestationPool.ts

@@ -5,7 +5,6 @@ import {IForkChoice} from "@lodestar/fork-choice";
 import {
   ForkName,
   ForkSeq,
-  MAX_ATTESTATIONS,
   MAX_ATTESTATIONS_ELECTRA,
   MAX_COMMITTEES_PER_SLOT,
   MIN_ATTESTATION_INCLUSION_DELAY,
@@ -23,7 +22,6 @@ import {
   CachedBeaconStateAllForks,
   CachedBeaconStateAltair,
   CachedBeaconStateGloas,
-  CachedBeaconStatePhase0,
   EffectiveBalanceIncrements,
   RootCache,
   computeEpochAtSlot,
@@ -32,21 +30,12 @@ import {
   getAttestationParticipationStatus,
   getBlockRootAtSlot,
 } from "@lodestar/state-transition";
-import {
-  Attestation,
-  Epoch,
-  RootHex,
-  Slot,
-  ValidatorIndex,
-  electra,
-  isElectraAttestation,
-  phase0,
-  ssz,
-} from "@lodestar/types";
+import {Attestation, Epoch, RootHex, Slot, electra, isElectraAttestation, phase0, ssz} from "@lodestar/types";
 import {MapDef, assert, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/metrics.js";
 import {IntersectResult, intersectUint8Arrays} from "../../util/bitArray.js";
 import {getShufflingDependentRoot} from "../../util/dependentRoot.js";
+import {ShufflingCache} from "../shufflingCache.js";
 import {InsertOutcome} from "./types.js";
 import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
 
@@ -54,8 +43,6 @@ type DataRootHex = string;
 
 type CommitteeIndex = number;
 
-// for pre-electra
-type AttestationWithScore = {attestation: Attestation; score: number};
 /**
  * for electra, this is to consolidate aggregated attestations of the same attestation data into a single attestation to be included in block
  * note that this is local definition in this file and it's NOT validator consolidation
@@ -110,15 +97,6 @@ const MAX_RETAINED_ATTESTATIONS_PER_GROUP = 4;
  */
 const MAX_RETAINED_ATTESTATIONS_PER_GROUP_ELECTRA = 8;
 
-/**
- * Pre-electra, each slot has 64 committees, and each block has 128 attestations max so in average
- * we get 2 attestation per groups.
- * Starting from Jan 2024, we have a performance issue getting attestations for a block. Based on the
- * fact that lot of groups will have only 1 full participation attestation, increase this number
- * a bit higher than average. This also help decrease number of slots to search for attestations.
- */
-const MAX_ATTESTATIONS_PER_GROUP = 3;
-
 /**
  * For electra, there is on chain aggregation of attestations across committees, so we can just pick up to 8
  * attestations per group, sort by scores to get first 8.
@@ -230,123 +208,18 @@ export class AggregatedAttestationPool {
     this.lowestPermissibleSlot = Math.max(clockSlot - slotsToRetain, 0);
   }
 
-  getAttestationsForBlock(fork: ForkName, forkChoice: IForkChoice, state: CachedBeaconStateAllForks): Attestation[] {
-    const forkSeq = ForkSeq[fork];
-    return forkSeq >= ForkSeq.electra
-      ? this.getAttestationsForBlockElectra(fork, forkChoice, state)
-      : this.getAttestationsForBlockPreElectra(fork, forkChoice, state);
-  }
-
-  /**
-   * Get attestations to be included in a block pre-electra. Returns up to $MAX_ATTESTATIONS items
-   */
-  getAttestationsForBlockPreElectra(
+  getAttestationsForBlock(
     fork: ForkName,
     forkChoice: IForkChoice,
+    shufflingCache: ShufflingCache,
     state: CachedBeaconStateAllForks
-  ): phase0.Attestation[] {
-    const stateSlot = state.slot;
-    const stateEpoch = state.epochCtx.epoch;
-    const statePrevEpoch = stateEpoch - 1;
-
-    const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, state);
-    const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
-
-    const attestationsByScore: AttestationWithScore[] = [];
-
-    const slots = Array.from(this.attestationGroupByIndexByDataHexBySlot.keys()).sort((a, b) => b - a);
-    let minScore = Number.MAX_SAFE_INTEGER;
-    let slotCount = 0;
-    slot: for (const slot of slots) {
-      slotCount++;
-      const attestationGroupByIndexByDataHash = this.attestationGroupByIndexByDataHexBySlot.get(slot);
-      // should not happen
-      if (!attestationGroupByIndexByDataHash) {
-        throw Error(`No aggregated attestation pool for slot=${slot}`);
-      }
-
-      const epoch = computeEpochAtSlot(slot);
-      // validateAttestation condition: Attestation target epoch not in previous or current epoch
-      if (!(epoch === stateEpoch || epoch === statePrevEpoch)) {
-        continue; // Invalid attestations
-      }
-      // validateAttestation condition: Attestation slot not within inclusion window
-      if (
-        !(
-          slot + MIN_ATTESTATION_INCLUSION_DELAY <= stateSlot &&
-          // Post deneb, attestations are valid for current and previous epoch
-          (ForkSeq[fork] >= ForkSeq.deneb || stateSlot <= slot + SLOTS_PER_EPOCH)
-        )
-      ) {
-        continue; // Invalid attestations
-      }
-
-      const inclusionDistance = stateSlot - slot;
-      for (const attestationGroupByIndex of attestationGroupByIndexByDataHash.values()) {
-        for (const [committeeIndex, attestationGroup] of attestationGroupByIndex.entries()) {
-          const notSeenCommitteeMembers = notSeenValidatorsFn(epoch, slot, committeeIndex);
-          if (notSeenCommitteeMembers === null || notSeenCommitteeMembers.size === 0) {
-            continue;
-          }
-
-          if (
-            slotCount > 2 &&
-            attestationsByScore.length >= MAX_ATTESTATIONS &&
-            notSeenCommitteeMembers.size / inclusionDistance < minScore
-          ) {
-            // after 2 slots, there are a good chance that we have 2 * MAX_ATTESTATIONS attestations and break the for loop early
-            // if not, we may have to scan all slots in the pool
-            // if we have enough attestations and the max possible score is lower than scores of `attestationsByScore`, we should skip
-            // otherwise it takes time to check attestation, add it and remove it later after the sort by score
-            continue;
-          }
-
-          if (validateAttestationDataFn(attestationGroup.data) !== null) {
-            continue;
-          }
-
-          // TODO: Is it necessary to validateAttestation for:
-          // - Attestation committee index not within current committee count
-          // - Attestation aggregation bits length does not match committee length
-          //
-          // These properties should not change after being validate in gossip
-          // IF they have to be validated, do it only with one attestation per group since same data
-          // The committeeCountPerSlot can be precomputed once per slot
-          const getAttestationsResult = attestationGroup.getAttestationsForBlock(
-            fork,
-            state.epochCtx.effectiveBalanceIncrements,
-            notSeenCommitteeMembers,
-            MAX_ATTESTATIONS_PER_GROUP
-          );
-          for (const {attestation, newSeenEffectiveBalance} of getAttestationsResult.result) {
-            const score = newSeenEffectiveBalance / inclusionDistance;
-            if (score < minScore) {
-              minScore = score;
-            }
-            attestationsByScore.push({
-              attestation,
-              score,
-            });
-          }
-
-          // Stop accumulating attestations there are enough that may have good scoring
-          if (attestationsByScore.length >= MAX_ATTESTATIONS * 2) {
-            break slot;
-          }
-        }
-      }
+  ): Attestation[] {
+    const forkSeq = ForkSeq[fork];
+    if (forkSeq < ForkSeq.electra) {
+      throw new Error("Does not support producing blocks for pre-electra forks anymore");
     }
 
-    const sortedAttestationsByScore = attestationsByScore.sort((a, b) => b.score - a.score);
-    const attestationsForBlock: phase0.Attestation[] = [];
-    for (const [i, attestationWithScore] of sortedAttestationsByScore.entries()) {
-      if (i >= MAX_ATTESTATIONS) {
-        break;
-      }
-      // attestations could be modified in this op pool, so we need to clone for block
-      attestationsForBlock.push(ssz.phase0.Attestation.clone(attestationWithScore.attestation));
-    }
-    return attestationsForBlock;
+    return this.getAttestationsForBlockElectra(fork, forkChoice, shufflingCache, state);
   }
 
   /**
@@ -355,6 +228,7 @@ export class AggregatedAttestationPool {
   getAttestationsForBlockElectra(
     fork: ForkName,
     forkChoice: IForkChoice,
+    shufflingCache: ShufflingCache,
     state: CachedBeaconStateAllForks
   ): electra.Attestation[] {
     const stateSlot = state.slot;
@@ -362,7 +236,7 @@ export class AggregatedAttestationPool {
     const statePrevEpoch = stateEpoch - 1;
     const rootCache = new RootCache(state);
 
-    const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, state);
+    const notSeenValidatorsFn = getNotSeenValidatorsFn(this.config, shufflingCache, state);
     const validateAttestationDataFn = getValidateAttestationDataFn(forkChoice, state);
 
     const slots = Array.from(this.attestationGroupByIndexByDataHexBySlot.keys()).sort((a, b) => b - a);
@@ -864,41 +738,14 @@ export function aggregateConsolidation({byCommittee, attData}: AttestationsConso
  * Pre-compute participation from a CachedBeaconStateAllForks, for use to check if an attestation's committee
  * has already attested or not.
  */
-export function getNotSeenValidatorsFn(config: BeaconConfig, state: CachedBeaconStateAllForks): GetNotSeenValidatorsFn {
+export function getNotSeenValidatorsFn(
+  config: BeaconConfig,
+  shufflingCache: ShufflingCache,
+  state: CachedBeaconStateAllForks
+): GetNotSeenValidatorsFn {
   const stateSlot = state.slot;
   if (config.getForkName(stateSlot) === ForkName.phase0) {
-    // Get attestations to be included in a phase0 block.
-    // As we are close to altair, this is not really important, it's mainly for e2e.
-    // The performance is not great due to the different BeaconState data structure to altair.
-    // check for phase0 block already
-    const phase0State = state as CachedBeaconStatePhase0;
-    const stateEpoch = computeEpochAtSlot(stateSlot);
-
-    const previousEpochParticipants = extractParticipationPhase0(
-      phase0State.previousEpochAttestations.getAllReadonly(),
-      state
-    );
-    const currentEpochParticipants = extractParticipationPhase0(
-      phase0State.currentEpochAttestations.getAllReadonly(),
-      state
-    );
-
-    return (epoch: Epoch, slot: Slot, committeeIndex: number) => {
-      const participants =
-        epoch === stateEpoch ? currentEpochParticipants : epoch === stateEpoch - 1 ? previousEpochParticipants : null;
-      if (participants === null) {
-        return null;
-      }
-      const committee = state.epochCtx.getBeaconCommittee(slot, committeeIndex);
-
-      const notSeenCommitteeMembers = new Set<number>();
-      for (const [i, validatorIndex] of committee.entries()) {
-        if (!participants.has(validatorIndex)) {
-          notSeenCommitteeMembers.add(i);
-        }
-      }
-      return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
-    };
+    throw new Error("getNotSeenValidatorsFn is not supported phase0 state");
   }
 
   // altair and future forks
@@ -927,7 +774,8 @@ export function getNotSeenValidatorsFn(config: BeaconConfig, state: CachedBeacon
       return notSeenCommitteeMembers.size === 0 ? null : notSeenCommitteeMembers;
     }
 
-    const committee = state.epochCtx.getBeaconCommittee(slot, committeeIndex);
+    const decisionRoot = state.epochCtx.getShufflingDecisionRoot(computeEpochAtSlot(slot));
+    const committee = shufflingCache.getBeaconCommittee(epoch, decisionRoot, slot, committeeIndex);
     notSeenCommitteeMembers = new Set<number>();
     for (const [i, validatorIndex] of committee.entries()) {
       // no need to check flagIsTimelySource as if validator is not seen, it's participation status is 0
@@ -942,26 +790,6 @@ export function getNotSeenValidatorsFn(config: BeaconConfig, state: CachedBeacon
   };
 }
 
-export function extractParticipationPhase0(
-  attestations: phase0.PendingAttestation[],
-  state: CachedBeaconStateAllForks
-): Set<ValidatorIndex> {
-  const {epochCtx} = state;
-  const allParticipants = new Set<ValidatorIndex>();
-  for (const att of attestations) {
-    const aggregationBits = att.aggregationBits;
-    const attData = att.data;
-    const attSlot = attData.slot;
-    const committeeIndex = attData.index;
-    const committee = epochCtx.getBeaconCommittee(attSlot, committeeIndex);
-    const participants = aggregationBits.intersectValues(committee);
-    for (const participant of participants) {
-      allParticipants.add(participant);
-    }
-  }
-  return allParticipants;
-}
-
 /**
  * This returns a function to validate if an attestation data is compatible to a state.
  *

package/src/chain/opPools/opPool.ts

@@ -1,5 +1,5 @@
 import {BeaconConfig} from "@lodestar/config";
-import {Id, Repository} from "@lodestar/db";
+import {DbBatch, Id, Repository} from "@lodestar/db";
 import {
   BLS_WITHDRAWAL_PREFIX,
   ForkName,
@@ -440,23 +440,21 @@ async function persistDiff<K extends Id, V>(
   serializeKey: (key: K) => number | string
 ): Promise<void> {
   const persistedKeys = await dbRepo.keys();
-  const itemsToPut: {key: K; value: V}[] = [];
-  const keysToDelete: K[] = [];
+  const batch: DbBatch<K, V> = [];
 
   const persistedKeysSerialized = new Set(persistedKeys.map(serializeKey));
   for (const item of items) {
     if (!persistedKeysSerialized.has(serializeKey(item.key))) {
-      itemsToPut.push(item);
+      batch.push({type: "put", key: item.key, value: item.value});
     }
   }
 
   const targetKeysSerialized = new Set(items.map((item) => serializeKey(item.key)));
   for (const persistedKey of persistedKeys) {
     if (!targetKeysSerialized.has(serializeKey(persistedKey))) {
-      keysToDelete.push(persistedKey);
+      batch.push({type: "del", key: persistedKey});
     }
   }
 
-  if (itemsToPut.length > 0) await dbRepo.batchPut(itemsToPut);
-  if (keysToDelete.length > 0) await dbRepo.batchDelete(keysToDelete);
+  if (batch.length > 0) await dbRepo.batch(batch);
 }

package/src/chain/prepareNextSlot.ts

@@ -117,12 +117,7 @@ export class PrepareNextSlotScheduler {
         // the slot 0 of next epoch will likely use this Previous Root Checkpoint state for state transition so we transfer cache here
         // the resulting state with cache will be cached in Checkpoint State Cache which is used for the upcoming block processing
         // for other slots dontTransferCached=true because we don't run state transition on this state
-        //
-        // Shuffling calculation will be done asynchronously when passing asyncShufflingCalculation=true.  Shuffling will be queued in
-        // beforeProcessEpoch and should theoretically be ready immediately after the synchronous epoch transition finished and the
-        // event loop is free.  In long periods of non-finality too many forks will cause the shufflingCache to throw an error for
-        // too many queued shufflings so only run async during normal epoch transition. See issue ChainSafe/lodestar#7244
-        {dontTransferCache: !isEpochTransition, asyncShufflingCalculation: true},
+        {dontTransferCache: !isEpochTransition},
         RegenCaller.precomputeEpoch
       );
 
@@ -148,6 +143,7 @@ export class PrepareNextSlotScheduler {
             updatedPrepareState = (await this.chain.regen.getBlockSlotState(
               proposerHeadRoot,
               prepareSlot,
+              // only transfer cache if epoch transition because that's the state we will use to stateTransition() the 1st block of epoch
               {dontTransferCache: !isEpochTransition},
               RegenCaller.predictProposerHead
             )) as CachedBeaconStateExecutions;

package/src/chain/produceBlock/produceBlockBody.ts

@@ -661,7 +661,12 @@ export async function produceCommonBlockBody<T extends BlockType>(
     this.opPool.getSlashingsAndExits(currentState, blockType, this.metrics);
 
   const endAttestations = stepsMetrics?.startTimer();
-  const attestations = this.aggregatedAttestationPool.getAttestationsForBlock(fork, this.forkChoice, currentState);
+  const attestations = this.aggregatedAttestationPool.getAttestationsForBlock(
+    fork,
+    this.forkChoice,
+    this.shufflingCache,
+    currentState
+  );
   endAttestations?.({
     step: BlockProductionStep.attestations,
   });

package/src/chain/regen/interface.ts

@@ -31,10 +31,6 @@ export enum RegenFnName {
 
 export type StateRegenerationOpts = {
   dontTransferCache: boolean;
-  /**
-   * Do not queue shuffling calculation async. Forces sync JIT calculation in afterProcessEpoch if not passed as `true`
-   */
-  asyncShufflingCalculation?: boolean;
 };
 
 export interface IStateRegenerator extends IStateRegeneratorInternal {
@@ -90,5 +86,5 @@ export interface IStateRegeneratorInternal {
   /**
    * Return the exact state with `stateRoot`
    */
-  getState(stateRoot: RootHex, rCaller: RegenCaller, opts?: StateRegenerationOpts): Promise<CachedBeaconStateAllForks>;
+  getState(stateRoot: RootHex, rCaller: RegenCaller): Promise<CachedBeaconStateAllForks>;
 }

package/src/chain/regen/queued.ts

@@ -79,21 +79,15 @@ export class QueuedStateRegenerator implements IStateRegenerator {
 
   /**
    * Get a state from block state cache.
-   * This is not for block processing so don't transfer cache
    */
   getStateSync(stateRoot: RootHex): CachedBeaconStateAllForks | null {
-    return this.blockStateCache.get(stateRoot, {dontTransferCache: true});
+    return this.blockStateCache.get(stateRoot);
   }
 
   /**
    * Get state for block processing.
-   * By default, do not transfer cache except for the block at clock slot
-   * which is usually the gossip block.
    */
-  getPreStateSync(
-    block: BeaconBlock,
-    opts: StateRegenerationOpts = {dontTransferCache: true}
-  ): CachedBeaconStateAllForks | null {
+  getPreStateSync(block: BeaconBlock): CachedBeaconStateAllForks | null {
     const parentRoot = toRootHex(block.parentRoot);
     const parentBlock = this.forkChoice.getBlockHex(parentRoot);
     if (!parentBlock) {
@@ -108,7 +102,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
 
     // Check the checkpoint cache (if the pre-state is a checkpoint state)
     if (parentEpoch < blockEpoch) {
-      const checkpointState = this.checkpointStateCache.getLatest(parentRoot, blockEpoch, opts);
+      const checkpointState = this.checkpointStateCache.getLatest(parentRoot, blockEpoch);
       if (checkpointState && computeEpochAtSlot(checkpointState.slot) === blockEpoch) {
         return checkpointState;
       }
@@ -118,7 +112,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     // Otherwise the state transition may not be cached and wasted. Queue for regen since the
     // work required will still be significant.
     if (parentEpoch === blockEpoch) {
-      const state = this.blockStateCache.get(parentBlock.stateRoot, opts);
+      const state = this.blockStateCache.get(parentBlock.stateRoot);
       if (state) {
         return state;
       }
@@ -132,21 +126,17 @@ export class QueuedStateRegenerator implements IStateRegenerator {
   }
 
   /**
-   * Get checkpoint state from cache, this function is not for block processing so don't transfer cache
+   * Get checkpoint state from cache
    */
   getCheckpointStateSync(cp: CheckpointHex): CachedBeaconStateAllForks | null {
-    return this.checkpointStateCache.get(cp, {dontTransferCache: true});
+    return this.checkpointStateCache.get(cp);
   }
 
   /**
-   * Get state closest to head, this function is not for block processing so don't transfer cache
+   * Get state closest to head
    */
   getClosestHeadState(head: ProtoBlock): CachedBeaconStateAllForks | null {
-    const opts = {dontTransferCache: true};
-    return (
-      this.checkpointStateCache.getLatest(head.blockRoot, Infinity, opts) ||
-      this.blockStateCache.get(head.stateRoot, opts)
-    );
+    return this.checkpointStateCache.getLatest(head.blockRoot, Infinity) || this.blockStateCache.get(head.stateRoot);
   }
 
   pruneOnCheckpoint(finalizedEpoch: Epoch, justifiedEpoch: Epoch, headStateRoot: RootHex): void {
@@ -181,10 +171,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
       maybeHeadStateRoot,
     };
     const headState =
-      newHeadStateRoot === maybeHeadStateRoot
-        ? maybeHeadState
-        : // maybeHeadState was already in block state cache so we don't transfer the cache
-          this.blockStateCache.get(newHeadStateRoot, {dontTransferCache: true});
+      newHeadStateRoot === maybeHeadStateRoot ? maybeHeadState : this.blockStateCache.get(newHeadStateRoot);
 
     if (headState) {
       this.blockStateCache.setHeadState(headState);
@@ -199,9 +186,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
 
       // for the new FIFOBlockStateCache, it's important to reload state to regen head state here if needed
       const allowDiskReload = true;
-      // transfer cache here because we want to regen state asap
-      const cloneOpts = {dontTransferCache: false};
-      this.regen.getState(newHeadStateRoot, RegenCaller.processBlock, cloneOpts, allowDiskReload).then(
+      this.regen.getState(newHeadStateRoot, RegenCaller.processBlock, allowDiskReload).then(
         (headStateRegen) => this.blockStateCache.setHeadState(headStateRegen),
         (e) => this.logger.error("Error on head state regen", logCtx, e)
       );
@@ -224,7 +209,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.metrics?.regenFnCallTotal.inc({caller: rCaller, entrypoint: RegenFnName.getPreState});
 
     // First attempt to fetch the state from caches before queueing
-    const cachedState = this.getPreStateSync(block, opts);
+    const cachedState = this.getPreStateSync(block);
 
     if (cachedState !== null) {
       return cachedState;
@@ -243,7 +228,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.metrics?.regenFnCallTotal.inc({caller: rCaller, entrypoint: RegenFnName.getCheckpointState});
 
     // First attempt to fetch the state from cache before queueing
-    const checkpointState = this.checkpointStateCache.get(toCheckpointHex(cp), opts);
+    const checkpointState = this.checkpointStateCache.get(toCheckpointHex(cp));
     if (checkpointState) {
       return checkpointState;
     }
@@ -271,22 +256,18 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return this.jobQueue.push({key: "getBlockSlotState", args: [blockRoot, slot, opts, rCaller]});
   }
 
-  async getState(
-    stateRoot: RootHex,
-    rCaller: RegenCaller,
-    opts: StateRegenerationOpts = {dontTransferCache: true}
-  ): Promise<CachedBeaconStateAllForks> {
+  async getState(stateRoot: RootHex, rCaller: RegenCaller): Promise<CachedBeaconStateAllForks> {
     this.metrics?.regenFnCallTotal.inc({caller: rCaller, entrypoint: RegenFnName.getState});
 
     // First attempt to fetch the state from cache before queueing
-    const state = this.blockStateCache.get(stateRoot, opts);
+    const state = this.blockStateCache.get(stateRoot);
     if (state) {
       return state;
     }
 
     // The state is not immediately available in the cache, enqueue the job
     this.metrics?.regenFnQueuedTotal.inc({caller: rCaller, entrypoint: RegenFnName.getState});
-    return this.jobQueue.push({key: "getState", args: [stateRoot, rCaller, opts]});
+    return this.jobQueue.push({key: "getState", args: [stateRoot, rCaller]});
   }
 
   private jobQueueProcessor = async (regenRequest: RegenRequest): Promise<CachedBeaconStateAllForks> => {

package/src/chain/regen/regen.ts

@@ -78,7 +78,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     }
 
     // Otherwise, get the state normally.
-    return this.getState(parentBlock.stateRoot, regenCaller, opts, allowDiskReload);
+    return this.getState(parentBlock.stateRoot, regenCaller, allowDiskReload);
   }
 
   /**
@@ -124,8 +124,8 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     const {checkpointStateCache} = this.modules;
     const epoch = computeEpochAtSlot(slot);
     const latestCheckpointStateCtx = allowDiskReload
-      ? await checkpointStateCache.getOrReloadLatest(blockRoot, epoch, opts)
-      : checkpointStateCache.getLatest(blockRoot, epoch, opts);
+      ? await checkpointStateCache.getOrReloadLatest(blockRoot, epoch)
+      : checkpointStateCache.getLatest(blockRoot, epoch);
 
     // If a checkpoint state exists with the given checkpoint root, it either is in requested epoch
     // or needs to have empty slots processed until the requested epoch
@@ -136,7 +136,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     // Otherwise, use the fork choice to get the stateRoot from block at the checkpoint root
     // regenerate that state,
     // then process empty slots until the requested epoch
-    const blockStateCtx = await this.getState(block.stateRoot, regenCaller, opts, allowDiskReload);
+    const blockStateCtx = await this.getState(block.stateRoot, regenCaller, allowDiskReload);
     return processSlotsByCheckpoint(this.modules, blockStateCtx, slot, regenCaller, opts);
   }
 
@@ -148,23 +148,15 @@ export class StateRegenerator implements IStateRegeneratorInternal {
   async getState(
     stateRoot: RootHex,
     caller: RegenCaller,
-    opts?: StateRegenerationOpts,
     // internal option, don't want to expose to external caller
     allowDiskReload = false
   ): Promise<CachedBeaconStateAllForks> {
     // Trivial case, state at stateRoot is already cached
-    const cachedStateCtx = this.modules.blockStateCache.get(stateRoot, opts);
+    const cachedStateCtx = this.modules.blockStateCache.get(stateRoot);
     if (cachedStateCtx) {
       return cachedStateCtx;
     }
 
-    // in block gossip validation (getPreState() call), dontTransferCache is specified as true because we only want to transfer cache in verifyBlocksStateTransitionOnly()
-    // but here we want to process blocks as fast as possible so force to transfer cache in this case
-    if (opts && allowDiskReload) {
-      // if there is no `opts` specified, it already means "false"
-      opts.dontTransferCache = false;
-    }
-
     // Otherwise we have to use the fork choice to traverse backwards, block by block,
     // searching the state caches
     // then replay blocks forward to the desired stateRoot
@@ -179,7 +171,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
     const getSeedStateTimer = this.modules.metrics?.regenGetState.getSeedState.startTimer({caller});
     // iterateAncestorBlocks only returns ancestor blocks, not the block itself
     for (const b of this.modules.forkChoice.iterateAncestorBlocks(block.blockRoot)) {
-      state = this.modules.blockStateCache.get(b.stateRoot, opts);
+      state = this.modules.blockStateCache.get(b.stateRoot);
       if (state) {
         break;
       }
@@ -187,8 +179,8 @@ export class StateRegenerator implements IStateRegeneratorInternal {
       if (!lastBlockToReplay) continue;
       const epoch = computeEpochAtSlot(lastBlockToReplay.slot - 1);
       state = allowDiskReload
-        ? await checkpointStateCache.getOrReloadLatest(b.blockRoot, epoch, opts)
-        : checkpointStateCache.getLatest(b.blockRoot, epoch, opts);
+        ? await checkpointStateCache.getOrReloadLatest(b.blockRoot, epoch)
+        : checkpointStateCache.getLatest(b.blockRoot, epoch);
       if (state) {
         break;
       }
@@ -255,6 +247,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
       try {
         // Only advances state trusting block's signture and hashes.
         // We are only running the state transition to get a specific state's data.
+        // stateTransition() does the clone() inside, transfer cache to make the regen faster
         state = stateTransition(
           state,
           block,
@@ -265,6 +258,7 @@ export class StateRegenerator implements IStateRegeneratorInternal {
             verifyStateRoot: false,
             verifyProposer: false,
             verifySignatures: false,
+            dontTransferCache: false,
           },
           this.modules
         );
@@ -390,8 +384,8 @@ export async function processSlotsToNearestCheckpoint(
     const checkpointState = postState;
     const cp = getCheckpointFromState(checkpointState);
     checkpointStateCache.add(cp, checkpointState);
-    // consumers should not mutate or get the transfered cache
-    emitter?.emit(ChainEvent.checkpoint, cp, checkpointState.clone(true));
+    // consumers should not mutate state ever
+    emitter?.emit(ChainEvent.checkpoint, cp, checkpointState);
 
     if (count >= 1) {
       // in normal condition, we only process 1 epoch so never reach this