@lodestar/beacon-node 1.42.0-dev.4411584fd8 → 1.42.0-dev.47afaa6bb7

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

@@ -1,10 +1,9 @@
-import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ChainForkConfig} from "@lodestar/config";
 import {Repository} from "@lodestar/db";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
-import {BeaconStateCapella, getLatestWeakSubjectivityCheckpointEpoch, loadState} from "@lodestar/state-transition";
+import {isStatePostCapella} from "@lodestar/state-transition";
 import {ssz} from "@lodestar/types";
 import {Checkpoint} from "@lodestar/types/phase0";
 import {fromHex, toHex, toRootHex} from "@lodestar/utils";
@@ -86,7 +85,7 @@ export function getLodestarApi({
 
     async getLatestWeakSubjectivityCheckpointEpoch() {
       const state = chain.getHeadState();
-      return {data: getLatestWeakSubjectivityCheckpointEpoch(config, state)};
+      return {data: state.getLatestWeakSubjectivityCheckpointEpoch()};
     },
 
     async getSyncChainsDebugState() {
@@ -214,22 +213,23 @@ export function getLodestarApi({
     async getHistoricalSummaries({stateId}) {
       const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
 
-      const stateView = (
-        state instanceof Uint8Array ? loadState(config, chain.getHeadState(), state).state : state
-      ) as BeaconStateCapella;
+      const stateView = state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state;
 
       const fork = config.getForkName(stateView.slot);
       if (ForkSeq[fork] < ForkSeq.capella) {
         throw new Error("Historical summaries are not supported before Capella");
       }
+      if (!isStatePostCapella(stateView)) {
+        throw new Error("Expected Capella state for historical summaries");
+      }
 
       const {gindex} = ssz[fork].BeaconState.getPathInfo(["historicalSummaries"]);
-      const proof = new Tree(stateView.node).getSingleProof(gindex);
+      const proof = stateView.getSingleProof(gindex);
 
       return {
         data: {
           slot: stateView.slot,
-          historicalSummaries: stateView.historicalSummaries.toValue(),
+          historicalSummaries: stateView.historicalSummaries,
           proof: proof,
         },
         meta: {executionOptimistic, finalized, version: fork},

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

@@ -1,7 +1,6 @@
 import {CompactMultiProof, ProofType, createProof} from "@chainsafe/persistent-merkle-tree";
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
-import {loadState} from "@lodestar/state-transition";
 import {ApiOptions} from "../../options.js";
 import {getBlockResponse} from "../beacon/blocks/utils.js";
 import {getStateResponseWithRegen} from "../beacon/state/utils.js";
@@ -24,16 +23,10 @@ export function getProofApi(
 
       const res = await getStateResponseWithRegen(chain, stateId);
 
-      const state =
-        res.state instanceof Uint8Array ? loadState(config, chain.getHeadState(), res.state).state : res.state;
-
-      // there should be no state changes in beacon-node so no need to commit() here
-      const stateNode = state.node;
-
-      const proof = createProof(stateNode, {type: ProofType.compactMulti, descriptor});
+      const state = res.state instanceof Uint8Array ? chain.getHeadState().loadOtherState(res.state) : res.state;
 
       return {
-        data: proof as CompactMultiProof,
+        data: state.createMultiProof(descriptor),
         meta: {version: config.getForkName(state.slot)},
       };
     },

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

@@ -17,19 +17,15 @@ import {
   isForkPostGloas,
 } from "@lodestar/params";
 import {
-  CachedBeaconStateAllForks,
   DataAvailabilityStatus,
-  attesterShufflingDecisionRoot,
+  IBeaconStateView,
   beaconBlockToBlinded,
   calculateCommitteeAssignments,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
-  createCachedBeaconState,
-  createPubkeyCache,
-  getBlockRootAtSlot,
   getCurrentSlot,
-  loadState,
+  isStatePostAltair,
   proposerShufflingDecisionRoot,
 } from "@lodestar/state-transition";
 import {
@@ -193,11 +189,13 @@ export function getValidatorApi(
   const MAX_API_CLOCK_DISPARITY_MS = MAX_API_CLOCK_DISPARITY_SEC * 1000;
 
   /** Compute and cache the genesis block root */
-  async function getGenesisBlockRoot(state: CachedBeaconStateAllForks): Promise<Root> {
+  async function getGenesisBlockRoot(state: IBeaconStateView): Promise<Root> {
     if (!genesisBlockRoot) {
       // Close to genesis the genesis block may not be available in the DB
-      if (state.slot < SLOTS_PER_HISTORICAL_ROOT) {
-        genesisBlockRoot = state.blockRoots.get(0);
+      if (state.slot === GENESIS_SLOT) {
+        genesisBlockRoot = state.computeAnchorCheckpoint().checkpoint.root;
+      } else if (state.slot < SLOTS_PER_HISTORICAL_ROOT) {
+        genesisBlockRoot = state.getBlockRootAtSlot(GENESIS_SLOT);
       }
 
       const blockRes = await chain.getCanonicalBlockAtSlot(GENESIS_SLOT);
@@ -303,7 +301,7 @@ export function getValidatorApi(
    *                    |
    *              prepareNextSlot (4s before next slot)
    */
-  async function waitForCheckpointState(cpHex: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | null> {
+  async function waitForCheckpointState(cpHex: CheckpointHexPayload): Promise<IBeaconStateView | null> {
     const cpState = chain.regen.getCheckpointStateSync(cpHex);
     if (cpState) {
       return cpState;
@@ -995,7 +993,7 @@ export function getValidatorApi(
             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);
+            headState.getBlockRootAtSlot(slot);
 
       let index: CommitteeIndex;
       if (isForkPostGloas(fork)) {
@@ -1026,7 +1024,7 @@ export function getValidatorApi(
         targetSlot >= headSlot
           ? // If the state is earlier than the target slot then the target *must* be the head block root.
             headBlockRoot
-          : getBlockRootAtSlot(headState, targetSlot);
+          : headState.getBlockRootAtSlot(targetSlot);
 
       // Check the execution status as validator shouldn't vote on an optimistic head
       // Check on target is sufficient as a valid target would imply a valid source
@@ -1068,7 +1066,7 @@ export function getValidatorApi(
       // see https://github.com/ChainSafe/lodestar/issues/5063
       if (!chain.forkChoice.hasBlock(beaconBlockRoot)) {
         const rootHex = toRootHex(beaconBlockRoot);
-        network.searchUnknownSlotRoot({slot, root: rootHex}, BlockInputSource.api);
+        network.searchUnknownBlock({slot, root: rootHex}, BlockInputSource.api);
         // if result of this call is false, i.e. block hasn't seen after 1 slot then the below notOnOptimisticBlockRoot call will throw error
         await chain.waitForBlock(slot, rootHex);
       }
@@ -1103,7 +1101,7 @@ export function getValidatorApi(
       }
 
       const head = chain.forkChoice.getHead();
-      let state: CachedBeaconStateAllForks | undefined = undefined;
+      let state: IBeaconStateView | undefined = undefined;
       const startSlot = computeStartSlotAtEpoch(epoch);
       const prepareNextSlotLookAheadMs =
         config.SLOT_DURATION_MS - config.getSlotComponentDurationMs(PREPARE_NEXT_SLOT_BPS);
@@ -1133,43 +1131,34 @@ export function getValidatorApi(
         } else {
           const res = await getStateResponseWithRegen(chain, startSlot);
 
-          const stateViewDU =
-            res.state instanceof Uint8Array ? loadState(config, chain.getHeadState(), res.state).state : res.state;
+          state = res.state instanceof Uint8Array ? chain.getHeadState().loadOtherState(res.state) : res.state;
 
-          state = createCachedBeaconState(
-            stateViewDU,
-            {
-              config: chain.config,
-              // Not required to compute proposers
-              pubkeyCache: createPubkeyCache(),
-            },
-            {skipSyncPubkeys: true, skipSyncCommitteeCache: true}
-          );
-
-          if (state.epochCtx.epoch !== epoch) {
-            throw Error(`Loaded state epoch ${state.epochCtx.epoch} does not match requested epoch ${epoch}`);
+          if (state.epoch !== epoch) {
+            throw Error(`Loaded state epoch ${state.epoch} does not match requested epoch ${epoch}`);
           }
         }
       }
 
-      const stateEpoch = state.epochCtx.epoch;
+      const stateEpoch = state.epoch;
       let indexes: ValidatorIndex[] = [];
 
       switch (epoch) {
         case stateEpoch:
-          indexes = state.epochCtx.getBeaconProposers();
+          indexes = state.currentProposers;
           break;
 
-        case stateEpoch + 1:
+        case stateEpoch + 1: {
           // make sure shuffling is calculated and ready for next call to calculate nextProposers
-          await chain.shufflingCache.get(state.epochCtx.nextEpoch, state.epochCtx.nextDecisionRoot);
+          const nextEpoch = state.epoch + 1;
+          await chain.shufflingCache.get(nextEpoch, state.nextDecisionRoot);
           // Requesting duties for next epoch is allowed since they can be predicted with high probabilities.
           // @see `epochCtx.getBeaconProposersNextEpoch` JSDocs for rationale.
-          indexes = state.epochCtx.getBeaconProposersNextEpoch();
+          indexes = state.nextProposers;
           break;
+        }
 
         case stateEpoch - 1: {
-          const indexesPrevEpoch = state.epochCtx.getBeaconProposersPrevEpoch();
+          const indexesPrevEpoch = state.previousProposers;
           if (indexesPrevEpoch === null) {
             // Should not happen as previous proposer duties should be initialized for head state
             // and if we load state from `Uint8Array` it will always be the state of requested epoch
@@ -1188,7 +1177,7 @@ export function getValidatorApi(
       //       See benchmark -> packages/lodestar/test/perf/api/impl/validator/attester.test.ts
       // After dropping the flat caches attached to the CachedBeaconState it's no longer available.
       // TODO: Add a flag to just send 0x00 as pubkeys since the Lodestar validator does not need them.
-      const pubkeys = getPubkeysForIndices(state.validators, indexes);
+      const pubkeys = getPubkeysForIndices(state, indexes);
 
       const duties: routes.validator.ProposerDuty[] = [];
       for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
@@ -1242,8 +1231,8 @@ export function getValidatorApi(
       // will equal `currentEpoch + 1`
 
       // Check that all validatorIndex belong to the state before calling getCommitteeAssignments()
-      const pubkeys = getPubkeysForIndices(state.validators, indices);
-      const decisionRoot = state.epochCtx.getShufflingDecisionRoot(epoch);
+      const pubkeys = getPubkeysForIndices(state, indices);
+      const decisionRoot = state.getShufflingDecisionRoot(epoch);
       const shuffling = await chain.shufflingCache.get(epoch, decisionRoot);
       if (!shuffling) {
         throw new ApiError(
@@ -1264,7 +1253,7 @@ export function getValidatorApi(
         }
       }
 
-      const dependentRoot = attesterShufflingDecisionRoot(state, epoch) || (await getGenesisBlockRoot(state));
+      const dependentRoot = fromHex(state.getShufflingDecisionRoot(epoch)) || (await getGenesisBlockRoot(state));
 
       return {
         data: duties,
@@ -1294,6 +1283,9 @@ export function getValidatorApi(
       if (indices.length === 0) {
         throw new ApiError(400, "No validator to get attester duties");
       }
+      if (epoch < config.ALTAIR_FORK_EPOCH) {
+        throw new ApiError(400, "Sync committee duties are not supported before Altair");
+      }
 
       // May request for an epoch that's in the future
       await waitForNextClosestEpoch();
@@ -1303,11 +1295,14 @@ export function getValidatorApi(
       // Note: does not support requesting past duties
       const head = chain.forkChoice.getHead();
       const state = chain.getHeadState();
+      if (!isStatePostAltair(state)) {
+        throw new ApiError(400, "Sync committee duties are not available before Altair");
+      }
 
       // Check that all validatorIndex belong to the state before calling getCommitteeAssignments()
-      const pubkeys = getPubkeysForIndices(state.validators, indices);
+      const pubkeys = getPubkeysForIndices(state, indices);
       // Ensures `epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD <= current_epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD + 1`
-      const syncCommitteeCache = state.epochCtx.getIndexedSyncCommitteeAtEpoch(epoch);
+      const syncCommitteeCache = state.getIndexedSyncCommitteeAtEpoch(epoch);
       const validatorSyncCommitteeIndexMap = syncCommitteeCache.validatorIndexMap;
 
       const duties: routes.validator.SyncDuty[] = [];
@@ -1605,7 +1600,7 @@ export function getValidatorApi(
         const validatorIndex = chain.pubkeyCache.getIndex(pubkey);
         if (validatorIndex === null) return false;
 
-        const validator = headState.validators.getReadonly(validatorIndex);
+        const validator = headState.getValidator(validatorIndex);
         const status = getValidatorStatus(validator, currentEpoch);
         return (
           status === "active_exiting" ||
@@ -1647,7 +1642,7 @@ export function getValidatorApi(
         throw Error("Cached block production result is not full block");
       }
 
-      const {executionPayload, executionRequests, envelopeStateRoot} = produceResult as ProduceFullGloas;
+      const {executionPayload, executionRequests, payloadEnvelopeStateRoot} = produceResult as ProduceFullGloas;
 
       const envelope: gloas.ExecutionPayloadEnvelope = {
         payload: executionPayload,
@@ -1655,7 +1650,7 @@ export function getValidatorApi(
         builderIndex: BUILDER_INDEX_SELF_BUILD,
         beaconBlockRoot,
         slot,
-        stateRoot: envelopeStateRoot,
+        stateRoot: payloadEnvelopeStateRoot,
       };
 
       logger.info("Produced execution payload envelope", {

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

@@ -1,6 +1,6 @@
 import {routes} from "@lodestar/api";
 import {ATTESTATION_SUBNET_COUNT} from "@lodestar/params";
-import {BeaconStateAllForks, computeSlotsSinceEpochStart} from "@lodestar/state-transition";
+import {IBeaconStateView, computeSlotsSinceEpochStart} from "@lodestar/state-transition";
 import {BLSPubkey, CommitteeIndex, ProducedBlockSource, Slot, SubnetID, ValidatorIndex} from "@lodestar/types";
 import {MAX_BUILDER_BOOST_FACTOR} from "@lodestar/validator";
 import {BlockSelectionResult, BuilderBlockSelectionReason, EngineBlockSelectionReason} from "./index.js";
@@ -24,11 +24,8 @@ export function computeSubnetForCommitteesAtSlot(
  * Note: This is the fastest way of getting compressed pubkeys.
  *       See benchmark -> packages/beacon-node/test/perf/api/impl/validator/attester.test.ts
  */
-export function getPubkeysForIndices(
-  validators: BeaconStateAllForks["validators"],
-  indexes: ValidatorIndex[]
-): BLSPubkey[] {
-  const validatorsLen = validators.length; // Get once, it's expensive
+export function getPubkeysForIndices(state: IBeaconStateView, indexes: ValidatorIndex[]): BLSPubkey[] {
+  const validatorsLen = state.validatorCount; // Get once, it's expensive
 
   const pubkeys: BLSPubkey[] = [];
   for (let i = 0, len = indexes.length; i < len; i++) {
@@ -38,7 +35,7 @@ export function getPubkeysForIndices(
     }
 
     // NOTE: This could be optimized further by traversing the tree optimally with .getNodes()
-    const validator = validators.getReadonly(index);
+    const validator = state.getValidator(index);
     pubkeys.push(validator.pubkey);
   }
 

package/src/chain/ColumnReconstructionTracker.ts

@@ -3,6 +3,7 @@ import {Logger, sleep} from "@lodestar/utils";
 import {Metrics} from "../metrics/metrics.js";
 import {DataColumnReconstructionCode, recoverDataColumnSidecars} from "../util/dataColumns.js";
 import {BlockInputColumns} from "./blocks/blockInput/index.js";
+import {PayloadEnvelopeInput} from "./blocks/payloadEnvelopeInput/index.js";
 import {ChainEventEmitter} from "./emitter.js";
 
 /**
@@ -53,25 +54,25 @@ export class ColumnReconstructionTracker {
     this.maxDelayMs = this.config.getSlotComponentDurationMs(RECONSTRUCTION_DELAY_MAX_BPS);
   }
 
-  triggerColumnReconstruction(blockInput: BlockInputColumns): void {
+  triggerColumnReconstruction(input: BlockInputColumns | PayloadEnvelopeInput): void {
     if (this.running) {
       return;
     }
 
-    if (this.lastBlockRootHex === blockInput.blockRootHex) {
+    if (this.lastBlockRootHex === input.blockRootHex) {
       return;
     }
 
     // We don't care about the outcome of this call,
     // just that it has been triggered for this block root.
     this.running = true;
-    this.lastBlockRootHex = blockInput.blockRootHex;
+    this.lastBlockRootHex = input.blockRootHex;
     const delay = this.minDelayMs + Math.random() * (this.maxDelayMs - this.minDelayMs);
     sleep(delay)
       .then(() => {
-        const logCtx = {slot: blockInput.slot, root: blockInput.blockRootHex};
+        const logCtx = {slot: input.slot, root: input.blockRootHex};
         this.logger.debug("Attempting data column sidecar reconstruction", logCtx);
-        recoverDataColumnSidecars(blockInput, this.emitter, this.metrics)
+        recoverDataColumnSidecars(input, this.emitter, this.metrics)
           .then((result) => {
             this.metrics?.recoverDataColumnSidecars.reconstructionResult.inc({result});
             this.logger.debug("Data column sidecar reconstruction complete", {...logCtx, result});

package/src/chain/GetBlobsTracker.ts

@@ -11,6 +11,7 @@ import {
   getDataColumnSidecarsFromExecution,
 } from "../util/execution.js";
 import {IBlockInput, isBlockInputBlobs} from "./blocks/blockInput/index.js";
+import {PayloadEnvelopeInput} from "./blocks/payloadEnvelopeInput/index.js";
 import {ChainEventEmitter} from "./emitter.js";
 
 export type GetBlobsTrackerInit = {
@@ -43,22 +44,22 @@ export class GetBlobsTracker {
     this.config = init.config;
   }
 
-  triggerGetBlobs(blockInput: IBlockInput): void {
-    if (this.activeReconstructions.has(blockInput.blockRootHex)) {
+  triggerGetBlobs(input: IBlockInput | PayloadEnvelopeInput, onComplete?: () => void): void {
+    if (this.activeReconstructions.has(input.blockRootHex)) {
       return;
     }
 
-    if (isBlockInputBlobs(blockInput)) {
+    if (!(input instanceof PayloadEnvelopeInput) && isBlockInputBlobs(input)) {
       // there is not preallocation for blob sidecars like there is for columns sidecars so no need to
       // store the index for the preallocated buffers
-      this.activeReconstructions.add(blockInput.blockRootHex);
+      this.activeReconstructions.add(input.blockRootHex);
       callInNextEventLoop(() => {
-        const logCtx = {slot: blockInput.slot, root: blockInput.blockRootHex};
+        const logCtx = {slot: input.slot, root: input.blockRootHex};
         this.logger.verbose("Trigger getBlobsV1 for block", logCtx);
-        getBlobSidecarsFromExecution(this.config, this.executionEngine, this.metrics, this.emitter, blockInput).finally(
+        getBlobSidecarsFromExecution(this.config, this.executionEngine, this.metrics, this.emitter, input).finally(
           () => {
             this.logger.verbose("Completed getBlobsV1 for block", logCtx);
-            this.activeReconstructions.delete(blockInput.blockRootHex);
+            this.activeReconstructions.delete(input.blockRootHex);
           }
         );
       });
@@ -72,7 +73,7 @@ export class GetBlobsTracker {
       this.blobsAndProofsBuffers[freeIndex] = {inUse: false, buffers: []};
     }
 
-    const maxBlobs = this.config.getMaxBlobsPerBlock(computeEpochAtSlot(blockInput.slot));
+    const maxBlobs = this.config.getMaxBlobsPerBlock(computeEpochAtSlot(input.slot));
     // double check that there is enough pre-allocated space (blob schedule may have changed since the last use)
     const timer = this.metrics?.peerDas.getBlobsV2PreAllocationTime.startTimer();
     for (let i = 0; i < maxBlobs; i++) {
@@ -84,22 +85,23 @@ export class GetBlobsTracker {
 
     // We don't care about the outcome of this call,
     // just that it has been triggered for this block root.
-    this.activeReconstructions.add(blockInput.blockRootHex);
+    this.activeReconstructions.add(input.blockRootHex);
     this.blobsAndProofsBuffers[freeIndex].inUse = true;
     callInNextEventLoop(() => {
-      const logCtx = {slot: blockInput.slot, root: blockInput.blockRootHex};
+      const logCtx = {slot: input.slot, root: input.blockRootHex};
       this.logger.verbose("Trigger getBlobsV2 for block", logCtx);
       getDataColumnSidecarsFromExecution(
         this.config,
         this.executionEngine,
         this.emitter,
-        blockInput,
+        input,
         this.metrics,
         this.blobsAndProofsBuffers[freeIndex].buffers
       )
         .then((result) => {
           this.logger.debug("getBlobsV2 result for block", {...logCtx, result});
           this.metrics?.dataColumns.dataColumnEngineResult.inc({result});
+          onComplete?.();
         })
         .catch((error) => {
           this.logger.debug("Error during getBlobsV2 for block", logCtx, error as Error);
@@ -107,7 +109,7 @@ export class GetBlobsTracker {
         })
         .finally(() => {
           this.logger.verbose("Completed getBlobsV2 for block", logCtx);
-          this.activeReconstructions.delete(blockInput.blockRootHex);
+          this.activeReconstructions.delete(input.blockRootHex);
           this.blobsAndProofsBuffers[freeIndex].inUse = false;
         });
     });

package/src/chain/archiveStore/archiveStore.ts

@@ -120,6 +120,7 @@ export class ArchiveStore {
         opts: {
           genesisTime: this.chain.clock.genesisTime,
           dbLocation: this.opts.dbName,
+          nativeStateView: this.opts.nativeStateView ?? false,
         },
         config: this.chain.config,
         metrics: this.metrics,

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

@@ -1,33 +1,15 @@
 import {BeaconConfig} from "@lodestar/config";
 import {
-  BeaconStateAllForks,
-  CachedBeaconStateAllForks,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
-  PubkeyCache,
-  createCachedBeaconState,
-  stateTransition,
+  IBeaconStateView,
+  createBeaconStateViewForHistoricalRegen,
 } from "@lodestar/state-transition";
 import {byteArrayEquals} from "@lodestar/utils";
 import {IBeaconDb} from "../../../db/index.js";
-import {getStateTypeFromBytes} from "../../../util/multifork.js";
 import {HistoricalStateRegenMetrics} from "./metrics.js";
 import {RegenErrorType} from "./types.js";
 
-/**
- * Populate a PubkeyCache with any new entries based on a BeaconState
- */
-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 = pubkeyCache.size; i < newCount; i++) {
-    const pubkey = validators.getReadonly(i).pubkey;
-    pubkeyCache.set(i, pubkey);
-  }
-}
-
 /**
  * Get the nearest BeaconState at or before a slot
  */
@@ -35,27 +17,17 @@ export async function getNearestState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkeyCache: PubkeyCache
-): Promise<CachedBeaconStateAllForks> {
+  nativeStateView: boolean
+): Promise<IBeaconStateView> {
   const stateBytesArr = await db.stateArchive.binaries({limit: 1, lte: slot, reverse: true});
   if (!stateBytesArr.length) {
     throw new Error("No near state found in the database");
   }
 
   const stateBytes = stateBytesArr[0];
-  const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
-  syncPubkeyCache(state, pubkeyCache);
-
-  return createCachedBeaconState(
-    state,
-    {
-      config,
-      pubkeyCache,
-    },
-    {
-      skipSyncPubkeys: true,
-    }
-  );
+  return nativeStateView
+    ? createBeaconStateViewForHistoricalRegen({useNative: true, stateBytes})
+    : createBeaconStateViewForHistoricalRegen({useNative: false, config, stateBytes});
 }
 
 /**
@@ -65,13 +37,13 @@ export async function getHistoricalState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkeyCache: PubkeyCache,
+  nativeStateView: boolean,
   metrics?: HistoricalStateRegenMetrics
 ): Promise<Uint8Array> {
   const regenTimer = metrics?.regenTime.startTimer();
 
   const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, pubkeyCache).catch((e) => {
+  let state = await getNearestState(slot, config, db, nativeStateView).catch((e) => {
     metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
     throw e;
   });
@@ -81,8 +53,7 @@ export async function getHistoricalState(
   let blockCount = 0;
   for await (const block of db.blockArchive.valuesStream({gt: state.slot, lte: slot})) {
     try {
-      state = stateTransition(
-        state,
+      state = state.stateTransition(
         block,
         {
           verifyProposer: false,

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

@@ -20,7 +20,7 @@ export class HistoricalStateRegen implements HistoricalStateWorkerApi {
   private readonly api: ModuleThread<HistoricalStateWorkerApi>;
   private readonly logger: LoggerNode;
 
-  constructor(modules: HistoricalStateRegenModules) {
+  private constructor(modules: HistoricalStateRegenModules) {
     this.api = modules.api;
     this.logger = modules.logger;
     modules.signal?.addEventListener("abort", () => this.close(), {once: true});
@@ -35,6 +35,7 @@ export class HistoricalStateRegen implements HistoricalStateWorkerApi {
       dbLocation: modules.opts.dbLocation,
       metricsEnabled: Boolean(modules.metrics),
       loggerOpts: modules.logger.toOpts(),
+      nativeStateView: modules.opts.nativeStateView,
     };
 
     const worker = new Worker(path.join(WORKER_DIR, "worker.js"), {

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

@@ -7,6 +7,7 @@ export type HistoricalStateRegenInitModules = {
   opts: {
     genesisTime: number;
     dbLocation: string;
+    nativeStateView: boolean;
   };
   config: BeaconConfig;
   logger: LoggerNode;
@@ -26,6 +27,7 @@ export type HistoricalStateWorkerData = {
   dbLocation: string;
   metricsEnabled: boolean;
   loggerOpts: LoggerNodeOpts;
+  nativeStateView: boolean;
 };
 
 export type HistoricalStateWorkerApi = {

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

@@ -3,7 +3,6 @@ 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,8 +51,6 @@ const queue = new JobFnQueue(
   queueMetrics
 );
 
-const pubkeyCache = createPubkeyCache();
-
 const api: HistoricalStateWorkerApi = {
   async close() {
     abortController.abort();
@@ -65,7 +62,7 @@ const api: HistoricalStateWorkerApi = {
     historicalStateRegenMetrics?.regenRequestCount.inc();
 
     const stateBytes = await queue.push<Uint8Array>(() =>
-      getHistoricalState(slot, config, db, pubkeyCache, historicalStateRegenMetrics)
+      getHistoricalState(slot, config, db, workerData.nativeStateView, historicalStateRegenMetrics)
     );
     const result = Transfer(stateBytes, [stateBytes.buffer]) as unknown as Uint8Array;
 

package/src/chain/archiveStore/interface.ts

@@ -25,6 +25,7 @@ export type ArchiveStoreOpts = StatesArchiveOpts & {
   archiveDataEpochs?: number;
   pruneHistory?: boolean;
   serveHistoricalState?: boolean;
+  nativeStateView?: boolean;
 };
 
 export type ProposalStats = {

package/src/chain/balancesCache.ts

@@ -1,11 +1,5 @@
 import {CheckpointWithHex} from "@lodestar/fork-choice";
-import {
-  CachedBeaconStateAllForks,
-  EffectiveBalanceIncrements,
-  computeStartSlotAtEpoch,
-  getBlockRootAtSlot,
-  getEffectiveBalanceIncrementsZeroInactive,
-} from "@lodestar/state-transition";
+import {EffectiveBalanceIncrements, IBeaconStateView, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, RootHex} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 
@@ -29,11 +23,11 @@ export class CheckpointBalancesCache {
    * `state.current_epoch`. If there is not already some entry for the given block root, then
    * add the effective balances from the `state` to the cache.
    */
-  processState(blockRootHex: RootHex, state: CachedBeaconStateAllForks): void {
-    const epoch = state.epochCtx.epoch;
+  processState(blockRootHex: RootHex, state: IBeaconStateView): void {
+    const epoch = state.epoch;
     const epochBoundarySlot = computeStartSlotAtEpoch(epoch);
     const epochBoundaryRoot =
-      epochBoundarySlot === state.slot ? blockRootHex : toRootHex(getBlockRootAtSlot(state, epochBoundarySlot));
+      epochBoundarySlot === state.slot ? blockRootHex : toRootHex(state.getBlockRootAtSlot(epochBoundarySlot));
 
     const index = this.items.findIndex((item) => item.epoch === epoch && item.rootHex === epochBoundaryRoot);
     if (index === -1) {
@@ -41,7 +35,7 @@ export class CheckpointBalancesCache {
         this.items.shift();
       }
       // expect to reach this once per epoch
-      this.items.push({epoch, rootHex: epochBoundaryRoot, balances: getEffectiveBalanceIncrementsZeroInactive(state)});
+      this.items.push({epoch, rootHex: epochBoundaryRoot, balances: state.getEffectiveBalanceIncrementsZeroInactive()});
     }
   }