@lodestar/state-transition 1.42.0-dev.5f2fffc2ce → 1.42.0-dev.687ecdc8cd

package/src/block/processExecutionPayloadEnvelope.ts

@@ -1,19 +1,18 @@
-import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {
-  BUILDER_INDEX_SELF_BUILD,
-  DOMAIN_BEACON_BUILDER,
-  SLOTS_PER_EPOCH,
-  SLOTS_PER_HISTORICAL_ROOT,
-} from "@lodestar/params";
+import {SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT} from "@lodestar/params";
 import {gloas, ssz} from "@lodestar/types";
 import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
+import {getExecutionPayloadEnvelopeSignatureSet} from "../signatureSets/executionPayloadEnvelope.js";
+import {BeaconStateView} from "../stateView/beaconStateView.js";
 import {CachedBeaconStateGloas} from "../types.js";
-import {computeSigningRoot, computeTimeAtSlot} from "../util/index.js";
+import {computeTimeAtSlot} from "../util/index.js";
+import {verifySignatureSet} from "../util/signatureSets.js";
 import {processConsolidationRequest} from "./processConsolidationRequest.js";
 import {processDepositRequest} from "./processDepositRequest.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
 
 export type ProcessExecutionPayloadEnvelopeOpts = {
+  verifySignature?: boolean;
+  verifyStateRoot?: boolean;
   dontTransferCache?: boolean;
 };
 
