@lodestar/beacon-node 1.39.0-dev.075956b855 → 1.39.0-dev.0bce7eb9f1

package/src/chain/stateCache/fifoBlockStateCache.ts

@@ -4,7 +4,6 @@ import {RootHex} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
 import {LinkedList} from "../../util/array.js";
-import {StateRegenerationOpts} from "../regen/interface.js";
 import {MapTracker} from "./mapMetrics.js";
 import {BlockStateCache} from "./types.js";
 
@@ -86,14 +85,14 @@ export class FIFOBlockStateCache implements BlockStateCache {
     }
 
     const firstState = firstValue.value;
-    // don't transfer cache because consumer only use this cache to reload another state from disc
-    return firstState.clone(true);
+    // consumers should not mutate the returned state
+    return firstState;
   }
 
   /**
    * Get a state from this cache given a state root hex.
    */
-  get(rootHex: RootHex, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null {
+  get(rootHex: RootHex): CachedBeaconStateAllForks | null {
     this.metrics?.lookups.inc();
     const item = this.cache.get(rootHex);
     if (!item) {
@@ -103,7 +102,7 @@ export class FIFOBlockStateCache implements BlockStateCache {
     this.metrics?.hits.inc();
     this.metrics?.stateClonedCount.observe(item.clonedCount);
 
-    return item.clone(opts?.dontTransferCache);
+    return item;
   }
 
   /**

package/src/chain/stateCache/inMemoryCheckpointsCache.ts

@@ -3,7 +3,6 @@ import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
 import {Epoch, RootHex, phase0} from "@lodestar/types";
 import {MapDef, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
-import {StateRegenerationOpts} from "../regen/interface.js";
 import {MapTracker} from "./mapMetrics.js";
 import {CacheItemType, CheckpointStateCache} from "./types.js";
 
@@ -42,21 +41,16 @@ export class InMemoryCheckpointStateCache implements CheckpointStateCache {
     this.maxEpochs = maxEpochs;
   }
 
-  async getOrReload(cp: CheckpointHex, opts?: StateRegenerationOpts): Promise<CachedBeaconStateAllForks | null> {
-    return this.get(cp, opts);
+  async getOrReload(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | null> {
+    return this.get(cp);
   }
 
   async getStateOrBytes(cp: CheckpointHex): Promise<Uint8Array | CachedBeaconStateAllForks | null> {
-    // no need to transfer cache for this api
-    return this.get(cp, {dontTransferCache: true});
+    return this.get(cp);
   }
 
-  async getOrReloadLatest(
-    rootHex: string,
-    maxEpoch: number,
-    opts?: StateRegenerationOpts
-  ): Promise<CachedBeaconStateAllForks | null> {
-    return this.getLatest(rootHex, maxEpoch, opts);
+  async getOrReloadLatest(rootHex: string, maxEpoch: number): Promise<CachedBeaconStateAllForks | null> {
+    return this.getLatest(rootHex, maxEpoch);
   }
 
   async processState(): Promise<number> {
@@ -64,7 +58,7 @@ export class InMemoryCheckpointStateCache implements CheckpointStateCache {
     return 0;
   }
 
-  get(cp: CheckpointHex, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null {
+  get(cp: CheckpointHex): CachedBeaconStateAllForks | null {
     this.metrics?.lookups.inc();
     const cpKey = toCheckpointKey(cp);
     const item = this.cache.get(cpKey);
@@ -81,7 +75,7 @@ export class InMemoryCheckpointStateCache implements CheckpointStateCache {
 
     this.metrics?.stateClonedCount.observe(item.clonedCount);
 
-    return item.clone(opts?.dontTransferCache);
+    return item;
   }
 
   add(cp: phase0.Checkpoint, item: CachedBeaconStateAllForks): void {
@@ -98,14 +92,14 @@ export class InMemoryCheckpointStateCache implements CheckpointStateCache {
   /**
    * Searches for the latest cached state with a `root`, starting with `epoch` and descending
    */
-  getLatest(rootHex: RootHex, maxEpoch: Epoch, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null {
+  getLatest(rootHex: RootHex, maxEpoch: Epoch): CachedBeaconStateAllForks | null {
     // 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.epochIndex.get(epoch)?.has(rootHex)) {
-        return this.get({rootHex, epoch}, opts);
+        return this.get({rootHex, epoch});
       }
     }
     return null;

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -11,7 +11,6 @@ import {Logger, MapDef, fromHex, sleep, toHex, toRootHex} from "@lodestar/utils"
 import {Metrics} from "../../metrics/index.js";
 import {AllocSource, BufferPool, BufferWithKey} from "../../util/bufferPool.js";
 import {IClock} from "../../util/clock.js";
-import {StateRegenerationOpts} from "../regen/interface.js";
 import {serializeState} from "../serializeState.js";
 import {CPStateDatastore, DatastoreKey} from "./datastore/index.js";
 import {MapTracker} from "./mapMetrics.js";
@@ -204,10 +203,10 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * - Get block for processing
    * - Regen head state
    */
-  async getOrReload(cp: CheckpointHex, opts?: StateRegenerationOpts): Promise<CachedBeaconStateAllForks | null> {
-    const stateOrStateBytesData = await this.getStateOrLoadDb(cp, opts);
+  async getOrReload(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | null> {
+    const stateOrStateBytesData = await this.getStateOrLoadDb(cp);
     if (stateOrStateBytesData === null || isCachedBeaconState(stateOrStateBytesData)) {
-      return stateOrStateBytesData?.clone(opts?.dontTransferCache) ?? null;
+      return stateOrStateBytesData ?? null;
     }
     const {persistedKey, stateBytes} = stateOrStateBytesData;
     const logMeta = {persistedKey: toHex(persistedKey)};
@@ -233,7 +232,8 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       sszTimer?.();
       const timer = this.metrics?.cpStateCache.stateReloadDuration.startTimer();
       const newCachedState = loadCachedBeaconState(seedState, stateBytes, {}, validatorsBytes);
-      newCachedState.commit();
+      // 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());
       timer?.();
 
@@ -252,7 +252,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.cache.set(cpKey, {type: CacheItemType.inMemory, state: newCachedState, persistedKey});
       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.clone(opts?.dontTransferCache);
+      return newCachedState;
     } catch (e) {
       this.logger.debug("Reload: error loading cached state", logMeta, e as Error);
       return null;
@@ -263,8 +263,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * Return either state or state bytes loaded from db.
    */
   async getStateOrBytes(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | Uint8Array | null> {
-    // don't have to transfer cache for this specific api
-    const stateOrLoadedState = await this.getStateOrLoadDb(cp, {dontTransferCache: true});
+    const stateOrLoadedState = await this.getStateOrLoadDb(cp);
     if (stateOrLoadedState === null || isCachedBeaconState(stateOrLoadedState)) {
       return stateOrLoadedState;
     }
@@ -274,12 +273,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Return either state or state bytes with persisted key loaded from db.
    */
-  async getStateOrLoadDb(
-    cp: CheckpointHex,
-    opts?: StateRegenerationOpts
-  ): Promise<CachedBeaconStateAllForks | LoadedStateBytesData | null> {
+  async getStateOrLoadDb(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | LoadedStateBytesData | null> {
     const cpKey = toCacheKey(cp);
-    const inMemoryState = this.get(cpKey, opts);
+    const inMemoryState = this.get(cpKey);
     if (inMemoryState) {
       return inMemoryState;
     }
@@ -308,7 +304,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Similar to get() api without reloading from disk
    */
-  get(cpOrKey: CheckpointHex | string, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null {
+  get(cpOrKey: CheckpointHex | string): CachedBeaconStateAllForks | null {
     this.metrics?.cpStateCache.lookups.inc();
     const cpKey = typeof cpOrKey === "string" ? cpOrKey : toCacheKey(cpOrKey);
     const cacheItem = this.cache.get(cpKey);
@@ -326,7 +322,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     if (isInMemoryCacheItem(cacheItem)) {
       const {state} = cacheItem;
       this.metrics?.cpStateCache.stateClonedCount.observe(state.clonedCount);
-      return state.clone(opts?.dontTransferCache);
+      return state;
     }
 
     return null;
@@ -360,14 +356,14 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Searches in-memory state for the latest cached state with a `root` without reload, starting with `epoch` and descending
    */
-  getLatest(rootHex: RootHex, maxEpoch: Epoch, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null {
+  getLatest(rootHex: RootHex, maxEpoch: Epoch): CachedBeaconStateAllForks | null {
     // 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.epochIndex.get(epoch)?.has(rootHex)) {
-        const inMemoryClonedState = this.get({rootHex, epoch}, opts);
+        const inMemoryClonedState = this.get({rootHex, epoch});
         if (inMemoryClonedState) {
           return inMemoryClonedState;
         }
@@ -383,11 +379,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * - Get block for processing
    * - Regen head state
    */
-  async getOrReloadLatest(
-    rootHex: RootHex,
-    maxEpoch: Epoch,
-    opts?: StateRegenerationOpts
-  ): Promise<CachedBeaconStateAllForks | null> {
+  async getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch): Promise<CachedBeaconStateAllForks | null> {
     // sort epochs in descending order, only consider epochs lte `epoch`
     const epochs = Array.from(this.epochIndex.keys())
       .sort((a, b) => b - a)
@@ -395,9 +387,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     for (const epoch of epochs) {
       if (this.epochIndex.get(epoch)?.has(rootHex)) {
         try {
-          const clonedState = await this.getOrReload({rootHex, epoch}, opts);
-          if (clonedState) {
-            return clonedState;
+          const state = await this.getOrReload({rootHex, epoch});
+          if (state) {
+            return state;
           }
         } catch (e) {
           this.logger.debug("Error get or reload state", {epoch, rootHex}, e as Error);

package/src/chain/stateCache/types.ts

@@ -1,7 +1,6 @@
 import {routes} from "@lodestar/api";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
 import {Epoch, RootHex, phase0} from "@lodestar/types";
-import {StateRegenerationOpts} from "../regen/interface.js";
 
 export type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
 
@@ -21,7 +20,7 @@ export type CheckpointHex = {epoch: Epoch; rootHex: RootHex};
  * The cache key is state root
  */
 export interface BlockStateCache {
-  get(rootHex: RootHex, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null;
+  get(rootHex: RootHex): CachedBeaconStateAllForks | null;
   add(item: CachedBeaconStateAllForks): void;
   setHeadState(item: CachedBeaconStateAllForks | null): void;
   /**
@@ -60,16 +59,12 @@ export interface BlockStateCache {
  */
 export interface CheckpointStateCache {
   init?: () => Promise<void>;
-  getOrReload(cp: CheckpointHex, opts?: StateRegenerationOpts): Promise<CachedBeaconStateAllForks | null>;
+  getOrReload(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | null>;
   getStateOrBytes(cp: CheckpointHex): Promise<CachedBeaconStateAllForks | Uint8Array | null>;
-  get(cpOrKey: CheckpointHex | string, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null;
+  get(cpOrKey: CheckpointHex | string): CachedBeaconStateAllForks | null;
   add(cp: phase0.Checkpoint, state: CachedBeaconStateAllForks): void;
-  getLatest(rootHex: RootHex, maxEpoch: Epoch, opts?: StateRegenerationOpts): CachedBeaconStateAllForks | null;
-  getOrReloadLatest(
-    rootHex: RootHex,
-    maxEpoch: Epoch,
-    opts?: StateRegenerationOpts
-  ): Promise<CachedBeaconStateAllForks | null>;
+  getLatest(rootHex: RootHex, maxEpoch: Epoch): CachedBeaconStateAllForks | null;
+  getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch): Promise<CachedBeaconStateAllForks | null>;
   updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch): number | null;
   prune(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void;
   pruneFinalized(finalizedEpoch: Epoch): void;

package/src/chain/validation/attesterSlashing.ts

@@ -43,7 +43,14 @@ export async function validateAttesterSlashing(
   // [REJECT] All of the conditions within process_attester_slashing pass validation.
   try {
     // verifySignature = false, verified in batch below
-    assertValidAttesterSlashing(chain.index2pubkey, state, attesterSlashing, false);
+    assertValidAttesterSlashing(
+      chain.config,
+      chain.index2pubkey,
+      state.slot,
+      state.validators.length,
+      attesterSlashing,
+      false
+    );
   } catch (e) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,

package/src/chain/validation/blobSidecar.ts

@@ -138,8 +138,9 @@ export async function validateGossipBlobSidecar(
   const signature = blobSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blobSlot, blockHex, signature)) {
     const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.config,
       chain.index2pubkey,
-      blockState,
+      blockState.slot,
       blobSidecar.signedBlockHeader
     );
     // Don't batch so verification is not delayed
@@ -243,10 +244,9 @@ export async function validateBlockBlobSidecars(
     const blockRootHex = toRootHex(blockRoot);
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockSlot, blockRootHex, signature)) {
-      const headState = await chain.getHeadState();
       const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.config,
         chain.index2pubkey,
-        headState,
         firstSidecarSignedBlockHeader
       );
 

package/src/chain/validation/blsToExecutionChange.ts

@@ -1,8 +1,4 @@
-import {
-  CachedBeaconStateCapella,
-  getBlsToExecutionChangeSignatureSet,
-  isValidBlsToExecutionChange,
-} from "@lodestar/state-transition";
+import {getBlsToExecutionChangeSignatureSet, isValidBlsToExecutionChange} from "@lodestar/state-transition";
 import {capella} from "@lodestar/types";
 import {BlsToExecutionChangeError, BlsToExecutionChangeErrorCode, GossipAction} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
@@ -42,10 +38,16 @@ async function validateBlsToExecutionChange(
   // and chanes relevant to `isValidBlsToExecutionChange()` happen only on processBlock(), not processEpoch()
   const state = chain.getHeadState();
   const {config} = chain;
-
+  const addressChange = blsToExecutionChange.message;
+  if (addressChange.validatorIndex >= state.validators.length) {
+    throw new BlsToExecutionChangeError(GossipAction.REJECT, {
+      code: BlsToExecutionChangeErrorCode.INVALID,
+    });
+  }
+  const validator = state.validators.getReadonly(addressChange.validatorIndex);
   // [REJECT] All of the conditions within process_bls_to_execution_change pass validation.
   // verifySignature = false, verified in batch below
-  const {valid} = isValidBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange, false);
+  const {valid} = isValidBlsToExecutionChange(config, validator, blsToExecutionChange, false);
   if (!valid) {
     throw new BlsToExecutionChangeError(GossipAction.REJECT, {
       code: BlsToExecutionChangeErrorCode.INVALID,

package/src/chain/validation/dataColumnSidecar.ts

@@ -135,8 +135,9 @@ export async function validateGossipDataColumnSidecar(
   const signature = dataColumnSidecar.signedBlockHeader.signature;
   if (!chain.seenBlockInputCache.isVerifiedProposerSignature(blockHeader.slot, blockRootHex, signature)) {
     const signatureSet = getBlockHeaderProposerSignatureSetByParentStateSlot(
+      chain.config,
       chain.index2pubkey,
-      blockState,
+      blockState.slot,
       dataColumnSidecar.signedBlockHeader
     );
 
@@ -336,10 +337,9 @@ export async function validateBlockDataColumnSidecars(
     const slot = firstSidecarSignedBlockHeader.message.slot;
     const signature = firstSidecarSignedBlockHeader.signature;
     if (!chain.seenBlockInputCache.isVerifiedProposerSignature(slot, rootHex, signature)) {
-      const headState = await chain.getHeadState();
       const signatureSet = getBlockHeaderProposerSignatureSetByHeaderSlot(
+        chain.config,
         chain.index2pubkey,
-        headState,
         firstSidecarSignedBlockHeader
       );
 

package/src/chain/validation/proposerSlashing.ts

@@ -35,8 +35,9 @@ async function validateProposerSlashing(
 
   // [REJECT] All of the conditions within process_proposer_slashing pass validation.
   try {
+    const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
     // verifySignature = false, verified in batch below
-    assertValidProposerSlashing(state, proposerSlashing, false);
+    assertValidProposerSlashing(chain.config, chain.index2pubkey, state.slot, proposerSlashing, proposer, false);
   } catch (e) {
     throw new ProposerSlashingError(GossipAction.REJECT, {
       code: ProposerSlashingErrorCode.INVALID,

package/src/db/repositories/stateArchive.ts

@@ -42,10 +42,10 @@ export class StateArchiveRepository extends Repository<Slot, BeaconStateAllForks
 
   // Index Root -> Slot
 
-  async getByRoot(stateRoot: Root): Promise<BeaconStateAllForks | null> {
+  async getBinaryByRoot(stateRoot: Root): Promise<Uint8Array | null> {
     const slot = await this.getSlotByRoot(stateRoot);
     if (slot !== null && Number.isInteger(slot)) {
-      return this.get(slot);
+      return this.getBinary(slot);
     }
     return null;
   }

package/src/execution/engine/mock.ts

@@ -1,4 +1,5 @@
 import crypto from "node:crypto";
+import {ChainConfig} from "@lodestar/config";
 import {
   BLOB_TX_TYPE,
   BYTES_PER_FIELD_ELEMENT,
@@ -7,7 +8,9 @@ import {
   ForkPostBellatrix,
   ForkPostCapella,
   ForkSeq,
+  SLOTS_PER_EPOCH,
 } from "@lodestar/params";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {ExecutionPayload, RootHex, bellatrix, deneb, ssz} from "@lodestar/types";
 import {fromHex, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
@@ -34,14 +37,11 @@ const INTEROP_GAS_LIMIT = 30e6;
 const PRUNE_PAYLOAD_ID_AFTER_MS = 5000;
 
 export type ExecutionEngineMockOpts = {
-  genesisBlockHash: string;
+  genesisBlockHash?: string;
   eth1BlockHash?: string;
   onlyPredefinedResponses?: boolean;
-  capellaForkTimestamp?: number;
-  denebForkTimestamp?: number;
-  electraForkTimestamp?: number;
-  fuluForkTimestamp?: number;
-  gloasForkTimestamp?: number;
+  genesisTime?: number;
+  config?: ChainConfig;
 };
 
 type ExecutionBlock = {
@@ -74,17 +74,21 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   /** Preparing payloads to be retrieved via engine_getPayloadV1 */
   private readonly preparingPayloads = new Map<number, PreparedPayload>();
   private readonly payloadsForDeletion = new Map<number, number>();
-
   private readonly predefinedPayloadStatuses = new Map<RootHex, PayloadStatus>();
 
   private payloadId = 0;
+  private capellaForkTimestamp: number;
+  private denebForkTimestamp: number;
+  private electraForkTimestamp: number;
+  private fuluForkTimestamp: number;
+  private gloasForkTimestamp: number;
 
   readonly handlers: {
     [K in keyof EngineApiRpcParamTypes]: (...args: EngineApiRpcParamTypes[K]) => EngineApiRpcReturnTypes[K];
   };
 
   constructor(private readonly opts: ExecutionEngineMockOpts) {
-    this.validBlocks.set(opts.genesisBlockHash, {
+    this.validBlocks.set(opts.genesisBlockHash ?? ZERO_HASH_HEX, {
       parentHash: ZERO_HASH_HEX,
       blockHash: ZERO_HASH_HEX,
       timestamp: 0,
@@ -100,6 +104,29 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
       blockNumber: 1,
     });
 
+    const {config} = opts;
+
+    this.capellaForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.CAPELLA_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.denebForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.DENEB_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.electraForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.ELECTRA_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.fuluForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.FULU_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+    this.gloasForkTimestamp =
+      opts.genesisTime && config
+        ? computeTimeAtSlot(config, config.GLOAS_FORK_EPOCH * SLOTS_PER_EPOCH, opts.genesisTime)
+        : Infinity;
+
     this.handlers = {
       engine_newPayloadV1: this.notifyNewPayload.bind(this),
       engine_newPayloadV2: this.notifyNewPayload.bind(this),
@@ -448,11 +475,11 @@ export class ExecutionEngineMockBackend implements JsonRpcBackend {
   }
 
   private timestampToFork(timestamp: number): ForkPostBellatrix {
-    if (timestamp >= (this.opts.gloasForkTimestamp ?? Infinity)) return ForkName.gloas;
-    if (timestamp >= (this.opts.fuluForkTimestamp ?? Infinity)) return ForkName.fulu;
-    if (timestamp >= (this.opts.electraForkTimestamp ?? Infinity)) return ForkName.electra;
-    if (timestamp >= (this.opts.denebForkTimestamp ?? Infinity)) return ForkName.deneb;
-    if (timestamp >= (this.opts.capellaForkTimestamp ?? Infinity)) return ForkName.capella;
+    if (timestamp >= this.gloasForkTimestamp) return ForkName.gloas;
+    if (timestamp >= this.fuluForkTimestamp) return ForkName.fulu;
+    if (timestamp >= this.electraForkTimestamp) return ForkName.electra;
+    if (timestamp >= this.denebForkTimestamp) return ForkName.deneb;
+    if (timestamp >= this.capellaForkTimestamp) return ForkName.capella;
     return ForkName.bellatrix;
   }
 }

package/src/metrics/metrics/lodestar.ts

@@ -1308,33 +1308,19 @@ export function createLodestarMetrics(
         name: "lodestar_shuffling_cache_miss_count",
         help: "Count of shuffling cache miss",
       }),
-      shufflingBuiltMultipleTimes: register.gauge({
-        name: "lodestar_shuffling_cache_recalculated_shuffling_count",
-        help: "Count of shuffling that were build multiple times",
-      }),
-      shufflingPromiseNotResolvedAndThrownAway: register.gauge({
-        name: "lodestar_shuffling_cache_promise_not_resolved_and_thrown_away_count",
-        help: "Count of shuffling cache promises that were discarded and the shuffling was built synchronously",
+      shufflingSetMultipleTimes: register.gauge({
+        name: "lodestar_shuffling_cache_set_multiple_times_count",
+        help: "Count of shuffling that were set multiple times",
       }),
       shufflingPromiseNotResolved: register.gauge({
         name: "lodestar_shuffling_cache_promise_not_resolved_count",
         help: "Count of shuffling cache promises that were requested before the promise was resolved",
       }),
-      nextShufflingNotOnEpochCache: register.gauge({
-        name: "lodestar_shuffling_cache_next_shuffling_not_on_epoch_cache",
-        help: "The next shuffling was not on the epoch cache before the epoch transition",
-      }),
       shufflingPromiseResolutionTime: register.histogram({
         name: "lodestar_shuffling_cache_promise_resolution_time_seconds",
         help: "Time from promise insertion until promise resolution when shuffling was ready in seconds",
         buckets: [0.5, 1, 1.5, 2],
       }),
-      shufflingCalculationTime: register.histogram<{source: "build" | "getSync"}>({
-        name: "lodestar_shuffling_cache_shuffling_calculation_time_seconds",
-        help: "Run time of shuffling calculation",
-        buckets: [0.5, 0.75, 1, 1.25, 1.5],
-        labelNames: ["source"],
-      }),
     },
 
     seenCache: {

package/src/network/peers/discover.ts

@@ -1,4 +1,4 @@
-import type {PeerId, PeerInfo, PrivateKey} from "@libp2p/interface";
+import type {PeerId, PeerInfo, PendingDial, PrivateKey} from "@libp2p/interface";
 import {Multiaddr} from "@multiformats/multiaddr";
 import {ENR} from "@chainsafe/enr";
 import {BeaconConfig} from "@lodestar/config";
@@ -217,7 +217,7 @@ export class PeerDiscovery {
     const pendingDials = new Set(
       this.libp2p.services.components.connectionManager
         .getDialQueue()
-        .map((pendingDial) => pendingDial.peerId?.toString())
+        .map((pendingDial: PendingDial) => pendingDial.peerId?.toString())
     );
     for (const [id, cachedENR] of this.cachedENRs.entries()) {
       if (
@@ -458,7 +458,7 @@ export class PeerDiscovery {
       if (
         this.libp2p.services.components.connectionManager
           .getDialQueue()
-          .find((pendingDial) => pendingDial.peerId?.equals(peerId))
+          .find((pendingDial: PendingDial) => pendingDial.peerId?.equals(peerId))
       ) {
         return DiscoveredPeerStatus.already_dialing;
       }

package/src/network/reqresp/utils/dataColumnResponseValidation.ts

@@ -55,7 +55,7 @@ export async function handleColumnSidecarUnavailability({
   const blobsCount = getBlobKzgCommitmentsCountFromSignedBeaconBlockSerialized(chain.config, blockBytes);
 
   // There are zero blobs for that column index, so we can safely return without any error
-  if (blobsCount > 0) return;
+  if (blobsCount === 0) return;
 
   // There are blobs for that column index so we should have synced for it
   // We need to inform to peers that we don't have that expected data

package/src/node/nodejs.ts

@@ -6,9 +6,10 @@ import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconApiMethods} from "@lodestar/api/beacon/server";
 import {BeaconConfig} from "@lodestar/config";
 import type {LoggerNode} from "@lodestar/logger/node";
-import {CachedBeaconStateAllForks, Index2PubkeyCache} from "@lodestar/state-transition";
+import {ZERO_HASH_HEX} from "@lodestar/params";
+import {CachedBeaconStateAllForks, Index2PubkeyCache, isExecutionCachedStateType} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
-import {sleep} from "@lodestar/utils";
+import {sleep, toRootHex} from "@lodestar/utils";
 import {ProcessShutdownCallback} from "@lodestar/validator";
 import {BeaconRestApiServer, getApi} from "../api/index.js";
 import {BeaconChain, IBeaconChain, initBeaconMetrics} from "../chain/index.js";
@@ -221,6 +222,20 @@ export class BeaconNode {
         )
       : null;
 
+    let executionEngineOpts = opts.executionEngine;
+    if (opts.executionEngine.mode === "mock") {
+      const eth1BlockHash = isExecutionCachedStateType(anchorState)
+        ? toRootHex(anchorState.latestExecutionPayloadHeader.blockHash)
+        : undefined;
+      executionEngineOpts = {
+        ...opts.executionEngine,
+        genesisBlockHash: ZERO_HASH_HEX,
+        eth1BlockHash,
+        genesisTime: anchorState.genesisTime,
+        config,
+      };
+    }
+
     const chain = new BeaconChain(opts.chain, {
       privateKey,
       config,
@@ -236,7 +251,7 @@ export class BeaconNode {
       validatorMonitor,
       anchorState,
       isAnchorStateFinalized,
-      executionEngine: initializeExecutionEngine(opts.executionEngine, {
+      executionEngine: initializeExecutionEngine(executionEngineOpts, {
         metrics,
         signal,
         logger: logger.child({module: LoggerModule.execution}),

package/src/sync/backfill/backfill.ts

@@ -750,13 +750,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // GENESIS_SLOT doesn't has valid signature
     if (anchorBlock.message.slot === GENESIS_SLOT) return;
-    await verifyBlockProposerSignature(
-      this.chain.config,
-      this.chain.index2pubkey,
-      this.chain.bls,
-      this.chain.getHeadState(),
-      [anchorBlock]
-    );
+    await verifyBlockProposerSignature(this.chain.config, this.chain.index2pubkey, this.chain.bls, [anchorBlock]);
 
     // We can write to the disk if this is ahead of prevFinalizedCheckpointBlock otherwise
     // we will need to go make checks on the top of sync loop before writing as it might
@@ -821,13 +815,7 @@ export class BackfillSync extends (EventEmitter as {new (): BackfillSyncEmitter}
 
     // If any of the block's proposer signature fail, we can't trust this peer at all
     if (verifiedBlocks.length > 0) {
-      await verifyBlockProposerSignature(
-        this.chain.config,
-        this.chain.index2pubkey,
-        this.chain.bls,
-        this.chain.getHeadState(),
-        verifiedBlocks
-      );
+      await verifyBlockProposerSignature(this.chain.config, this.chain.index2pubkey, this.chain.bls, verifiedBlocks);
 
       // This is bad, like super bad. Abort the backfill
       if (!nextAnchor)

package/src/sync/backfill/verify.ts

@@ -1,11 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  Index2PubkeyCache,
-  getBlockProposerSignatureSet,
-} from "@lodestar/state-transition";
+import {ISignatureSet, Index2PubkeyCache, getBlockProposerSignatureSet} from "@lodestar/state-transition";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
 import {IBlsVerifier} from "../../chain/bls/index.js";
 import {BackfillSyncError, BackfillSyncErrorCode} from "./errors.js";
@@ -49,7 +44,6 @@ export async function verifyBlockProposerSignature(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
   bls: IBlsVerifier,
-  state: CachedBeaconStateAllForks,
   blocks: SignedBeaconBlock[]
 ): Promise<void> {
   if (blocks.length === 1 && blocks[0].message.slot === GENESIS_SLOT) return;