@lodestar/beacon-node 1.39.1 → 1.40.0-dev.193b2e2047

package/src/chain/opPools/executionPayloadBidPool.ts

@@ -0,0 +1,77 @@
+import {Slot, gloas} from "@lodestar/types";
+import {MapDef, toRootHex} from "@lodestar/utils";
+import {InsertOutcome} from "./types.js";
+import {pruneBySlot} from "./utils.js";
+
+/**
+ * TODO GLOAS: Revisit this value and add rational for choosing it
+ */
+const SLOTS_RETAINED = 2;
+
+type BlockRootHex = string;
+type BlockHashHex = string;
+
+/**
+ * Store the best execution payload bid per slot / (parent block root, parent block hash).
+ */
+export class ExecutionPayloadBidPool {
+  private readonly bidByParentHashByParentRootBySlot = new MapDef<
+    Slot,
+    MapDef<BlockRootHex, Map<BlockHashHex, gloas.ExecutionPayloadBid>>
+  >(() => new MapDef<BlockRootHex, Map<BlockHashHex, gloas.ExecutionPayloadBid>>(() => new Map()));
+  private lowestPermissibleSlot = 0;
+
+  get size(): number {
+    let count = 0;
+    for (const byParentRoot of this.bidByParentHashByParentRootBySlot.values()) {
+      for (const byParentHash of byParentRoot.values()) {
+        count += byParentHash.size;
+      }
+    }
+    return count;
+  }
+
+  add(bid: gloas.ExecutionPayloadBid): InsertOutcome {
+    const {slot, parentBlockRoot, parentBlockHash, value} = bid;
+    const lowestPermissibleSlot = this.lowestPermissibleSlot;
+
+    if (slot < lowestPermissibleSlot) {
+      return InsertOutcome.Old;
+    }
+
+    const parentRootHex = toRootHex(parentBlockRoot);
+    const parentHashHex = toRootHex(parentBlockHash);
+    const bidByParentHash = this.bidByParentHashByParentRootBySlot.getOrDefault(slot).getOrDefault(parentRootHex);
+    const existing = bidByParentHash.get(parentHashHex);
+
+    if (existing) {
+      const existingValue = existing.value;
+      const newValue = value;
+      if (newValue > existingValue) {
+        bidByParentHash.set(parentHashHex, bid);
+        return InsertOutcome.NewData;
+      }
+      return newValue === existingValue ? InsertOutcome.AlreadyKnown : InsertOutcome.NotBetterThan;
+    }
+
+    bidByParentHash.set(parentHashHex, bid);
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Return the highest-value bid matching slot, parent block root, and parent block hash.
+   * Used for gossip validation and block production.
+   */
+  getBestBid(
+    parentBlockRoot: BlockRootHex,
+    parentBlockHash: BlockHashHex,
+    slot: Slot
+  ): gloas.ExecutionPayloadBid | null {
+    const bidByParentHash = this.bidByParentHashByParentRootBySlot.get(slot)?.get(parentBlockRoot);
+    return bidByParentHash?.get(parentBlockHash) ?? null;
+  }
+
+  prune(clockSlot: Slot): void {
+    this.lowestPermissibleSlot = pruneBySlot(this.bidByParentHashByParentRootBySlot, clockSlot, SLOTS_RETAINED);
+  }
+}

package/src/chain/opPools/index.ts

@@ -1,5 +1,7 @@
 export {AggregatedAttestationPool} from "./aggregatedAttestationPool.js";
 export {AttestationPool} from "./attestationPool.js";
+export {ExecutionPayloadBidPool} from "./executionPayloadBidPool.js";
 export {OpPool} from "./opPool.js";
+export {PayloadAttestationPool} from "./payloadAttestationPool.js";
 export {SyncCommitteeMessagePool} from "./syncCommitteeMessagePool.js";
 export {SyncContributionAndProofPool} from "./syncContributionAndProofPool.js";

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/opPools/payloadAttestationPool.ts

@@ -0,0 +1,157 @@
+import {Signature, aggregateSignatures} from "@chainsafe/blst";
+import {BitArray} from "@chainsafe/ssz";
+import {ChainForkConfig} from "@lodestar/config";
+import {MAX_COMMITTEES_PER_SLOT, PTC_SIZE} from "@lodestar/params";
+import {RootHex, Slot, gloas} from "@lodestar/types";
+import {MapDef, toRootHex} from "@lodestar/utils";
+import {Metrics} from "../../metrics/metrics.js";
+import {IClock} from "../../util/clock.js";
+import {InsertOutcome, OpPoolError, OpPoolErrorCode} from "./types.js";
+import {pruneBySlot, signatureFromBytesNoCheck} from "./utils.js";
+
+/**
+ * TODO GLOAS: Revisit this value and add rational for choosing it
+ */
+const SLOTS_RETAINED = 2;
+
+/**
+ * The maximum number of distinct `PayloadAttestationData` that will be stored in each slot.
+ *
+ * This is a DoS protection measure.
+ */
+// TODO GLOAS: Revisit this value. Educated guess would be MAX_ATTESTATIONS_PER_SLOT in AttestationPool divided by MAX_COMMITTEES_PER_SLOT
+const MAX_PAYLOAD_ATTESTATIONS_PER_SLOT = 16_384 / MAX_COMMITTEES_PER_SLOT;
+
+type DataRootHex = string;
+type BlockRootHex = string;
+
+type AggregateFast = {
+  aggregationBits: BitArray;
+  data: gloas.PayloadAttestationData;
+  signature: Signature;
+};
+
+export class PayloadAttestationPool {
+  private readonly aggregateByDataRootByBlockRootBySlot = new MapDef<
+    Slot,
+    Map<BlockRootHex, Map<DataRootHex, AggregateFast>>
+  >(() => new Map<BlockRootHex, Map<DataRootHex, AggregateFast>>());
+  private lowestPermissibleSlot = 0;
+
+  constructor(
+    private readonly config: ChainForkConfig,
+    private readonly clock: IClock,
+    private readonly metrics: Metrics | null = null
+  ) {}
+
+  get size(): number {
+    let count = 0;
+    for (const aggregateByDataRootByBlockRoot of this.aggregateByDataRootByBlockRootBySlot.values()) {
+      for (const aggregateByDataRoot of aggregateByDataRootByBlockRoot.values()) {
+        count += aggregateByDataRoot.size;
+      }
+    }
+    return count;
+  }
+
+  add(
+    message: gloas.PayloadAttestationMessage,
+    payloadAttDataRootHex: RootHex,
+    validatorCommitteeIndex: number
+  ): InsertOutcome {
+    const slot = message.data.slot;
+    const lowestPermissibleSlot = this.lowestPermissibleSlot;
+
+    if (slot < lowestPermissibleSlot) {
+      return InsertOutcome.Old;
+    }
+
+    if (slot < this.clock.slotWithPastTolerance(this.config.MAXIMUM_GOSSIP_CLOCK_DISPARITY / 1000)) {
+      return InsertOutcome.Late;
+    }
+
+    const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.getOrDefault(slot);
+    let aggregateByDataRoot = aggregateByDataRootByBlockRoot.get(toRootHex(message.data.beaconBlockRoot));
+
+    if (!aggregateByDataRoot) {
+      aggregateByDataRoot = new Map<DataRootHex, AggregateFast>();
+      aggregateByDataRootByBlockRoot.set(toRootHex(message.data.beaconBlockRoot), aggregateByDataRoot);
+    }
+
+    if (aggregateByDataRoot.size >= MAX_PAYLOAD_ATTESTATIONS_PER_SLOT) {
+      throw new OpPoolError({code: OpPoolErrorCode.REACHED_MAX_PER_SLOT});
+    }
+
+    const aggregate = aggregateByDataRoot.get(payloadAttDataRootHex);
+    if (aggregate) {
+      // Aggregate msg into aggregate
+      return aggregateMessageInto(message, validatorCommitteeIndex, aggregate);
+    }
+    // Create a new aggregate with data
+    aggregateByDataRoot.set(payloadAttDataRootHex, messageToAggregate(message, validatorCommitteeIndex));
+
+    return InsertOutcome.NewData;
+  }
+
+  /**
+   * Get payload attestations to be included in a block.
+   * Pick the top `maxAttestation` number of attestations with the most votes
+   */
+  getPayloadAttestationsForBlock(
+    beaconBlockRoot: BlockRootHex,
+    slot: Slot,
+    maxAttestation: number
+  ): gloas.PayloadAttestation[] {
+    const aggregateByDataRootByBlockRoot = this.aggregateByDataRootByBlockRootBySlot.get(slot);
+
+    if (!aggregateByDataRootByBlockRoot) {
+      this.metrics?.opPool.payloadAttestationPool.getPayloadAttestationsCacheMisses.inc();
+      return [];
+    }
+
+    const aggregateByDataRoot = aggregateByDataRootByBlockRoot.get(beaconBlockRoot);
+
+    if (!aggregateByDataRoot) {
+      this.metrics?.opPool.payloadAttestationPool.getPayloadAttestationsCacheMisses.inc();
+      return [];
+    }
+
+    return Array.from(aggregateByDataRoot.values())
+      .slice()
+      .sort((a, b) => b.aggregationBits.getTrueBitIndexes().length - a.aggregationBits.getTrueBitIndexes().length)
+      .slice(0, maxAttestation)
+      .map(fastToPayloadAttestation);
+  }
+
+  prune(clockSlot: Slot): void {
+    pruneBySlot(this.aggregateByDataRootByBlockRootBySlot, clockSlot, SLOTS_RETAINED);
+    this.lowestPermissibleSlot = clockSlot;
+  }
+}
+
+function messageToAggregate(message: gloas.PayloadAttestationMessage, validatorCommitteeIndex: number): AggregateFast {
+  return {
+    aggregationBits: BitArray.fromSingleBit(PTC_SIZE, validatorCommitteeIndex),
+    data: message.data,
+    signature: signatureFromBytesNoCheck(message.signature),
+  };
+}
+
+function aggregateMessageInto(
+  message: gloas.PayloadAttestationMessage,
+  validatorCommitteeIndex: number,
+  aggregate: AggregateFast
+): InsertOutcome {
+  if (aggregate.aggregationBits.get(validatorCommitteeIndex) === true) {
+    return InsertOutcome.AlreadyKnown;
+  }
+
+  aggregate.aggregationBits.set(validatorCommitteeIndex, true);
+  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(message.signature)]);
+
+  return InsertOutcome.Aggregated;
+}
+
+function fastToPayloadAttestation(aggFast: AggregateFast): gloas.PayloadAttestation {
+  return {...aggFast, signature: aggFast.signature.toBytes()};
+}