@@ -23,14 +22,14 @@ export type ProcessExecutionPayloadEnvelopeOpts = {
 export function processExecutionPayloadEnvelope(
   state: CachedBeaconStateGloas,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
-  verify: boolean,
   opts?: ProcessExecutionPayloadEnvelopeOpts
 ): CachedBeaconStateGloas {
+  const {verifySignature = true, verifyStateRoot = true} = opts ?? {};
   const envelope = signedEnvelope.message;
   const payload = envelope.payload;
   const fork = state.config.getForkSeq(envelope.slot);
 
-  if (verify && !verifyExecutionPayloadEnvelopeSignature(state, signedEnvelope)) {
+  if (verifySignature && !verifyExecutionPayloadEnvelopeSignature(state, signedEnvelope)) {
     throw Error(`Execution payload envelope has invalid signature builderIndex=${envelope.builderIndex}`);
   }
 
@@ -70,7 +69,7 @@ export function processExecutionPayloadEnvelope(
 
   postState.commit();
 
-  if (verify && !byteArrayEquals(envelope.stateRoot, postState.hashTreeRoot())) {
+  if (verifyStateRoot && !byteArrayEquals(envelope.stateRoot, postState.hashTreeRoot())) {
     throw new Error(
       `Envelope's state root does not match state envelope=${toRootHex(envelope.stateRoot)} state=${toRootHex(postState.hashTreeRoot())}`
     );
@@ -160,28 +159,12 @@ function verifyExecutionPayloadEnvelopeSignature(
   state: CachedBeaconStateGloas,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope
 ): boolean {
-  const builderIndex = signedEnvelope.message.builderIndex;
-
-  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
-  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, signedEnvelope.message, domain);
-
-  try {
-    let publicKey: PublicKey;
-
-    if (builderIndex === BUILDER_INDEX_SELF_BUILD) {
-      const validatorIndex = state.latestBlockHeader.proposerIndex;
-      const proposerPubkey = state.epochCtx.pubkeyCache.get(validatorIndex);
-      if (!proposerPubkey) {
-        return false;
-      }
-      publicKey = proposerPubkey;
-    } else {
-      publicKey = PublicKey.fromBytes(state.builders.getReadonly(builderIndex).pubkey);
-    }
-    const signature = Signature.fromBytes(signedEnvelope.signature, true);
-
-    return verify(signingRoot, publicKey, signature);
-  } catch (_e) {
-    return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
-  }
+  const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
+    state.config,
+    state.epochCtx.pubkeyCache,
+    new BeaconStateView(state),
+    signedEnvelope,
+    state.latestBlockHeader.proposerIndex
+  );
+  return verifySignatureSet(signatureSet);
 }

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -1,7 +1,11 @@
+import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
-import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
-import {gloas, ssz} from "@lodestar/types";
+import {BUILDER_INDEX_SELF_BUILD, DOMAIN_BEACON_BUILDER} from "@lodestar/params";
+import {ValidatorIndex, gloas, ssz} from "@lodestar/types";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {computeSigningRoot} from "../util/index.js";
+import {type SingleSignatureSet, createSingleSignatureSetFromComponents} from "../util/signatureSets.js";
 
 export function getExecutionPayloadEnvelopeSigningRoot(
   config: BeaconConfig,
@@ -11,3 +15,23 @@ export function getExecutionPayloadEnvelopeSigningRoot(
 
   return computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
 }
+
+export function getExecutionPayloadEnvelopeSignatureSet(
+  config: BeaconConfig,
+  pubkeyCache: PubkeyCache,
+  state: IBeaconStateView,
+  signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+  proposerIndex: ValidatorIndex
+): SingleSignatureSet {
+  const envelope = signedEnvelope.message;
+  const pubkey =
+    envelope.builderIndex === BUILDER_INDEX_SELF_BUILD
+      ? pubkeyCache.getOrThrow(proposerIndex)
+      : PublicKey.fromBytes(state.getBuilder(envelope.builderIndex).pubkey);
+
+  return createSingleSignatureSetFromComponents(
+    pubkey,
+    getExecutionPayloadEnvelopeSigningRoot(config, envelope),
+    signedEnvelope.signature
+  );
+}

package/src/signatureSets/index.ts

@@ -3,8 +3,7 @@ import {ForkSeq} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
-import {BeaconStateView} from "../stateView/beaconStateView.js";
-import {CachedBeaconStateAllForks} from "../types.js";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
 import {getBlsToExecutionChangeSignatureSets} from "./blsToExecutionChange.js";
@@ -32,7 +31,7 @@ export * from "./voluntaryExits.js";
 export function getBlockSignatureSets(
   config: BeaconConfig,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
   opts?: {
@@ -48,7 +47,7 @@ export function getBlockSignatureSets(
     ...getProposerSlashingsSignatureSets(config, signedBlock),
     ...getAttesterSlashingsSignatureSets(config, signedBlock),
     ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, new BeaconStateView(state), signedBlock),
+    ...getVoluntaryExitsSignatureSets(config, state, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {

package/src/slot/upgradeStateToAltair.ts

@@ -3,6 +3,7 @@ import {ForkSeq} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {getAttestationParticipationStatus} from "../block/processAttestationsAltair.js";
 import {getCachedBeaconState} from "../cache/stateCache.js";
+import {BeaconStateView} from "../stateView/beaconStateView.js";
 import {CachedBeaconStateAltair, CachedBeaconStatePhase0} from "../types.js";
 import {RootCache, newZeroedArray} from "../util/index.js";
 import {getNextSyncCommittee} from "../util/syncCommittee.js";
@@ -125,7 +126,7 @@ function translateParticipation(
   pendingAttesations: CompositeViewDU<typeof ssz.phase0.EpochAttestations>
 ): void {
   const {epochCtx} = state;
-  const rootCache = new RootCache(state);
+  const rootCache = new RootCache(new BeaconStateView(state));
   const epochParticipation = state.previousEpochParticipation;
 
   for (const attestation of pendingAttesations.getAllReadonly()) {

package/src/stateView/beaconStateView.ts

@@ -1,9 +1,10 @@
 import {CompactMultiProof, ProofType, Tree, createProof} from "@chainsafe/persistent-merkle-tree";
-import {ByteViews} from "@chainsafe/ssz";
+import {BitArray, ByteViews} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_HISTORICAL_ROOT, isForkPostGloas} from "@lodestar/params";
 import {
   BeaconBlock,
+  BeaconState,
   BlindedBeaconBlock,
   BuilderIndex,
   Bytes32,
@@ -28,11 +29,11 @@ import {
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
 import {processExecutionPayloadEnvelope} from "../block/index.js";
+import {ProcessExecutionPayloadEnvelopeOpts} from "../block/processExecutionPayloadEnvelope.js";
 import {VoluntaryExitValidity, getVoluntaryExitValidity} from "../block/processVoluntaryExit.js";
 import {getExpectedWithdrawals} from "../block/processWithdrawals.js";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
 import {EpochTransitionCacheOpts} from "../cache/epochTransitionCache.js";
-import {PubkeyCache, createPubkeyCache} from "../cache/pubkeyCache.js";
 import {RewardCache} from "../cache/rewardCache.js";
 import {
   CachedBeaconStateAllForks,
@@ -46,7 +47,6 @@ import {
   isStateValidatorsNodesPopulated,
 } from "../cache/stateCache.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
-import {BeaconStateAllForks} from "../cache/types.js";
 import {computeUnrealizedCheckpoints} from "../epoch/computeUnrealizedCheckpoints.js";
 import {getFinalizedRootProof, getSyncCommitteesWitness} from "../lightClient/proofs.js";
 import {SyncCommitteeWitness} from "../lightClient/types.js";
@@ -63,7 +63,6 @@ import {isExecutionEnabled, isExecutionStateType, isMergeTransitionComplete} fro
 import {canBuilderCoverBid} from "../util/gloas.js";
 import {loadState} from "../util/loadState/loadState.js";
 import {getRandaoMix} from "../util/seed.js";
-import {getStateTypeFromBytes} from "../util/sszBytes.js";
 import {getLatestWeakSubjectivityCheckpointEpoch} from "../util/weakSubjectivity.js";
 import {IBeaconStateView} from "./interface.js";
 
@@ -91,7 +90,7 @@ export class BeaconStateView implements IBeaconStateView {
   // fulu
   private _proposerLookahead: fulu.ProposerLookahead | null = null;
   // gloas
-  private _executionPayloadAvailability: boolean[] | null = null;
+  private _executionPayloadAvailability: BitArray | null = null;
   private _latestExecutionPayloadBid: ExecutionPayloadBid | null = null;
 
   constructor(readonly cachedState: CachedBeaconStateAllForks) {
@@ -356,15 +355,15 @@ export class BeaconStateView implements IBeaconStateView {
 
   // gloas
 
-  get executionPayloadAvailability(): boolean[] {
+  get executionPayloadAvailability(): BitArray {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
       throw new Error("executionPayloadAvailability is not available before GLOAS");
     }
 
     if (this._executionPayloadAvailability === null) {
-      this._executionPayloadAvailability = (this.cachedState as CachedBeaconStateGloas).executionPayloadAvailability
-        .toValue()
-        .toBoolArray();
+      this._executionPayloadAvailability = (
+        this.cachedState as CachedBeaconStateGloas
+      ).executionPayloadAvailability.toValue();
     }
 
     return this._executionPayloadAvailability;
@@ -403,7 +402,7 @@ export class BeaconStateView implements IBeaconStateView {
    * Return the index of the validator in the PTC committee for the given slot.
    * return -1 if validator is not in the PTC committee for the given slot.
    */
-  validatorPTCCommitteeIndex(validatorIndex: ValidatorIndex, slot: Slot): number {
+  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number {
     if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
       throw new Error("PTC committees are not supported before GLOAS");
     }
@@ -502,6 +501,10 @@ export class BeaconStateView implements IBeaconStateView {
     return this.cachedState.epochCtx.syncProposerReward;
   }
 
+  getIndexedSyncCommittee(slot: Slot): SyncCommitteeCache {
+    return this.cachedState.epochCtx.getIndexedSyncCommittee(slot);
+  }
+
   getIndexedSyncCommitteeAtEpoch(epoch: Epoch): SyncCommitteeCache {
     return this.cachedState.epochCtx.getIndexedSyncCommitteeAtEpoch(epoch);
   }
@@ -712,6 +715,10 @@ export class BeaconStateView implements IBeaconStateView {
     return new BeaconStateView(cachedState);
   }
 
+  toValue(): BeaconState {
+    return this.cachedState.toValue();
+  }
+
   serialize(): Uint8Array {
     return this.cachedState.serialize();
   }
@@ -761,49 +768,19 @@ export class BeaconStateView implements IBeaconStateView {
     return new BeaconStateView(newState);
   }
 
-  processExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope, verify: boolean): void {
+  processExecutionPayloadEnvelope(
+    signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+    opts?: ProcessExecutionPayloadEnvelopeOpts
+  ): BeaconStateView {
     const fork = this.config.getForkName(this.cachedState.slot);
     if (!isForkPostGloas(fork)) {
       throw Error(`processExecutionPayloadEnvelope is only available for gloas+ forks, got fork=${fork}`);
     }
-    processExecutionPayloadEnvelope(this.cachedState as CachedBeaconStateGloas, signedEnvelope, verify);
-  }
-}
-
-/**
- * Create BeaconStateView for historical state regen, no need to sync pubkey cache there.
- */
-export function createBeaconStateViewForHistoricalRegen(
-  config: BeaconConfig,
-  stateBytes: Uint8Array
-): IBeaconStateView {
-  const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
-
-  const pubkeyCache = createPubkeyCache();
-  syncPubkeyCache(state, pubkeyCache);
-  const cachedState = createCachedBeaconState(
-    state,
-    {
-      config,
-      pubkeyCache,
-    },
-    {
-      skipSyncPubkeys: true,
-    }
-  );
-
-  return new BeaconStateView(cachedState);
-}
-
-/**
- * Populate a PubkeyIndexMap with any new entries based on a BeaconState
- */
-function syncPubkeyCache(state: BeaconStateAllForks, pubkeyCache: PubkeyCache): void {
-  // Get the validators sub tree once for all the loop
-
-  const newCount = state.validators.length;
-  for (let i = pubkeyCache.size; i < newCount; i++) {
-    const pubkey = state.validators.getReadonly(i).pubkey;
-    pubkeyCache.set(i, pubkey);
+    const postPayloadState = processExecutionPayloadEnvelope(
+      this.cachedState as CachedBeaconStateGloas,
+      signedEnvelope,
+      opts
+    );
+    return new BeaconStateView(postPayloadState);
   }
 }

package/src/stateView/index.ts

@@ -1,2 +1,3 @@
 export * from "./beaconStateView.js";
 export * from "./interface.js";
+export * from "./stateViewFactory.js";

package/src/stateView/interface.ts

@@ -1,7 +1,8 @@
 import {CompactMultiProof} from "@chainsafe/persistent-merkle-tree";
-import {ByteViews} from "@chainsafe/ssz";
+import {BitArray, ByteViews} from "@chainsafe/ssz";
 import {
   BeaconBlock,
+  BeaconState,
   BlindedBeaconBlock,
   BuilderIndex,
   Bytes32,
@@ -23,6 +24,7 @@ import {
   rewards,
 } from "@lodestar/types";
 import {Checkpoint, Fork} from "@lodestar/types/phase0";
+import {ProcessExecutionPayloadEnvelopeOpts} from "../block/processExecutionPayloadEnvelope.js";
 import {VoluntaryExitValidity} from "../block/processVoluntaryExit.js";
 import {EffectiveBalanceIncrements} from "../cache/effectiveBalanceIncrements.js";
 import {EpochTransitionCacheOpts} from "../cache/epochTransitionCache.js";
@@ -92,11 +94,11 @@ export interface IBeaconStateView {
   proposerLookahead: fulu.ProposerLookahead;
 
   // gloas
-  executionPayloadAvailability: boolean[];
+  executionPayloadAvailability: BitArray;
   latestExecutionPayloadBid: ExecutionPayloadBid;
   getBuilder(index: BuilderIndex): gloas.Builder;
   canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean;
-  validatorPTCCommitteeIndex(validatorIndex: ValidatorIndex, slot: Slot): number;
+  getIndexInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number;
 
   // Shuffling and committees
   getShufflingAtEpoch(epoch: Epoch): EpochShuffling;
@@ -109,12 +111,11 @@ export interface IBeaconStateView {
   getCurrentShuffling(): EpochShuffling;
   getNextShuffling(): EpochShuffling;
 
-  // utils: proposers, anchor checkpoint
+  // Proposer shuffling
   previousProposers: ValidatorIndex[] | null;
   currentProposers: ValidatorIndex[];
   nextProposers: ValidatorIndex[];
   getBeaconProposer(slot: Slot): ValidatorIndex;
-  computeAnchorCheckpoint(): {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader};
 
   // Sync committees
   currentSyncCommittee: altair.SyncCommittee;
@@ -122,6 +123,8 @@ export interface IBeaconStateView {
   currentSyncCommitteeIndexed: SyncCommitteeCache;
   syncProposerReward: number;
   getIndexedSyncCommitteeAtEpoch(epoch: Epoch): SyncCommitteeCache;
+  /** Get indexed sync committee with slot+1 offset for duty lookups */
+  getIndexedSyncCommittee(slot: Slot): SyncCommitteeCache;
 
   // Validators and balances
   effectiveBalanceIncrements: EffectiveBalanceIncrements;
@@ -148,6 +151,7 @@ export interface IBeaconStateView {
     expectedWithdrawals: capella.Withdrawal[];
     processedBuilderWithdrawalsCount: number;
     processedPartialWithdrawalsCount: number;
+    processedBuildersSweepCount: number;
     processedValidatorSweepCount: number;
   };
 
@@ -179,6 +183,7 @@ export interface IBeaconStateView {
     justifiedCheckpoint: phase0.Checkpoint;
     finalizedCheckpoint: phase0.Checkpoint;
   };
+  computeAnchorCheckpoint(): {checkpoint: phase0.Checkpoint; blockHeader: phase0.BeaconBlockHeader};
 
   // this is for backward compatible
   clonedCount: number;
@@ -189,6 +194,7 @@ export interface IBeaconStateView {
 
   // Serialization
   loadOtherState(stateBytes: Uint8Array, seedValidatorsBytes?: Uint8Array): IBeaconStateView;
+  toValue(): BeaconState;
   serialize(): Uint8Array;
   serializedSize(): number;
   serializeToBytes(output: ByteViews, offset: number): number;
@@ -209,5 +215,8 @@ export interface IBeaconStateView {
     epochTransitionCacheOpts?: EpochTransitionCacheOpts & {dontTransferCache?: boolean},
     modules?: StateTransitionModules
   ): IBeaconStateView;
-  processExecutionPayloadEnvelope(signedEnvelope: gloas.SignedExecutionPayloadEnvelope, verify: boolean): void;
+  processExecutionPayloadEnvelope(
+    signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
+    opts?: ProcessExecutionPayloadEnvelopeOpts
+  ): IBeaconStateView;
 }

package/src/stateView/stateViewFactory.ts

@@ -0,0 +1,78 @@
+import {BeaconConfig} from "@lodestar/config";
+import {PubkeyCache, createPubkeyCache} from "../cache/pubkeyCache.js";
+import {createCachedBeaconState} from "../cache/stateCache.js";
+import {BeaconStateAllForks} from "../cache/types.js";
+import {getStateTypeFromBytes} from "../util/sszBytes.js";
+import {BeaconStateView} from "./beaconStateView.js";
+import {IBeaconStateView} from "./interface.js";
+
+// ---- createBeaconStateView (startup path) ----
+
+type NodeJSOpts = {
+  useNative: false;
+  anchorState: BeaconStateAllForks;
+  config: BeaconConfig;
+  pubkeyCache: PubkeyCache;
+};
+
+type NativeOpts = {
+  useNative: true;
+  stateBytes: Uint8Array;
+};
+
+/**
+ * Create a BeaconStateView from a pre-deserialized state. Used at node startup.
+ *
+ * The caller is responsible for creating and populating `pubkeyCache` (it is also
+ * passed separately to BeaconNode.init, so it must live outside this factory).
+ *
+ * Set `useNative: true` to use the native (Zig) implementation once available.
+ */
+export function createBeaconStateView(opts: NodeJSOpts | NativeOpts): IBeaconStateView {
+  if (opts.useNative) {
+    throw new Error("Native (Zig) BeaconStateView not yet implemented");
+  }
+  const {anchorState, config, pubkeyCache} = opts;
+  const cachedState = createCachedBeaconState(anchorState, {config, pubkeyCache}, {skipSyncPubkeys: true});
+  return new BeaconStateView(cachedState);
+}
+
+// ---- createBeaconStateViewForHistoricalRegen (regen path) ----
+
+// Reused across all historical state regen calls in the worker thread
+const pubkeyCacheRegen = createPubkeyCache();
+
+function syncPubkeyCache(state: BeaconStateAllForks, pubkeyCache: PubkeyCache): void {
+  const newCount = state.validators.length;
+  for (let i = pubkeyCache.size; i < newCount; i++) {
+    const pubkey = state.validators.getReadonly(i).pubkey;
+    pubkeyCache.set(i, pubkey);
+  }
+}
+
+type RegenNodeJSOpts = {
+  useNative: false;
+  config: BeaconConfig;
+  stateBytes: Uint8Array;
+};
+
+type RegenNativeOpts = {
+  useNative: true;
+  stateBytes: Uint8Array;
+};
+
+/**
+ * Create a BeaconStateView from raw SSZ bytes. Used in the historical state regen worker thread.
+ *
+ * Set `useNative: true` to use the native (Zig) implementation once available.
+ */
+export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts | RegenNativeOpts): IBeaconStateView {
+  if (opts.useNative) {
+    throw new Error("Native (Zig) BeaconStateView not yet implemented");
+  }
+  const {config, stateBytes} = opts;
+  const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
+  syncPubkeyCache(state, pubkeyCacheRegen);
+  const cachedState = createCachedBeaconState(state, {config, pubkeyCache: pubkeyCacheRegen}, {skipSyncPubkeys: true});
+  return new BeaconStateView(cachedState);
+}

package/src/util/execution.ts

@@ -143,7 +143,7 @@ export function executionPayloadToPayloadHeader(fork: ForkSeq, payload: Executio
   }
 
   if (fork >= ForkSeq.deneb) {
-    // https://github.com/ethereum/consensus-specs/blob/dev/specs/eip4844/beacon-chain.md#process_execution_payload
+    // https://github.com/ethereum/consensus-specs/blob/v1.3.0-rc.2/specs/eip4844/beacon-chain.md#process_execution_payload
     (bellatrixPayloadFields as deneb.ExecutionPayloadHeader).blobGasUsed = (
       payload as deneb.ExecutionPayloadHeader | deneb.ExecutionPayload
     ).blobGasUsed;

package/src/util/rootCache.ts

@@ -1,6 +1,5 @@
 import {Epoch, Root, Slot, phase0} from "@lodestar/types";
-import {CachedBeaconStateAllForks} from "../types.js";
-import {getBlockRoot, getBlockRootAtSlot} from "./blockRoot.js";
+import {IBeaconStateView} from "../stateView/interface.js";
 
 /**
  * Cache to prevent accessing the state tree to fetch block roots repeteadly.
@@ -12,7 +11,7 @@ export class RootCache {
   private readonly blockRootEpochCache = new Map<Epoch, Root>();
   private readonly blockRootSlotCache = new Map<Slot, Root>();
 
-  constructor(private readonly state: CachedBeaconStateAllForks) {
+  constructor(private readonly state: IBeaconStateView) {
     this.currentJustifiedCheckpoint = state.currentJustifiedCheckpoint;
     this.previousJustifiedCheckpoint = state.previousJustifiedCheckpoint;
   }
@@ -20,7 +19,7 @@ export class RootCache {
   getBlockRoot(epoch: Epoch): Root {
     let root = this.blockRootEpochCache.get(epoch);
     if (!root) {
-      root = getBlockRoot(this.state, epoch);
+      root = this.state.getBlockRootAtEpoch(epoch);
       this.blockRootEpochCache.set(epoch, root);
     }
     return root;
@@ -29,7 +28,7 @@ export class RootCache {
   getBlockRootAtSlot(slot: Slot): Root {
     let root = this.blockRootSlotCache.get(slot);
     if (!root) {
-      root = getBlockRootAtSlot(this.state, slot);
+      root = this.state.getBlockRootAtSlot(slot);
       this.blockRootSlotCache.set(slot, root);
     }
     return root;

package/src/util/shuffling.ts

@@ -11,6 +11,7 @@ import {
 } from "@lodestar/types";
 import {LodestarError} from "@lodestar/utils";
 import {CachedBeaconStateAllForks} from "../cache/stateCache.js";
+import {IBeaconStateView} from "../stateView/interface.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
 import {computeStartSlotAtEpoch} from "./epoch.js";
 import {EpochShuffling} from "./epochShuffling.js";
@@ -22,21 +23,21 @@ import {EpochShuffling} from "./epochShuffling.js";
  * Returns `null` on the one-off scenario where the genesis block decides its own shuffling.
  * It should be set to the latest block applied to this `state` or the genesis block root.
  */
-export function proposerShufflingDecisionRoot(fork: ForkName, state: CachedBeaconStateAllForks): Root | null {
+export function proposerShufflingDecisionRoot(fork: ForkName, state: IBeaconStateView): Root | null {
   const decisionSlot = proposerShufflingDecisionSlot(fork, state);
   if (state.slot === decisionSlot) {
     return null;
   }
-  return getBlockRootAtSlot(state, decisionSlot);
+  return state.getBlockRootAtSlot(decisionSlot);
 }
 
 /**
  * Returns the slot at which the proposer shuffling was decided. The block root at this slot
  * can be used to key the proposer shuffling for the current epoch.
  */
-function proposerShufflingDecisionSlot(fork: ForkName, state: CachedBeaconStateAllForks): Slot {
+function proposerShufflingDecisionSlot(fork: ForkName, state: IBeaconStateView): Slot {
   // After fulu, the decision slot is in previous epoch due to deterministic proposer lookahead
-  const epoch = isForkPostFulu(fork) ? state.epochCtx.epoch - 1 : state.epochCtx.epoch;
+  const epoch = isForkPostFulu(fork) ? state.epoch - 1 : state.epoch;
   const startSlot = computeStartSlotAtEpoch(epoch);
   return Math.max(startSlot - 1, 0);
 }