@lodestar/beacon-node 1.42.0-dev.f6213da56d → 1.42.0-dev.f866249fa3

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

package/src/chain/blocks/blockInput/blockInput.ts

@@ -617,7 +617,7 @@ type BlockInputColumnsState =
  * - The block is not yet seen and all required sampled columns are seen
  * - The block is not yet seen and all required sampled columns are not yet seen
  */
-export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.DataColumnSidecars> {
+export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.DataColumnSidecar[]> {
   type = DAType.Columns as const;
 
   state: BlockInputColumnsState;
@@ -630,7 +630,7 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
    *
    * This is different from `dataPromise` which resolves when all data is available or could become available (e.g. through reconstruction)
    */
-  protected computedDataPromise = createPromise<fulu.DataColumnSidecars>();
+  protected computedDataPromise = createPromise<fulu.DataColumnSidecar[]>();
 
   private constructor(
     init: BlockInputInit,
@@ -854,8 +854,8 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return this.state.versionedHashes;
   }
 
-  getCustodyColumns(): fulu.DataColumnSidecars {
-    const columns: fulu.DataColumnSidecars = [];
+  getCustodyColumns(): fulu.DataColumnSidecar[] {
+    const columns: fulu.DataColumnSidecar[] = [];
     for (const index of this.custodyColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -876,8 +876,8 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return columns;
   }
 
-  getSampledColumns(): fulu.DataColumnSidecars {
-    const columns: fulu.DataColumnSidecars = [];
+  getSampledColumns(): fulu.DataColumnSidecar[] {
+    const columns: fulu.DataColumnSidecar[] = [];
     for (const index of this.sampledColumns) {
       const column = this.columnsCache.get(index);
       if (column) {
@@ -891,7 +891,7 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return [...this.columnsCache.values()];
   }
 
-  getAllColumns(): fulu.DataColumnSidecars {
+  getAllColumns(): fulu.DataColumnSidecar[] {
     return this.getAllColumnsWithSource().map(({columnSidecar}) => columnSidecar);
   }
 
@@ -919,7 +919,7 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return this.state.hasComputedAllData;
   }
 
-  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<fulu.DataColumnSidecars> {
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<fulu.DataColumnSidecar[]> {
     if (!this.state.hasComputedAllData) {
       return withTimeout(() => this.computedDataPromise.promise, timeout, signal);
     }

package/src/chain/blocks/blockInput/types.ts

@@ -1,5 +1,5 @@
 import {ForkName} from "@lodestar/params";
-import {ColumnIndex, DataColumnSidecars, RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ColumnIndex, DataColumnSidecar, RootHex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
 import {VersionedHashes} from "../../../execution/index.js";
 
 export enum DAType {
@@ -9,13 +9,14 @@ export enum DAType {
   NoData = "no-data",
 }
 
-export type DAData = null | deneb.BlobSidecars | fulu.DataColumnSidecars;
+export type DAData = null | deneb.BlobSidecars | fulu.DataColumnSidecar[];
 
 /**
  * Represents were input originated. Blocks and Data can come from different
  * sources so each should be labelled individually.
  */
 export enum BlockInputSource {
+  network_processor = "network_processor",
   gossip = "gossip",
   api = "api",
   engine = "engine",
@@ -107,9 +108,9 @@ export type MissingColumnMeta = {
 export interface IDataColumnsInput {
   readonly slot: Slot;
   readonly blockRootHex: string;
-  getCustodyColumns(): DataColumnSidecars;
+  getCustodyColumns(): DataColumnSidecar[];
   hasComputedAllData(): boolean;
-  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<DataColumnSidecars>;
+  waitForComputedAllData(timeout: number, signal?: AbortSignal): Promise<DataColumnSidecar[]>;
 }
 
 /**

package/src/chain/blocks/importBlock.ts

@@ -3,6 +3,7 @@ import {routes} from "@lodestar/api";
 import {
   AncestorStatus,
   EpochDifference,
+  ExecutionStatus,
   ForkChoiceError,
   ForkChoiceErrorCode,
   NotReorgedReason,
@@ -18,15 +19,14 @@ import {
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
 import {
-  CachedBeaconStateAltair,
-  EpochCache,
+  IBeaconStateView,
   RootCache,
   computeEpochAtSlot,
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
-  isExecutionStateType,
   isStartSlotOfEpoch,
-  isStateValidatorsNodesPopulated,
+  isStatePostAltair,
+  isStatePostBellatrix,
 } from "@lodestar/state-transition";
 import {
   Attestation,
@@ -87,7 +87,7 @@ export async function importBlock(
   fullyVerifiedBlock: FullyVerifiedBlock,
   opts: ImportBlockOpts
 ): Promise<void> {
-  const {blockInput, postState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
+  const {blockInput, postBlockState, parentBlockSlot, executionStatus, dataAvailabilityStatus, indexedAttestations} =
     fullyVerifiedBlock;
   const block = blockInput.getBlock();
   const source = blockInput.getBlockSource();
@@ -99,7 +99,7 @@ export async function importBlock(
   const blockEpoch = computeEpochAtSlot(blockSlot);
   const prevFinalizedEpoch = this.forkChoice.getFinalizedCheckpoint().epoch;
   const blockDelaySec =
-    fullyVerifiedBlock.seenTimestampSec - computeTimeAtSlot(this.config, blockSlot, postState.genesisTime);
+    fullyVerifiedBlock.seenTimestampSec - computeTimeAtSlot(this.config, blockSlot, postBlockState.genesisTime);
   const recvToValLatency = Date.now() / 1000 - (opts.seenTimestampSec ?? Date.now() / 1000);
   const fork = this.config.getForkSeq(blockSlot);
 
@@ -122,13 +122,13 @@ export async function importBlock(
   // 2. Import block to fork choice
 
   // Should compute checkpoint balances before forkchoice.onBlock
-  this.checkpointBalancesCache.processState(blockRootHex, postState);
+  this.checkpointBalancesCache.processState(blockRootHex, postBlockState);
   const blockSummary = this.forkChoice.onBlock(
     block.message,
-    postState,
+    postBlockState,
     blockDelaySec,
     currentSlot,
-    executionStatus,
+    fork >= ForkSeq.gloas ? ExecutionStatus.PayloadSeparated : executionStatus,
     dataAvailabilityStatus
   );
 
@@ -138,13 +138,14 @@ export async function importBlock(
   // Post-Gloas: blockSummary.payloadStatus is always PENDING, so payloadPresent = false (block state only, no payload processing yet)
   const payloadPresent = !isGloasBlock(blockSummary);
   // processState manages both block state and payload state variants together for memory/disk management
-  this.regen.processBlockState(blockRootHex, postState);
+  this.regen.processBlockState(blockRootHex, postBlockState);
 
   // For Gloas blocks, create PayloadEnvelopeInput so it's available for later payload import
   if (fork >= ForkSeq.gloas) {
-    this.seenPayloadEnvelopeInputCache.add({
+    const payloadInput = this.seenPayloadEnvelopeInputCache.add({
       blockRootHex,
       block: block as SignedBeaconBlock<ForkPostGloas>,
+      forkName: blockInput.forkName,
       sampledColumns: this.custodyConfig.sampledColumns,
       custodyColumns: this.custodyConfig.custodyColumns,
       timeCreatedSec: fullyVerifiedBlock.seenTimestampSec,
@@ -155,6 +156,22 @@ export async function importBlock(
       source: source.source,
       ...(opts.seenTimestampSec !== undefined ? {recvToImport: Date.now() / 1000 - opts.seenTimestampSec} : {}),
     });
+
+    // Immediately attempt fetch of data columns from execution engine as the bid contains kzg commitments
+    // which is all the information we need so there is no reason to delay until execution payload arrives
+    // TODO GLOAS: If we want EL retries after this initial attempt, add an explicit retry policy here
+    // (for example later in the slot). Do not couple retries to incoming gossip columns.
+    this.getBlobsTracker.triggerGetBlobs(payloadInput, () => {
+      // TODO GLOAS: come up with a better mechanism to trigger processExecutionPayload after data becomes available,
+      // similar to how pre-gloas uses waitForBlockAndAllData with a cutoff timeout and incompleteBlockInput event
+      this.processExecutionPayload(payloadInput, {validSignature: true}).catch((e) => {
+        this.logger.debug(
+          "Error processing execution payload after getBlobs",
+          {slot: blockSlot, root: blockRootHex},
+          e as Error
+        );
+      });
+    });
   }
 
   this.metrics?.importBlock.bySource.inc({source: source.source});
@@ -174,7 +191,7 @@ export async function importBlock(
     (opts.importAttestations !== AttestationImportOpt.Skip && blockEpoch >= currentEpoch - FORK_CHOICE_ATT_EPOCH_LIMIT)
   ) {
     const attestations = block.message.body.attestations;
-    const rootCache = new RootCache(postState);
+    const rootCache = new RootCache(postBlockState);
     const invalidAttestationErrorsByCode = new Map<string, {error: Error; count: number}>();
 
     const addAttestation = fork >= ForkSeq.electra ? addAttestationPostElectra : addAttestationPreElectra;
@@ -188,7 +205,7 @@ export async function importBlock(
         const attDataRoot = toRootHex(ssz.phase0.AttestationData.hashTreeRoot(indexedAttestation.data));
         addAttestation.call(
           this,
-          postState.epochCtx,
+          postBlockState,
           target,
           attDataRoot,
           attestation as Attestation<ForkPostElectra>,
@@ -303,7 +320,7 @@ export async function importBlock(
 
   if (newHead.blockRoot !== oldHead.blockRoot) {
     // Set head state as strong reference
-    this.regen.updateHeadState(newHead, postState);
+    this.regen.updateHeadState(newHead, postBlockState);
 
     try {
       this.emitter.emit(routes.events.EventType.head, {
@@ -373,11 +390,13 @@ export async function importBlock(
       // we want to import block asap so do this in the next event loop
       callInNextEventLoop(() => {
         try {
-          this.lightClientServer?.onImportBlockHead(
-            block.message as BeaconBlock<ForkPostAltair>,
-            postState as CachedBeaconStateAltair,
-            parentBlockSlot
-          );
+          if (isStatePostAltair(postBlockState)) {
+            this.lightClientServer?.onImportBlockHead(
+              block.message as BeaconBlock<ForkPostAltair>,
+              postBlockState,
+              parentBlockSlot
+            );
+          }
         } catch (e) {
           this.logger.verbose("Error lightClientServer.onImportBlock", {slot: blockSlot}, e as Error);
         }
@@ -396,11 +415,11 @@ export async function importBlock(
   // and the block is weak and can potentially be reorged out.
   let shouldOverrideFcu = false;
 
-  if (blockSlot >= currentSlot && isExecutionStateType(postState)) {
+  if (blockSlot >= currentSlot && isStatePostBellatrix(postBlockState) && postBlockState.isExecutionStateType) {
     let notOverrideFcuReason = NotReorgedReason.Unknown;
     const proposalSlot = blockSlot + 1;
     try {
-      const proposerIndex = postState.epochCtx.getBeaconProposer(proposalSlot);
+      const proposerIndex = postBlockState.getBeaconProposer(proposalSlot);
       const feeRecipient = this.beaconProposerCache.get(proposerIndex);
 
       if (feeRecipient) {
@@ -480,20 +499,20 @@ export async function importBlock(
     }
   }
 
-  if (!isStateValidatorsNodesPopulated(postState)) {
-    this.logger.verbose("After importBlock caching postState without SSZ cache", {slot: postState.slot});
+  if (!postBlockState.isStateValidatorsNodesPopulated()) {
+    this.logger.verbose("After importBlock caching postState without SSZ cache", {slot: postBlockState.slot});
   }
 
   // Cache shufflings when crossing an epoch boundary
   const parentEpoch = computeEpochAtSlot(parentBlockSlot);
   if (parentEpoch < blockEpoch) {
-    this.shufflingCache.processState(postState);
+    this.shufflingCache.processState(postBlockState);
     this.logger.verbose("Processed shuffling for next epoch", {parentEpoch, blockEpoch, slot: blockSlot});
   }
 
   if (blockSlot % SLOTS_PER_EPOCH === 0) {
     // Cache state to preserve epoch transition work
-    const checkpointState = postState;
+    const checkpointState = postBlockState;
     const cp = getCheckpointFromState(checkpointState);
     this.regen.addCheckpointState(cp, checkpointState, payloadPresent);
     // consumers should not mutate state ever
@@ -502,7 +521,7 @@ export async function importBlock(
     // Note: in-lined code from previos handler of ChainEvent.checkpoint
     this.logger.verbose("Checkpoint processed", toCheckpointHexPayload(cp, payloadPresent));
 
-    const activeValidatorsCount = checkpointState.epochCtx.currentShuffling.activeIndices.length;
+    const activeValidatorsCount = checkpointState.activeValidatorCount;
     this.metrics?.currentActiveValidators.set(activeValidatorsCount);
     this.metrics?.currentValidators.set({status: "active"}, activeValidatorsCount);
 
@@ -583,11 +602,11 @@ export async function importBlock(
   this.metrics?.parentBlockDistance.observe(blockSlot - parentBlockSlot);
   this.metrics?.proposerBalanceDeltaAny.observe(fullyVerifiedBlock.proposerBalanceDelta);
   this.validatorMonitor?.registerImportedBlock(block.message, fullyVerifiedBlock);
-  if (this.config.getForkSeq(blockSlot) >= ForkSeq.altair) {
+  if (isStatePostAltair(fullyVerifiedBlock.postBlockState)) {
     this.validatorMonitor?.registerSyncAggregateInBlock(
       blockEpoch,
       (block as altair.SignedBeaconBlock).message.body.syncAggregate,
-      fullyVerifiedBlock.postState.epochCtx.currentSyncCommitteeIndexed.validatorIndices
+      fullyVerifiedBlock.postBlockState.currentSyncCommitteeIndexed.validatorIndices
     );
   }
 
@@ -629,7 +648,7 @@ export async function importBlock(
 export function addAttestationPreElectra(
   this: BeaconChain,
   // added to have the same signature as addAttestationPostElectra
-  _: EpochCache,
+  _: IBeaconStateView,
   target: phase0.Checkpoint,
   attDataRoot: string,
   attestation: Attestation,
@@ -646,7 +665,7 @@ export function addAttestationPreElectra(
 
 export function addAttestationPostElectra(
   this: BeaconChain,
-  epochCtx: EpochCache,
+  state: IBeaconStateView,
   target: phase0.Checkpoint,
   attDataRoot: string,
   attestation: Attestation<ForkPostElectra>,
@@ -664,7 +683,7 @@ export function addAttestationPostElectra(
   } else {
     const attSlot = attestation.data.slot;
     const attEpoch = computeEpochAtSlot(attSlot);
-    const decisionRoot = epochCtx.getShufflingDecisionRoot(attEpoch);
+    const decisionRoot = state.getShufflingDecisionRoot(attEpoch);
     const committees = this.shufflingCache.getBeaconCommittees(attEpoch, decisionRoot, attSlot, committeeIndices);
     const aggregationBools = attestation.aggregationBits.toBoolArray();
     let offset = 0;