@lodestar/beacon-node 1.42.0-dev.c35b4283f1 → 1.42.0-dev.c58e92512e

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

@@ -1,24 +1,16 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
+import {EPOCHS_PER_HISTORICAL_VECTOR, SLOTS_PER_EPOCH, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {
-  EPOCHS_PER_HISTORICAL_VECTOR,
-  SLOTS_PER_EPOCH,
-  SYNC_COMMITTEE_SUBNET_SIZE,
-  isForkPostElectra,
-  isForkPostFulu,
-} from "@lodestar/params";
-import {
-  BeaconStateAllForks,
-  BeaconStateElectra,
-  BeaconStateFulu,
-  CachedBeaconStateAltair,
+  IBeaconStateView,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   getCurrentEpoch,
-  getRandaoMix,
-  loadState,
+  isStatePostAltair,
+  isStatePostElectra,
+  isStatePostFulu,
 } from "@lodestar/state-transition";
-import {ValidatorIndex, getValidatorStatus} from "@lodestar/types";
+import {ValidatorIndex, getValidatorStatus, ssz} from "@lodestar/types";
 import {ApiError} from "../../errors.js";
 import {ApiModules} from "../../types.js";
 import {assertUniqueItems} from "../../utils.js";
@@ -35,11 +27,11 @@ export function getBeaconStateApi({
 }: Pick<ApiModules, "chain" | "config">): ApplicationMethods<routes.beacon.state.Endpoints> {
   async function getState(
     stateId: routes.beacon.StateId
-  ): Promise<{state: BeaconStateAllForks; executionOptimistic: boolean; finalized: boolean}> {
+  ): Promise<{state: IBeaconStateView; executionOptimistic: boolean; finalized: boolean}> {
     const {state, executionOptimistic, finalized} = await getStateResponseWithRegen(chain, stateId);
 
     return {
-      state: state instanceof Uint8Array ? loadState(config, chain.getHeadState(), state).state : state,
+      state: state instanceof Uint8Array ? chain.getHeadState().loadOtherState(state) : state,
       executionOptimistic,
       finalized,
     };
@@ -71,7 +63,7 @@ export function getBeaconStateApi({
         throw new ApiError(400, "Requested epoch is out of range");
       }
 
-      const randao = getRandaoMix(state, usedEpoch);
+      const randao = state.getRandaoMix(usedEpoch);
 
       return {
         data: {randao},
@@ -94,7 +86,6 @@ export function getBeaconStateApi({
     async getStateValidators({stateId, validatorIds = [], statuses = []}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
       const currentEpoch = getCurrentEpoch(state);
-      const {validators, balances} = state; // Get the validators sub tree once for all the loop
       const {pubkeyCache} = chain;
 
       const validatorResponses: routes.beacon.ValidatorResponse[] = [];
@@ -105,14 +96,14 @@ export function getBeaconStateApi({
           const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const validatorIndex = resp.validatorIndex;
-            const validator = validators.getReadonly(validatorIndex);
+            const validator = state.getValidator(validatorIndex);
             if (statuses.length && !statuses.includes(getValidatorStatus(validator, currentEpoch))) {
               continue;
             }
             const validatorResponse = toValidatorResponse(
               validatorIndex,
               validator,
-              balances.get(validatorIndex),
+              state.getBalance(validatorIndex),
               currentEpoch
             );
             validatorResponses.push(validatorResponse);
@@ -135,8 +126,8 @@ export function getBeaconStateApi({
       }
 
       // TODO: This loops over the entire state, it's a DOS vector
-      const validatorsArr = state.validators.getAllReadonlyValues();
-      const balancesArr = state.balances.getAll();
+      const validatorsArr = state.getAllValidators();
+      const balancesArr = state.getAllBalances();
       const resp: routes.beacon.ValidatorResponse[] = [];
       for (let i = 0; i < validatorsArr.length; i++) {
         resp.push(toValidatorResponse(i, validatorsArr[i], balancesArr[i], currentEpoch));
@@ -166,12 +157,12 @@ export function getBeaconStateApi({
           const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const index = resp.validatorIndex;
-            const {pubkey, activationEpoch} = state.validators.getReadonly(index);
+            const {pubkey, activationEpoch} = state.getValidator(index);
             validatorIdentities.push({index, pubkey, activationEpoch});
           }
         }
       } else {
-        const validatorsArr = state.validators.getAllReadonlyValues();
+        const validatorsArr = state.getAllValidators();
         validatorIdentities = new Array(validatorsArr.length) as routes.beacon.ValidatorIdentities;
         for (let i = 0; i < validatorsArr.length; i++) {
           const {pubkey, activationEpoch} = validatorsArr[i];
@@ -198,8 +189,8 @@ export function getBeaconStateApi({
       return {
         data: toValidatorResponse(
           validatorIndex,
-          state.validators.getReadonly(validatorIndex),
-          state.balances.get(validatorIndex),
+          state.getValidator(validatorIndex),
+          state.getBalance(validatorIndex),
           getCurrentEpoch(state)
         ),
         meta: {executionOptimistic, finalized},
@@ -219,7 +210,7 @@ export function getBeaconStateApi({
           if (resp.valid) {
             balances.push({
               index: resp.validatorIndex,
-              balance: state.balances.get(resp.validatorIndex),
+              balance: state.getBalance(resp.validatorIndex),
             });
           }
         }
@@ -230,7 +221,7 @@ export function getBeaconStateApi({
       }
 
       // TODO: This loops over the entire state, it's a DOS vector
-      const balancesArr = state.balances.getAll();
+      const balancesArr = state.getAllBalances();
       const resp: routes.beacon.ValidatorBalance[] = [];
       for (let i = 0; i < balancesArr.length; i++) {
         resp.push({index: i, balance: balancesArr[i]});
@@ -248,11 +239,6 @@ export function getBeaconStateApi({
     async getEpochCommittees({stateId, ...filters}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
 
-      const stateCached = state as CachedBeaconStateAltair;
-      if (stateCached.epochCtx === undefined) {
-        throw new ApiError(400, `No cached state available for stateId: ${stateId}`);
-      }
-
       const stateEpoch = computeEpochAtSlot(state.slot);
       const epoch = filters.epoch ?? stateEpoch;
       const startSlot = computeStartSlotAtEpoch(epoch);
@@ -266,7 +252,7 @@ export function getBeaconStateApi({
         throw new ApiError(400, `Slot ${filters.slot} is not in epoch ${epoch}`);
       }
 
-      const decisionRoot = stateCached.epochCtx.getShufflingDecisionRoot(epoch);
+      const decisionRoot = state.getShufflingDecisionRoot(epoch);
       const shuffling = await chain.shufflingCache.get(epoch, decisionRoot);
       if (!shuffling) {
         throw new ApiError(
@@ -314,13 +300,11 @@ export function getBeaconStateApi({
       if (stateEpoch < config.ALTAIR_FORK_EPOCH) {
         throw new ApiError(400, "Requested state before ALTAIR_FORK_EPOCH");
       }
-
-      const stateCached = state as CachedBeaconStateAltair;
-      if (stateCached.epochCtx === undefined) {
-        throw new ApiError(400, `No cached state available for stateId: ${stateId}`);
+      if (!isStatePostAltair(state)) {
+        throw new Error("Expected Altair state for sync committee lookup");
       }
 
-      const syncCommitteeCache = stateCached.epochCtx.getIndexedSyncCommitteeAtEpoch(epoch ?? stateEpoch);
+      const syncCommitteeCache = state.getIndexedSyncCommitteeAtEpoch(epoch ?? stateEpoch);
       const validatorIndices = new Array<ValidatorIndex>(...syncCommitteeCache.validatorIndices);
 
       // Subcommittee assignments of the current sync committee
@@ -340,64 +324,68 @@ export function getBeaconStateApi({
 
     async getPendingDeposits({stateId}, context) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const fork = config.getForkName(state.slot);
+      const fork = state.forkName;
 
-      if (!isForkPostElectra(fork)) {
+      if (!isStatePostElectra(state)) {
         throw new ApiError(400, `Cannot retrieve pending deposits for pre-electra state fork=${fork}`);
       }
 
-      const {pendingDeposits} = state as BeaconStateElectra;
+      const pendingDeposits = state.pendingDeposits;
 
       return {
-        data: context?.returnBytes ? pendingDeposits.serialize() : pendingDeposits.toValue(),
+        data: context?.returnBytes ? ssz.electra.PendingDeposits.serialize(pendingDeposits) : pendingDeposits,
         meta: {executionOptimistic, finalized, version: fork},
       };
     },
 
     async getPendingPartialWithdrawals({stateId}, context) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const fork = config.getForkName(state.slot);
+      const fork = state.forkName;
 
-      if (!isForkPostElectra(fork)) {
+      if (!isStatePostElectra(state)) {
         throw new ApiError(400, `Cannot retrieve pending partial withdrawals for pre-electra state fork=${fork}`);
       }
 
-      const {pendingPartialWithdrawals} = state as BeaconStateElectra;
+      const pendingPartialWithdrawals = state.pendingPartialWithdrawals;
 
       return {
-        data: context?.returnBytes ? pendingPartialWithdrawals.serialize() : pendingPartialWithdrawals.toValue(),
+        data: context?.returnBytes
+          ? ssz.electra.PendingPartialWithdrawals.serialize(pendingPartialWithdrawals)
+          : pendingPartialWithdrawals,
         meta: {executionOptimistic, finalized, version: fork},
       };
     },
 
     async getPendingConsolidations({stateId}, context) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const fork = config.getForkName(state.slot);
+      const fork = state.forkName;
 
-      if (!isForkPostElectra(fork)) {
+      if (!isStatePostElectra(state)) {
         throw new ApiError(400, `Cannot retrieve pending consolidations for pre-electra state fork=${fork}`);
       }
 
-      const {pendingConsolidations} = state as BeaconStateElectra;
+      const pendingConsolidations = state.pendingConsolidations;
 
       return {
-        data: context?.returnBytes ? pendingConsolidations.serialize() : pendingConsolidations.toValue(),
+        data: context?.returnBytes
+          ? ssz.electra.PendingConsolidations.serialize(pendingConsolidations)
+          : pendingConsolidations,
         meta: {executionOptimistic, finalized, version: fork},
       };
     },
 
     async getProposerLookahead({stateId}, context) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const fork = config.getForkName(state.slot);
+      const fork = state.forkName;
 
-      if (!isForkPostFulu(fork)) {
+      if (!isStatePostFulu(state)) {
         throw new ApiError(400, `Cannot retrieve proposer lookahead for pre-fulu state fork=${fork}`);
       }
 
-      const {proposerLookahead} = state as BeaconStateFulu;
+      const proposerLookahead = state.proposerLookahead;
 
       return {
-        data: context?.returnBytes ? proposerLookahead.serialize() : proposerLookahead.toValue(),
+        data: context?.returnBytes ? ssz.fulu.ProposerLookahead.serialize(proposerLookahead) : proposerLookahead,
         meta: {executionOptimistic, finalized, version: fork},
       };
     },

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

@@ -1,17 +1,8 @@
 import {routes} from "@lodestar/api";
 import {CheckpointWithPayloadStatus, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {BeaconStateAllForks, CachedBeaconStateAllForks, PubkeyCache} from "@lodestar/state-transition";
-import {
-  BLSPubkey,
-  Epoch,
-  RootHex,
-  Slot,
-  ValidatorIndex,
-  getValidatorStatus,
-  mapToGeneralStatus,
-  phase0,
-} from "@lodestar/types";
+import {IBeaconStateView, PubkeyCache} from "@lodestar/state-transition";
+import {BLSPubkey, Epoch, RootHex, Slot, ValidatorIndex, getValidatorStatus, phase0} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../../chain/index.js";
 import {ApiError, ValidationError} from "../../errors.js";
@@ -52,7 +43,7 @@ export function resolveStateId(
 export async function getStateResponseWithRegen(
   chain: IBeaconChain,
   inStateId: routes.beacon.StateId
-): Promise<{state: CachedBeaconStateAllForks | Uint8Array; executionOptimistic: boolean; finalized: boolean}> {
+): Promise<{state: IBeaconStateView | Uint8Array; executionOptimistic: boolean; finalized: boolean}> {
   const stateId = resolveStateId(chain.forkChoice, inStateId);
 
   const res =
@@ -89,22 +80,17 @@ export function toValidatorResponse(
 
 export function filterStateValidatorsByStatus(
   statuses: string[],
-  state: BeaconStateAllForks,
+  state: IBeaconStateView,
   pubkeyCache: PubkeyCache,
   currentEpoch: Epoch
 ): routes.beacon.ValidatorResponse[] {
   const responses: routes.beacon.ValidatorResponse[] = [];
-  const validatorsArr = state.validators.getAllReadonlyValues();
-  const statusSet = new Set(statuses);
-
-  for (const validator of validatorsArr) {
-    const validatorStatus = getValidatorStatus(validator, currentEpoch);
-    const generalStatus = mapToGeneralStatus(validatorStatus);
-
+  const validators = state.getValidatorsByStatus(new Set(statuses), currentEpoch);
+  for (const validator of validators) {
     const resp = getStateValidatorIndex(validator.pubkey, state, pubkeyCache);
-    if (resp.valid && (statusSet.has(validatorStatus) || statusSet.has(generalStatus))) {
+    if (resp.valid) {
       responses.push(
-        toValidatorResponse(resp.validatorIndex, validator, state.balances.get(resp.validatorIndex), currentEpoch)
+        toValidatorResponse(resp.validatorIndex, validator, state.getBalance(resp.validatorIndex), currentEpoch)
       );
     }
   }
@@ -117,7 +103,7 @@ type StateValidatorIndexResponse =
 
 export function getStateValidatorIndex(
   id: routes.beacon.ValidatorId | BLSPubkey,
-  state: BeaconStateAllForks,
+  state: IBeaconStateView,
   pubkeyCache: PubkeyCache
 ): StateValidatorIndexResponse {
   if (typeof id === "string") {
@@ -139,7 +125,7 @@ export function getStateValidatorIndex(
     if (!Number.isSafeInteger(validatorIndex)) {
       return {valid: false, code: 400, reason: "Invalid validator index"};
     }
-    if (validatorIndex >= state.validators.length) {
+    if (validatorIndex >= state.validatorCount) {
       return {valid: false, code: 404, reason: "Validator index from future state"};
     }
     return {valid: true, validatorIndex};
@@ -150,7 +136,7 @@ export function getStateValidatorIndex(
   if (validatorIndex === null) {
     return {valid: false, code: 404, reason: "Validator pubkey not found in state"};
   }
-  if (validatorIndex >= state.validators.length) {
+  if (validatorIndex >= state.validatorCount) {
     return {valid: false, code: 404, reason: "Validator pubkey from future state"};
   }
   return {valid: true, validatorIndex};

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

@@ -2,7 +2,7 @@ import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus} from "@lodestar/fork-choice";
 import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {BeaconState, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
+import {BeaconState, DataColumnSidecar, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../util/forkChoice.js";
@@ -98,7 +98,7 @@ export function getDebugApi({
       const fork = config.getForkName(block.message.slot);
       const blockRoot = sszTypesFor(fork).BeaconBlock.hashTreeRoot(block.message);
 
-      let dataColumnSidecars: DataColumnSidecars;
+      let dataColumnSidecars: DataColumnSidecar[];
 
       const blobCount = isForkPostDeneb(fork)
         ? getBlobKzgCommitments(fork, block as SignedBeaconBlock<ForkPostDeneb>).length

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" ||

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);
   }