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

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

@@ -35,6 +35,7 @@ import {
 } from "@lodestar/types";
 import {fromHex, sleep, toHex, toRootHex} from "@lodestar/utils";
 import {BlockInputSource, isBlockInputBlobs, isBlockInputColumns} from "../../../../chain/blocks/blockInput/index.js";
+import {PayloadEnvelopeInputSource} from "../../../../chain/blocks/payloadEnvelopeInput/index.js";
 import {ImportBlockOpts} from "../../../../chain/blocks/types.js";
 import {verifyBlocksInEpoch} from "../../../../chain/blocks/verifyBlock.js";
 import {BeaconChain} from "../../../../chain/chain.js";
@@ -48,6 +49,7 @@ import {
   ProduceFullGloas,
 } from "../../../../chain/produceBlock/index.js";
 import {validateGossipBlock} from "../../../../chain/validation/block.js";
+import {validateApiExecutionPayloadEnvelope} from "../../../../chain/validation/executionPayloadEnvelope.js";
 import {OpSource} from "../../../../chain/validatorMonitor.js";
 import {
   computePreFuluKzgCommitmentsInclusionProof,
@@ -55,7 +57,11 @@ import {
   kzgCommitmentToVersionedHash,
   reconstructBlobs,
 } from "../../../../util/blobs.js";
-import {getDataColumnSidecarsForGloas, getDataColumnSidecarsFromBlock} from "../../../../util/dataColumns.js";
+import {
+  getBlobKzgCommitments,
+  getDataColumnSidecarsFromBlock,
+  getGloasDataColumnSidecars,
+} from "../../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../../util/forkChoice.js";
 import {kzg} from "../../../../util/kzg.js";
 import {promiseAllMaybeAsync} from "../../../../util/promises.js";
@@ -97,17 +103,20 @@ export function getBeaconBlockApi({
     const fork = config.getForkName(slot);
     const blockRoot = toRootHex(chain.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(signedBlock.message));
 
-    // TODO GLOAS: handle new BlockInput type
     const blockForImport = chain.seenBlockInputCache.getByBlock({
       block: signedBlock,
       source: BlockInputSource.api,
       seenTimestampSec,
       blockRootHex: blockRoot,
     });
-    let blobSidecars: deneb.BlobSidecars, dataColumnSidecars: fulu.DataColumnSidecars;
+    let blobSidecars: deneb.BlobSidecars, dataColumnSidecars: fulu.DataColumnSidecar[];
 
     if (isDenebBlockContents(signedBlockContents)) {
-      if (isForkPostFulu(fork)) {
+      if (isForkPostGloas(fork)) {
+        // After gloas, data columns are not published with the block but when publishing the execution payload envelope
+        blobSidecars = [];
+        dataColumnSidecars = [];
+      } else if (isForkPostFulu(fork)) {
         const timer = metrics?.peerDas.dataColumnSidecarComputationTime.startTimer();
         // If the block was produced by this node, we will already have computed cells
         // Otherwise, we will compute them from the blobs in this function
@@ -122,7 +131,7 @@ export function getBeaconBlockApi({
           config,
           signedBlock as SignedBeaconBlock<ForkPostFulu>,
           cellsAndProofs
-        );
+        ) as fulu.DataColumnSidecar[];
         timer?.();
         blobSidecars = [];
       } else if (isForkPostDeneb(fork)) {
@@ -208,7 +217,7 @@ export function getBeaconBlockApi({
         if (!blockLocallyProduced) {
           const parentBlock = chain.forkChoice.getBlockDefaultStatus(signedBlock.message.parentRoot);
           if (parentBlock === null) {
-            chain.emitter.emit(ChainEvent.unknownParent, {
+            chain.emitter.emit(ChainEvent.blockUnknownParent, {
               blockInput: blockForImport,
               peer: IDENTITY_PEER_ID,
               source: BlockInputSource.api,
@@ -303,7 +312,7 @@ export function getBeaconBlockApi({
           .processBlock(blockForImport, opts)
           .catch((e) => {
             if (e instanceof BlockError && e.type.code === BlockErrorCode.PARENT_UNKNOWN) {
-              chain.emitter.emit(ChainEvent.unknownParent, {
+              chain.emitter.emit(ChainEvent.blockUnknownParent, {
                 blockInput: blockForImport,
                 peer: IDENTITY_PEER_ID,
                 source: BlockInputSource.api,
@@ -605,7 +614,7 @@ export function getBeaconBlockApi({
         if (slot < head.slot && head.slot <= slot + SLOTS_PER_HISTORICAL_ROOT) {
           const state = chain.getHeadState();
           return {
-            data: {root: state.blockRoots.get(slot % SLOTS_PER_HISTORICAL_ROOT)},
+            data: {root: state.getBlockRootAtSlot(slot)},
             meta: {
               executionOptimistic: isOptimisticBlock(head),
               finalized: computeEpochAtSlot(slot) <= chain.forkChoice.getFinalizedCheckpoint().epoch,
@@ -645,6 +654,8 @@ export function getBeaconBlockApi({
       const slot = envelope.slot;
       const fork = config.getForkName(slot);
       const blockRootHex = toRootHex(envelope.beaconBlockRoot);
+      const blockHashHex = toRootHex(envelope.payload.blockHash);
+      const stateRootHex = toRootHex(envelope.stateRoot);
 
       if (!isForkPostGloas(fork)) {
         throw new ApiError(400, `publishExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
@@ -659,8 +670,10 @@ export function getBeaconBlockApi({
         throw new ApiError(400, `Envelope slot ${slot} does not match block slot ${block.slot}`);
       }
 
+      await validateApiExecutionPayloadEnvelope(chain, signedExecutionPayloadEnvelope);
+
       const isSelfBuild = envelope.builderIndex === BUILDER_INDEX_SELF_BUILD;
-      let dataColumnSidecars: gloas.DataColumnSidecars = [];
+      let dataColumnSidecars: gloas.DataColumnSidecar[] = [];
 
       if (isSelfBuild) {
         // For self-builds, construct and publish data column sidecars from cached block production data
@@ -676,6 +689,7 @@ export function getBeaconBlockApi({
         }
 
         if (cachedResult.cells && cachedResult.blobsBundle.commitments.length > 0) {
+          const timer = metrics?.peerDas.dataColumnSidecarComputationTime.startTimer();
           const cellsAndProofs = cachedResult.cells.map((rowCells, rowIndex) => ({
             cells: rowCells,
             proofs: cachedResult.blobsBundle.proofs.slice(
@@ -684,54 +698,80 @@ export function getBeaconBlockApi({
             ),
           }));
 
-          dataColumnSidecars = getDataColumnSidecarsForGloas(slot, envelope.beaconBlockRoot, cellsAndProofs);
+          dataColumnSidecars = getGloasDataColumnSidecars(slot, envelope.beaconBlockRoot, cellsAndProofs);
+          timer?.();
         }
       } else {
         // TODO GLOAS: will this api be used by builders or only for self-building?
       }
 
-      // TODO GLOAS: Verify execution payload envelope signature
-      // For self-builds, the proposer signs with their own validator key
-      // For external builders, verify using the builder's registered pubkey
-      // Use verify_execution_payload_envelope_signature(state, signed_envelope)
+      // If called near a slot boundary (e.g. late in slot N-1), hold briefly so gossip aligns with slot N.
+      const msToBlockSlot = computeTimeAtSlot(config, slot, chain.genesisTime) * 1000 - Date.now();
+      if (msToBlockSlot <= MAX_API_CLOCK_DISPARITY_MS && msToBlockSlot > 0) {
+        await sleep(msToBlockSlot);
+      }
 
-      // TODO GLOAS: Process execution payload via state transition
-      // Call process_execution_payload(state, signed_envelope, execution_engine)
+      // TODO GLOAS: if block and payload are submitted in parallel, payloadInput may not yet exist.
+      // A queuing mechanism is needed to handle this case. See https://github.com/ChainSafe/lodestar/issues/8915
+      const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
+      if (!payloadInput) {
+        throw new ApiError(404, `PayloadEnvelopeInput not found for block root ${blockRootHex}`);
+      }
 
-      // TODO GLOAS: Update fork choice with the execution payload
-      // Call on_execution_payload(store, signed_envelope) to update fork choice state
+      payloadInput.addPayloadEnvelope({
+        envelope: signedExecutionPayloadEnvelope,
+        source: PayloadEnvelopeInputSource.api,
+        seenTimestampSec,
+        peerIdStr: undefined,
+      });
 
-      // TODO GLOAS: Add envelope and data columns to block input via seenBlockInputCache
-      // and trigger block import (Gloas block import requires both beacon block and envelope)
+      if (dataColumnSidecars.length > 0) {
+        for (const columnSidecar of dataColumnSidecars) {
+          payloadInput.addColumn({
+            columnSidecar,
+            source: PayloadEnvelopeInputSource.api,
+            seenTimestampSec,
+            peerIdStr: undefined,
+          });
+        }
+      }
 
       const valLogMeta = {
         slot,
         blockRoot: blockRootHex,
+        blockHash: blockHashHex,
+        stateRoot: stateRootHex,
         builderIndex: envelope.builderIndex,
         isSelfBuild,
         dataColumns: dataColumnSidecars.length,
       };
 
-      // If called near a slot boundary (e.g. late in slot N-1), hold briefly so gossip aligns with slot N.
-      const msToBlockSlot = computeTimeAtSlot(config, slot, chain.genesisTime) * 1000 - Date.now();
-      if (msToBlockSlot <= MAX_API_CLOCK_DISPARITY_MS && msToBlockSlot > 0) {
-        await sleep(msToBlockSlot);
-      }
-
       const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
       metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.api}, delaySec);
+      chain.validatorMonitor?.registerExecutionPayloadEnvelope(OpSource.api, delaySec, signedExecutionPayloadEnvelope);
 
       chain.logger.info("Publishing execution payload envelope", valLogMeta);
 
-      // Publish envelope and data columns
       const publishPromises = [
         // Gossip the signed execution payload envelope first
         () => network.publishSignedExecutionPayloadEnvelope(signedExecutionPayloadEnvelope),
         // For self-builds, publish all data column sidecars
         ...dataColumnSidecars.map((dataColumnSidecar) => () => network.publishDataColumnSidecar(dataColumnSidecar)),
+        // Import execution payload. Signature already verified above
+        () => chain.processExecutionPayload(payloadInput, {validSignature: true}),
       ];
 
-      const sentPeersArr = await promiseAllMaybeAsync<number | void>(publishPromises);
+      const publishPromise = promiseAllMaybeAsync<number | void>(publishPromises);
+
+      chain.emitter.emit(routes.events.EventType.executionPayloadGossip, {
+        slot,
+        builderIndex: envelope.builderIndex,
+        blockHash: blockHashHex,
+        blockRoot: blockRootHex,
+        stateRoot: stateRootHex,
+      });
+
+      const sentPeersArr = await publishPromise;
 
       // Track metrics for data column publishing
       if (dataColumnSidecars.length > 0) {
@@ -755,15 +795,11 @@ export function getBeaconBlockApi({
         metrics?.dataColumns.bySource.inc({source: BlockInputSource.api}, dataColumnSidecars.length);
 
         if (chain.emitter.listenerCount(routes.events.EventType.dataColumnSidecar)) {
-          // TODO GLOAS: revisit this, we likely don't wanna emit KZG commitments anymore
-          const cachedResult = chain.blockProductionCache.get(blockRootHex) as ProduceFullGloas | undefined;
-          const kzgCommitments = cachedResult?.blobsBundle.commitments.map(toHex) ?? [];
           for (const dataColumnSidecar of dataColumnSidecars) {
             chain.emitter.emit(routes.events.EventType.dataColumnSidecar, {
               blockRoot: blockRootHex,
               slot,
               index: dataColumnSidecar.index,
-              kzgCommitments,
             });
           }
         }
@@ -887,7 +923,7 @@ export function getBeaconBlockApi({
           );
         }
 
-        const blobKzgCommitments = (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments;
+        const blobKzgCommitments = getBlobKzgCommitments(fork, block as SignedBeaconBlock<ForkPostFulu>);
         const blobCount = blobKzgCommitments.length;
 
         if (blobCount > 0) {

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

@@ -1,6 +1,7 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ForkPostElectra, ForkPreElectra, SYNC_COMMITTEE_SUBNET_SIZE, isForkPostElectra} from "@lodestar/params";
+import {isStatePostAltair} from "@lodestar/state-transition";
 import {Attestation, Epoch, SingleAttestation, isElectraAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {
   AttestationError,
@@ -249,13 +250,16 @@ export function getBeaconPoolApi({
 
       // TODO: Fetch states at signature slots
       const state = chain.getHeadState();
+      if (!isStatePostAltair(state)) {
+        throw new ApiError(400, "Sync committee pool is not supported before Altair");
+      }
 
       const failures: FailureList = [];
 
       await Promise.all(
         signatures.map(async (signature, i) => {
           try {
-            const synCommittee = state.epochCtx.getIndexedSyncCommittee(signature.slot);
+            const synCommittee = state.getIndexedSyncCommittee(signature.slot);
             const indexesInCommittee = synCommittee.validatorIndexMap.get(signature.validatorIndex);
             if (indexesInCommittee === undefined || indexesInCommittee.length === 0) {
               return; // Not a sync committee member

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