@lodestar/beacon-node 1.41.0-dev.555261016d → 1.41.0-dev.66fe43ae9e

package/src/api/impl/beacon/state/utils.ts

@@ -1,9 +1,17 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {BeaconStateAllForks, CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {BLSPubkey, Epoch, RootHex, Slot, ValidatorIndex, getValidatorStatus, phase0} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks, PubkeyCache} from "@lodestar/state-transition";
+import {
+  BLSPubkey,
+  Epoch,
+  RootHex,
+  Slot,
+  ValidatorIndex,
+  getValidatorStatus,
+  mapToGeneralStatus,
+  phase0,
+} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../../chain/index.js";
 import {ApiError, ValidationError} from "../../errors.js";
@@ -65,28 +73,6 @@ export async function getStateResponseWithRegen(
   return res;
 }
 
-type GeneralValidatorStatus = "active" | "pending" | "exited" | "withdrawal";
-
-function mapToGeneralStatus(subStatus: routes.beacon.ValidatorStatus): GeneralValidatorStatus {
-  switch (subStatus) {
-    case "active_ongoing":
-    case "active_exiting":
-    case "active_slashed":
-      return "active";
-    case "pending_initialized":
-    case "pending_queued":
-      return "pending";
-    case "exited_slashed":
-    case "exited_unslashed":
-      return "exited";
-    case "withdrawal_possible":
-    case "withdrawal_done":
-      return "withdrawal";
-    default:
-      throw new Error(`Unknown substatus: ${subStatus}`);
-  }
-}
-
 export function toValidatorResponse(
   index: ValidatorIndex,
   validator: phase0.Validator,
@@ -104,7 +90,7 @@ export function toValidatorResponse(
 export function filterStateValidatorsByStatus(
   statuses: string[],
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   currentEpoch: Epoch
 ): routes.beacon.ValidatorResponse[] {
   const responses: routes.beacon.ValidatorResponse[] = [];
@@ -115,7 +101,7 @@ export function filterStateValidatorsByStatus(
     const validatorStatus = getValidatorStatus(validator, currentEpoch);
     const generalStatus = mapToGeneralStatus(validatorStatus);
 
-    const resp = getStateValidatorIndex(validator.pubkey, state, pubkey2index);
+    const resp = getStateValidatorIndex(validator.pubkey, state, pubkeyCache);
     if (resp.valid && (statusSet.has(validatorStatus) || statusSet.has(generalStatus))) {
       responses.push(
         toValidatorResponse(resp.validatorIndex, validator, state.balances.get(resp.validatorIndex), currentEpoch)
@@ -132,7 +118,7 @@ type StateValidatorIndexResponse =
 export function getStateValidatorIndex(
   id: routes.beacon.ValidatorId | BLSPubkey,
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: PubkeyCache
 ): StateValidatorIndexResponse {
   if (typeof id === "string") {
     // mutate `id` and fallthrough to below
@@ -160,7 +146,7 @@ export function getStateValidatorIndex(
   }
 
   // typeof id === Uint8Array
-  const validatorIndex = pubkey2index.get(id);
+  const validatorIndex = pubkeyCache.getIndex(id);
   if (validatorIndex === null) {
     return {valid: false, code: 404, reason: "Validator pubkey not found in state"};
   }

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

@@ -1,9 +1,10 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus} from "@lodestar/fork-choice";
-import {ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {BeaconState, deneb, fulu, sszTypesFor} from "@lodestar/types";
+import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {BeaconState, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
+import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../util/forkChoice.js";
 import {getStateSlotFromBytes} from "../../../util/multifork.js";
 import {getBlockResponse} from "../beacon/blocks/utils.js";
@@ -42,6 +43,7 @@ export function getDebugApi({
             validity: (() => {
               switch (node.executionStatus) {
                 case ExecutionStatus.Valid:
+                case ExecutionStatus.PayloadSeparated:
                   return "valid";
                 case ExecutionStatus.Invalid:
                   return "invalid";
@@ -96,10 +98,10 @@ export function getDebugApi({
       const fork = config.getForkName(block.message.slot);
       const blockRoot = sszTypesFor(fork).BeaconBlock.hashTreeRoot(block.message);
 
-      let dataColumnSidecars: fulu.DataColumnSidecars;
+      let dataColumnSidecars: DataColumnSidecars;
 
       const blobCount = isForkPostDeneb(fork)
-        ? (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments.length
+        ? getBlobKzgCommitments(fork, block as SignedBeaconBlock<ForkPostDeneb>).length
         : 0;
 
       if (isForkPostFulu(fork) && blobCount > 0) {
@@ -115,7 +117,9 @@ export function getDebugApi({
       }
 
       return {
-        data: indices ? dataColumnSidecars.filter(({index}) => indices.includes(index)) : dataColumnSidecars,
+        data: (indices
+          ? dataColumnSidecars.filter(({index}) => indices.includes(index))
+          : dataColumnSidecars) as DataColumnSidecars,
         meta: {
           executionOptimistic,
           finalized,

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

@@ -1,7 +1,9 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {MAX_REQUEST_LIGHT_CLIENT_COMMITTEE_HASHES, MAX_REQUEST_LIGHT_CLIENT_UPDATES} from "@lodestar/params";
+import type {LightClientUpdate} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
+import {LightClientServerError, LightClientServerErrorCode} from "../../../chain/errors/lightClientError.js";
 import {assertLightClientServer} from "../../../node/utils/lightclient.js";
 import {ApiModules} from "../types.js";
 // TODO: Import from lightclient/server package
@@ -16,8 +18,23 @@ export function getLightclientApi({
       assertLightClientServer(lightClientServer);
 
       const maxAllowedCount = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, count);
-      const periods = Array.from({length: maxAllowedCount}, (_ignored, i) => i + startPeriod);
-      const updates = await Promise.all(periods.map((period) => lightClientServer.getUpdate(period)));
+      const updates: LightClientUpdate[] = [];
+      for (let i = 0; i < maxAllowedCount; i++) {
+        try {
+          const update = await lightClientServer.getUpdate(startPeriod + i);
+          updates.push(update);
+        } catch (e) {
+          if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
+            // Period not available, if we already have results, stop to preserve
+            // consecutive order. If not, skip and try the next period.
+            if (updates.length > 0) break;
+            continue;
+          }
+          // Unexpected error
+          throw e;
+        }
+      }
+
       return {
         data: updates,
         meta: {versions: updates.map((update) => config.getForkName(update.attestedHeader.beacon.slot))},

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

@@ -1,12 +1,14 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
+import {ClientCode, ClientVersion} from "../../../execution/index.js";
+import {getLodestarClientVersion} from "../../../util/metadata.js";
 import {ApiOptions} from "../../options.js";
 import {ApiError} from "../errors.js";
 import {ApiModules} from "../types.js";
 
 export function getNodeApi(
   opts: ApiOptions,
-  {network, sync}: Pick<ApiModules, "network" | "sync">
+  {network, sync, chain}: Pick<ApiModules, "network" | "sync" | "chain">
 ): ApplicationMethods<routes.node.Endpoints> {
   return {
     async getNetworkIdentity() {
@@ -62,6 +64,20 @@ export function getNodeApi(
       };
     },
 
+    async getNodeVersionV2() {
+      const {clientVersion} = chain.executionEngine;
+
+      return {
+        data: {
+          beaconNode: toSpecClientVersion(getLodestarClientVersion(opts)),
+          executionClient:
+            clientVersion != null && clientVersion.code !== ClientCode.XX
+              ? toSpecClientVersion(clientVersion)
+              : undefined,
+        },
+      };
+    },
+
     async getSyncingStatus() {
       return {data: sync.getSyncStatus()};
     },
@@ -86,3 +102,8 @@ export function getNodeApi(
     },
   };
 }
+
+/** Prefix commit with 0x as required by the beacon-APIs spec */
+function toSpecClientVersion(cv: ClientVersion): routes.node.ClientVersion {
+  return {...cv, commit: `0x${cv.commit}`};
+}

package/src/api/impl/node/utils.ts

@@ -1,4 +1,4 @@
-import {Connection, StreamStatus} from "@libp2p/interface";
+import type {Connection, ConnectionStatus} from "@libp2p/interface";
 import {routes} from "@lodestar/api";
 
 /**
@@ -24,7 +24,7 @@ export function formatNodePeer(peerIdStr: string, connections: Connection[]): ro
  * - Otherwise, the first closed connection
  */
 export function getRelevantConnection(connections: Connection[]): Connection | null {
-  const byStatus = new Map<StreamStatus, Connection>();
+  const byStatus = new Map<ConnectionStatus, Connection>();
   for (const conn of connections) {
     if (conn.status === "open") return conn;
     if (!byStatus.has(conn.status)) byStatus.set(conn.status, conn);
@@ -37,7 +37,7 @@ export function getRelevantConnection(connections: Connection[]): Connection | n
  * Map libp2p connection status to the API's peer state notation
  * @param status
  */
-function getPeerState(status: StreamStatus): routes.node.PeerState {
+function getPeerState(status: ConnectionStatus): routes.node.PeerState {
   switch (status) {
     case "open":
       return "connected";

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

@@ -1,8 +1,8 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
-import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
+import {ExecutionStatus, PayloadStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkName,
   ForkPostBellatrix,
   ForkPreGloas,
@@ -14,6 +14,7 @@ import {
   isForkPostBellatrix,
   isForkPostDeneb,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
@@ -25,6 +26,7 @@ import {
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
   createCachedBeaconState,
+  createPubkeyCache,
   getBlockRootAtSlot,
   getCurrentSlot,
   loadState,
@@ -45,6 +47,7 @@ import {
   Wei,
   bellatrix,
   getValidatorStatus,
+  gloas,
   phase0,
   ssz,
 } from "@lodestar/types";
@@ -69,7 +72,7 @@ import {
 } from "../../../chain/errors/index.js";
 import {ChainEvent, CommonBlockBody} from "../../../chain/index.js";
 import {PREPARE_NEXT_SLOT_BPS} from "../../../chain/prepareNextSlot.js";
-import {BlockType, ProduceFullDeneb} from "../../../chain/produceBlock/index.js";
+import {BlockType, ProduceFullDeneb, ProduceFullGloas} from "../../../chain/produceBlock/index.js";
 import {RegenCaller} from "../../../chain/regen/index.js";
 import {CheckpointHex} from "../../../chain/stateCache/types.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
@@ -386,7 +389,7 @@ export function getValidatorApi(
    */
 
   function notOnOptimisticBlockRoot(beaconBlockRoot: Root): void {
-    const protoBeaconBlock = chain.forkChoice.getBlock(beaconBlockRoot);
+    const protoBeaconBlock = chain.forkChoice.getBlockDefaultStatus(beaconBlockRoot);
     if (!protoBeaconBlock) {
       throw new ApiError(404, `Block not in forkChoice, beaconBlockRoot=${toRootHex(beaconBlockRoot)}`);
     }
@@ -398,7 +401,7 @@ export function getValidatorApi(
   }
 
   function notOnOutOfRangeData(beaconBlockRoot: Root): void {
-    const protoBeaconBlock = chain.forkChoice.getBlock(beaconBlockRoot);
+    const protoBeaconBlock = chain.forkChoice.getBlockDefaultStatus(beaconBlockRoot);
     if (!protoBeaconBlock) {
       throw new ApiError(404, `Block not in forkChoice, beaconBlockRoot=${toRootHex(beaconBlockRoot)}`);
     }
@@ -901,6 +904,77 @@ export function getValidatorApi(
       return {data, meta};
     },
 
+    async produceBlockV4({slot, randaoReveal, graffiti, feeRecipient}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `produceBlockV4 not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      // TODO GLOAS: support producing blocks from builder bids
+      const source = ProducedBlockSource.engine;
+
+      // TODO GLOAS: needs to be updated after fork choice changes are merged
+      const parentBlock = chain.getProposerHead(slot);
+      const {blockRoot: parentBlockRootHex, slot: parentSlot} = parentBlock;
+      const parentBlockRoot = fromHex(parentBlockRootHex);
+      notOnOutOfRangeData(parentBlockRoot);
+      metrics?.blockProductionSlotDelta.set(slot - parentSlot);
+      metrics?.blockProductionRequests.inc({source});
+
+      const graffitiBytes = toGraffitiBytes(
+        graffiti ?? getDefaultGraffiti(getLodestarClientVersion(), chain.executionEngine.clientVersion, {})
+      );
+      const commonBlockBodyPromise = chain.produceCommonBlockBody({
+        slot,
+        parentBlock,
+        randaoReveal,
+        graffiti: graffitiBytes,
+      });
+
+      let timer: undefined | ((opts: {source: ProducedBlockSource}) => number);
+      try {
+        timer = metrics?.blockProductionTime.startTimer();
+        const {block, executionPayloadValue, consensusBlockValue} = await chain.produceBlock({
+          slot,
+          parentBlock,
+          randaoReveal,
+          graffiti: graffitiBytes,
+          feeRecipient,
+          commonBlockBodyPromise,
+        });
+
+        metrics?.blockProductionSuccess.inc({source});
+        metrics?.blockProductionNumAggregated.observe({source}, block.body.attestations.length);
+        metrics?.blockProductionConsensusBlockValue.observe({source}, Number(formatWeiToEth(consensusBlockValue)));
+        metrics?.blockProductionExecutionPayloadValue.observe({source}, Number(formatWeiToEth(executionPayloadValue)));
+
+        const blockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block));
+        logger.verbose("Produced block", {
+          slot,
+          executionPayloadValue,
+          consensusBlockValue,
+          root: blockRoot,
+        });
+        if (chain.opts.persistProducedBlocks) {
+          void chain.persistBlock(block, "produced_engine_block");
+        }
+
+        return {
+          data: block as gloas.BeaconBlock,
+          meta: {
+            version: fork,
+            consensusBlockValue,
+          },
+        };
+      } finally {
+        timer?.({source});
+      }
+    },
+
     async produceAttestationData({committeeIndex, slot}) {
       notWhileSyncing();
 
@@ -915,8 +989,30 @@ export function getValidatorApi(
       const headBlockRoot = fromHex(headBlockRootHex);
       const fork = config.getForkName(slot);
 
+      const beaconBlockRoot =
+        slot >= headSlot
+          ? // When attesting to the head slot or later, always use the head of the chain.
+            headBlockRoot
+          : // Permit attesting to slots *prior* to the current head. This is desirable when
+            // the VC and BN are out-of-sync due to time issues or overloading.
+            getBlockRootAtSlot(headState, slot);
+
       let index: CommitteeIndex;
-      if (isForkPostElectra(fork)) {
+      if (isForkPostGloas(fork)) {
+        const canonicalBlock = chain.forkChoice.getCanonicalBlockByRoot(beaconBlockRoot);
+        if (!canonicalBlock) {
+          // This should never happen
+          throw Error(`Block not found in fork choice for slot=${slot}, root=${toRootHex(beaconBlockRoot)}`);
+        }
+        // After Gloas, attestation.data.index signals payload status in fork-choice:
+        // - 0 = EMPTY / not present, 1 = FULL / present
+        // - same-slot attestations must always use index = 0
+        if (canonicalBlock.slot !== slot) {
+          index = canonicalBlock.payloadStatus === PayloadStatus.FULL ? 1 : 0;
+        } else {
+          index = 0;
+        }
+      } else if (isForkPostElectra(fork)) {
         index = 0;
       } else {
         if (committeeIndex === undefined) {
@@ -925,14 +1021,6 @@ export function getValidatorApi(
         index = committeeIndex;
       }
 
-      const beaconBlockRoot =
-        slot >= headSlot
-          ? // When attesting to the head slot or later, always use the head of the chain.
-            headBlockRoot
-          : // Permit attesting to slots *prior* to the current head. This is desirable when
-            // the VC and BN are out-of-sync due to time issues or overloading.
-            getBlockRootAtSlot(headState, slot);
-
       const targetSlot = computeStartSlotAtEpoch(attEpoch);
       const targetRoot =
         targetSlot >= headSlot
@@ -1049,8 +1137,7 @@ export function getValidatorApi(
             {
               config: chain.config,
               // Not required to compute proposers
-              pubkey2index: new PubkeyIndexMap(),
-              index2pubkey: [],
+              pubkeyCache: createPubkeyCache(),
             },
             {skipSyncPubkeys: true, skipSyncCommitteeCache: true}
           );
@@ -1511,7 +1598,7 @@ export function getValidatorApi(
 
       const filteredRegistrations = registrations.filter((registration) => {
         const {pubkey} = registration.message;
-        const validatorIndex = chain.pubkey2index.get(pubkey);
+        const validatorIndex = chain.pubkeyCache.getIndex(pubkey);
         if (validatorIndex === null) return false;
 
         const validator = headState.validators.getReadonly(validatorIndex);
@@ -1532,5 +1619,54 @@ export function getValidatorApi(
         count: filteredRegistrations.length,
       });
     },
+
+    async getExecutionPayloadEnvelope({slot, beaconBlockRoot}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `getExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      const blockRootHex = toRootHex(beaconBlockRoot);
+      const produceResult = chain.blockProductionCache.get(blockRootHex);
+
+      if (produceResult === undefined) {
+        throw new ApiError(404, `No cached block production result found for block root ${blockRootHex}`);
+      }
+      if (!isForkPostGloas(produceResult.fork)) {
+        throw Error(`Cached block production result is for pre-gloas fork=${produceResult.fork}`);
+      }
+      if (produceResult.type !== BlockType.Full) {
+        throw Error("Cached block production result is not full block");
+      }
+
+      const {executionPayload, executionRequests, envelopeStateRoot} = produceResult as ProduceFullGloas;
+
+      const envelope: gloas.ExecutionPayloadEnvelope = {
+        payload: executionPayload,
+        executionRequests: executionRequests,
+        builderIndex: BUILDER_INDEX_SELF_BUILD,
+        beaconBlockRoot,
+        slot,
+        stateRoot: envelopeStateRoot,
+      };
+
+      logger.info("Produced execution payload envelope", {
+        slot,
+        blockRoot: blockRootHex,
+        transactions: executionPayload.transactions.length,
+        blockHash: toRootHex(executionPayload.blockHash),
+      });
+
+      return {
+        data: envelope,
+        meta: {
+          version: fork,
+        },
+      };
+    },
   };
 }

package/src/chain/archiveStore/archiveStore.ts

@@ -1,5 +1,6 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
 import {LoggerNode} from "@lodestar/logger/node";
+import {ForkSeq} from "@lodestar/params";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {callFnWhenAwait} from "@lodestar/utils";
 import {IBeaconDb} from "../../db/index.js";
@@ -13,6 +14,7 @@ import {HistoricalStateRegen} from "./historicalState/historicalStateRegen.js";
 import {ArchiveMode, ArchiveStoreOpts, StateArchiveStrategy} from "./interface.js";
 import {FrequencyStateArchiveStrategy} from "./strategies/frequencyStateArchiveStrategy.js";
 import {archiveBlocks} from "./utils/archiveBlocks.js";
+import {archiveExecutionPayloadEnvelopes} from "./utils/archivePayloads.js";
 import {pruneHistory} from "./utils/pruneHistory.js";
 import {updateBackfillRange} from "./utils/updateBackfillRange.js";
 
@@ -27,6 +29,7 @@ type ArchiveStoreInitOpts = ArchiveStoreOpts & {dbName: string; anchorState: {fi
 
 export enum ArchiveStoreTask {
   ArchiveBlocks = "archive_blocks",
+  ArchivePayloads = "archive_payloads",
   PruneHistory = "prune_history",
   OnFinalizedCheckpoint = "on_finalized_checkpoint",
   MaybeArchiveState = "maybe_archive_state",
@@ -189,6 +192,7 @@ export class ArchiveStore {
   private processFinalizedCheckpoint = async (finalized: CheckpointWithHex): Promise<void> => {
     try {
       const finalizedEpoch = finalized.epoch;
+      const finalizedFork = this.chain.config.getForkSeqAtEpoch(finalizedEpoch);
       this.logger.verbose("Start processing finalized checkpoint", {epoch: finalizedEpoch, rootHex: finalized.rootHex});
 
       let timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
@@ -206,6 +210,12 @@ export class ArchiveStore {
       );
       timer?.({source: ArchiveStoreTask.ArchiveBlocks});
 
+      if (finalizedFork >= ForkSeq.gloas) {
+        timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
+        await archiveExecutionPayloadEnvelopes(this.chain, finalized);
+        timer?.({source: ArchiveStoreTask.ArchivePayloads});
+      }
+
       if (this.opts.pruneHistory) {
         timer = this.metrics?.processFinalizedCheckpoint.durationByTask.startTimer();
         await pruneHistory(

package/src/chain/archiveStore/historicalState/getHistoricalState.ts

@@ -1,10 +1,10 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig} from "@lodestar/config";
 import {
   BeaconStateAllForks,
   CachedBeaconStateAllForks,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
+  PubkeyCache,
   createCachedBeaconState,
   stateTransition,
 } from "@lodestar/state-transition";
@@ -15,16 +15,16 @@ import {HistoricalStateRegenMetrics} from "./metrics.js";
 import {RegenErrorType} from "./types.js";
 
 /**
- * Populate a PubkeyIndexMap with any new entries based on a BeaconState
+ * Populate a PubkeyCache with any new entries based on a BeaconState
  */
-export function syncPubkeyCache(state: BeaconStateAllForks, pubkey2index: PubkeyIndexMap): void {
+export function syncPubkeyCache(state: BeaconStateAllForks, pubkeyCache: PubkeyCache): void {
   // Get the validators sub tree once for all the loop
   const validators = state.validators;
 
   const newCount = state.validators.length;
-  for (let i = pubkey2index.size; i < newCount; i++) {
+  for (let i = pubkeyCache.size; i < newCount; i++) {
     const pubkey = validators.getReadonly(i).pubkey;
-    pubkey2index.set(pubkey, i);
+    pubkeyCache.set(i, pubkey);
   }
 }
 
@@ -35,7 +35,7 @@ export async function getNearestState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: PubkeyCache
 ): Promise<CachedBeaconStateAllForks> {
   const stateBytesArr = await db.stateArchive.binaries({limit: 1, lte: slot, reverse: true});
   if (!stateBytesArr.length) {
@@ -44,14 +44,13 @@ export async function getNearestState(
 
   const stateBytes = stateBytesArr[0];
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
-  syncPubkeyCache(state, pubkey2index);
+  syncPubkeyCache(state, pubkeyCache);
 
   return createCachedBeaconState(
     state,
     {
       config,
-      pubkey2index,
-      index2pubkey: [],
+      pubkeyCache,
     },
     {
       skipSyncPubkeys: true,
@@ -66,13 +65,13 @@ export async function getHistoricalState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   metrics?: HistoricalStateRegenMetrics
 ): Promise<Uint8Array> {
   const regenTimer = metrics?.regenTime.startTimer();
 
   const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, pubkey2index).catch((e) => {
+  let state = await getNearestState(slot, config, db, pubkeyCache).catch((e) => {
     metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
     throw e;
   });

package/src/chain/archiveStore/historicalState/worker.ts

@@ -1,9 +1,9 @@
 import worker from "node:worker_threads";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {Transfer, expose} from "@chainsafe/threads/worker";
 import {chainConfigFromJson, createBeaconConfig} from "@lodestar/config";
 import {LevelDbController} from "@lodestar/db/controller/level";
 import {getNodeLogger} from "@lodestar/logger/node";
+import {createPubkeyCache} from "@lodestar/state-transition";
 import {BeaconDb} from "../../../db/index.js";
 import {RegistryMetricCreator, collectNodeJSMetrics} from "../../../metrics/index.js";
 import {JobFnQueue} from "../../../util/queue/fnQueue.js";
@@ -52,7 +52,7 @@ const queue = new JobFnQueue(
   queueMetrics
 );
 
-const pubkey2index = new PubkeyIndexMap();
+const pubkeyCache = createPubkeyCache();
 
 const api: HistoricalStateWorkerApi = {
   async close() {
@@ -65,7 +65,7 @@ const api: HistoricalStateWorkerApi = {
     historicalStateRegenMetrics?.regenRequestCount.inc();
 
     const stateBytes = await queue.push<Uint8Array>(() =>
-      getHistoricalState(slot, config, db, pubkey2index, historicalStateRegenMetrics)
+      getHistoricalState(slot, config, db, pubkeyCache, historicalStateRegenMetrics)
     );
     const result = Transfer(stateBytes, [stateBytes.buffer]) as unknown as Uint8Array;
 

package/src/chain/archiveStore/utils/archivePayloads.ts

@@ -0,0 +1,15 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {IBeaconChain} from "../../interface.js";
+
+/**
+ * Archives execution payload envelopes from hot DB to archive DB after finalization.
+ */
+export async function archiveExecutionPayloadEnvelopes(
+  chain: IBeaconChain,
+  _finalized: CheckpointWithHex
+): Promise<void> {
+  const finalizedBlock = chain.forkChoice.getFinalizedBlock();
+  if (!finalizedBlock) return;
+
+  // TODO GLOAS: Implement payload envelope archival after epbs fork choice changes are merged
+}

package/src/chain/archiveStore/utils/updateBackfillRange.ts

@@ -20,7 +20,7 @@ export async function updateBackfillRange(
   try {
     // Mark the sequence in backfill db from finalized block's slot till anchor slot as
     // filled.
-    const finalizedBlockFC = chain.forkChoice.getBlockHex(finalized.rootHex);
+    const finalizedBlockFC = chain.forkChoice.getBlockHexDefaultStatus(finalized.rootHex);
     if (finalizedBlockFC && finalizedBlockFC.slot > chain.anchorStateLatestBlockSlot) {
       await db.backfilledRanges.put(finalizedBlockFC.slot, chain.anchorStateLatestBlockSlot);