package/src/chain/prepareNextSlot.ts

@@ -80,9 +80,8 @@ export class PrepareNextSlotScheduler {
       await sleep(this.config.getSlotComponentDurationMs(PREPARE_NEXT_SLOT_BPS), this.signal);
 
       // calling updateHead() here before we produce a block to reduce reorg possibility
-      const {slot: headSlot, blockRoot: headRoot} = this.chain.recomputeForkChoiceHead(
-        ForkchoiceCaller.prepareNextSlot
-      );
+      const headBlock = this.chain.recomputeForkChoiceHead(ForkchoiceCaller.prepareNextSlot);
+      const {slot: headSlot, blockRoot: headRoot} = headBlock;
 
       // PS: previously this was comparing slots, but that gave no leway on the skipped
       // slots on epoch bounday. Making it more fluid.
@@ -112,17 +111,12 @@ export class PrepareNextSlotScheduler {
       // Pre Bellatrix: we only do precompute state transition for the last slot of epoch
       // For Bellatrix, we always do the `processSlots()` to prepare payload for the next slot
       const prepareState = await this.chain.regen.getBlockSlotState(
-        headRoot,
+        headBlock,
         prepareSlot,
         // 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
       );
 
@@ -134,7 +128,8 @@ export class PrepareNextSlotScheduler {
 
         if (feeRecipient) {
           // If we are proposing next slot, we need to predict if we can proposer-boost-reorg or not
-          const {slot: proposerHeadSlot, blockRoot: proposerHeadRoot} = this.chain.predictProposerHead(clockSlot);
+          const proposerHead = this.chain.predictProposerHead(clockSlot);
+          const {slot: proposerHeadSlot, blockRoot: proposerHeadRoot} = proposerHead;
 
           // If we predict we can reorg, update prepareState with proposer head block
           if (proposerHeadRoot !== headRoot || proposerHeadSlot !== headSlot) {
@@ -146,8 +141,9 @@ export class PrepareNextSlotScheduler {
             });
             this.metrics?.weakHeadDetected.inc();
             updatedPrepareState = (await this.chain.regen.getBlockSlotState(
-              proposerHeadRoot,
+              proposerHead,
               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

@@ -1,5 +1,5 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {getSafeExecutionBlockHash} from "@lodestar/fork-choice";
+import {ProtoBlock, getSafeExecutionBlockHash} from "@lodestar/fork-choice";
 import {
   ForkName,
   ForkPostBellatrix,
@@ -43,7 +43,7 @@ import {
   electra,
   fulu,
 } from "@lodestar/types";
-import {Logger, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
+import {Logger, fromHex, sleep, toHex, toPubkeyHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {numToQuantity} from "../../execution/engine/utils.js";
 import {
@@ -86,7 +86,7 @@ export type BlockAttributes = {
   randaoReveal: BLSSignature;
   graffiti: Bytes32;
   slot: Slot;
-  parentBlockRoot: Root;
+  parentBlock: ProtoBlock;
   feeRecipient?: string;
 };
 
@@ -155,13 +155,14 @@ export async function produceBlockBody<T extends BlockType>(
   const {
     slot: blockSlot,
     feeRecipient: requestedFeeRecipient,
-    parentBlockRoot,
+    parentBlock,
     proposerIndex,
     proposerPubKey,
     commonBlockBodyPromise,
   } = blockAttr;
   let executionPayloadValue: Wei;
   let blockBody: AssembledBodyType<T>;
+  const parentBlockRoot = fromHex(parentBlock.blockRoot);
   // even though shouldOverrideBuilder is relevant for the engine response, for simplicity of typing
   // we just return it undefined for the builder which anyway doesn't get consumed downstream
   let shouldOverrideBuilder: boolean | undefined;
@@ -637,7 +638,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
   this: BeaconChain,
   blockType: T,
   currentState: CachedBeaconStateAllForks,
-  {randaoReveal, graffiti, slot, parentBlockRoot}: BlockAttributes
+  {randaoReveal, graffiti, slot, parentBlock}: BlockAttributes
 ): Promise<CommonBlockBody> {
   const stepsMetrics =
     blockType === BlockType.Full
@@ -661,7 +662,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,
   });
@@ -686,6 +692,7 @@ export async function produceCommonBlockBody<T extends BlockType>(
 
   const endSyncAggregate = stepsMetrics?.startTimer();
   if (ForkSeq[fork] >= ForkSeq.altair) {
+    const parentBlockRoot = fromHex(parentBlock.blockRoot);
     const previousSlot = slot - 1;
     const syncAggregate = this.syncContributionAndProofPool.getAggregate(previousSlot, parentBlockRoot);
     this.metrics?.production.producedSyncAggregateParticipants.observe(

package/src/chain/regen/interface.ts

@@ -18,6 +18,7 @@ export enum RegenCaller {
   validateGossipAggregateAndProof = "validateGossipAggregateAndProof",
   validateGossipAttestation = "validateGossipAttestation",
   validateGossipVoluntaryExit = "validateGossipVoluntaryExit",
+  validateGossipExecutionPayloadBid = "validateGossipExecutionPayloadBid",
   onForkChoiceFinalized = "onForkChoiceFinalized",
   restApi = "restApi",
 }
@@ -26,15 +27,10 @@ export enum RegenFnName {
   getBlockSlotState = "getBlockSlotState",
   getState = "getState",
   getPreState = "getPreState",
-  getCheckpointState = "getCheckpointState",
 }
 
 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 {
@@ -67,21 +63,11 @@ export interface IStateRegeneratorInternal {
     rCaller: RegenCaller
   ): Promise<CachedBeaconStateAllForks>;
 
-  /**
-   * Return a valid checkpoint state
-   * This will always return a state with `state.slot % SLOTS_PER_EPOCH === 0`
-   */
-  getCheckpointState(
-    cp: phase0.Checkpoint,
-    opts: StateRegenerationOpts,
-    rCaller: RegenCaller
-  ): Promise<CachedBeaconStateAllForks>;
-
   /**
    * Return the state of `blockRoot` processed to slot `slot`
    */
   getBlockSlotState(
-    blockRoot: RootHex,
+    block: ProtoBlock,
     slot: Slot,
     opts: StateRegenerationOpts,
     rCaller: RegenCaller
@@ -90,5 +76,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

@@ -5,7 +5,7 @@ import {BeaconBlock, Epoch, RootHex, Slot, phase0} from "@lodestar/types";
 import {Logger, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {JobItemQueue} from "../../util/queue/index.js";
-import {CheckpointHex, toCheckpointHex} from "../stateCache/index.js";
+import {CheckpointHex} from "../stateCache/index.js";
 import {BlockStateCache, CheckpointStateCache} from "../stateCache/types.js";
 import {RegenError, RegenErrorCode} from "./errors.js";
 import {
@@ -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;
@@ -235,24 +220,6 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     return this.jobQueue.push({key: "getPreState", args: [block, opts, rCaller]});
   }
 
-  async getCheckpointState(
-    cp: phase0.Checkpoint,
-    opts: StateRegenerationOpts,
-    rCaller: RegenCaller
-  ): Promise<CachedBeaconStateAllForks> {
-    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);
-    if (checkpointState) {
-      return checkpointState;
-    }
-
-    // The state is not immediately available in the caches, enqueue the job
-    this.metrics?.regenFnQueuedTotal.inc({caller: rCaller, entrypoint: RegenFnName.getCheckpointState});
-    return this.jobQueue.push({key: "getCheckpointState", args: [cp, opts, rCaller]});
-  }
-
   /**
    * Get state of provided `blockRoot` and dial forward to `slot`
    * Use this api with care because we don't want the queue to be busy
@@ -260,7 +227,7 @@ export class QueuedStateRegenerator implements IStateRegenerator {
    * @returns
    */
   async getBlockSlotState(
-    blockRoot: RootHex,
+    block: ProtoBlock,
     slot: Slot,
     opts: StateRegenerationOpts,
     rCaller: RegenCaller
@@ -268,25 +235,21 @@ export class QueuedStateRegenerator implements IStateRegenerator {
     this.metrics?.regenFnCallTotal.inc({caller: rCaller, entrypoint: RegenFnName.getBlockSlotState});
 
     // The state is not immediately available in the caches, enqueue the job
-    return this.jobQueue.push({key: "getBlockSlotState", args: [blockRoot, slot, opts, rCaller]});
+    return this.jobQueue.push({key: "getBlockSlotState", args: [block, 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> => {
@@ -300,8 +263,6 @@ export class QueuedStateRegenerator implements IStateRegenerator {
       switch (regenRequest.key) {
         case "getPreState":
           return await this.regen.getPreState(...regenRequest.args);
-        case "getCheckpointState":
-          return await this.regen.getCheckpointState(...regenRequest.args);
         case "getBlockSlotState":
           return await this.regen.getBlockSlotState(...regenRequest.args);
         case "getState":