@lodestar/beacon-node 1.42.0-dev.d73eccfa56 → 1.42.0-dev.eec18d0609

package/src/chain/stateCache/persistentCheckpointsCache.ts

@@ -1,12 +1,7 @@
 import {routes} from "@lodestar/api";
 import {BeaconConfig} from "@lodestar/config";
 import {CheckpointWithPayloadStatus} from "@lodestar/fork-choice";
-import {
-  CachedBeaconStateAllForks,
-  computeStartSlotAtEpoch,
-  getBlockRootAtSlot,
-  loadCachedBeaconState,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, computeStartSlotAtEpoch} from "@lodestar/state-transition";
 import {Epoch, RootHex, phase0} from "@lodestar/types";
 import {Logger, MapDef, fromHex, sleep, toHex, toRootHex} from "@lodestar/utils";
 import {Metrics} from "../../metrics/index.js";
@@ -40,7 +35,7 @@ type CacheKey = string;
 
 type InMemoryCacheItem = {
   type: CacheItemType.inMemory;
-  state: CachedBeaconStateAllForks;
+  state: IBeaconStateView;
   // if a cp state is reloaded from disk, it'll keep track of persistedKey to allow us to remove it from disk later
   // it also helps not to persist it again
   persistedKey?: DatastoreKey;
@@ -220,9 +215,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * - Get block for processing
    * - Regen head state
    */
-  async getOrReload(cp: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | null> {
+  async getOrReload(cp: CheckpointHexPayload): Promise<IBeaconStateView | null> {
     const stateOrStateBytesData = await this.getStateOrLoadDb(cp);
-    if (stateOrStateBytesData === null || isCachedBeaconState(stateOrStateBytesData)) {
+    if (stateOrStateBytesData === null || isBeaconStateView(stateOrStateBytesData)) {
       return stateOrStateBytesData ?? null;
     }
     const {persistedKey, stateBytes} = stateOrStateBytesData;
@@ -237,7 +232,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       this.clock?.secFromSlot(this.clock?.currentSlot ?? 0) ?? 0
     );
     const seedState = this.findSeedStateToReload(cp);
-    this.metrics?.cpStateCache.stateReloadEpochDiff.observe(Math.abs(seedState.epochCtx.epoch - cp.epoch));
+    this.metrics?.cpStateCache.stateReloadEpochDiff.observe(Math.abs(seedState.epoch - cp.epoch));
     this.logger.debug("Reload: found seed state", {...logMeta, seedSlot: seedState.slot});
 
     try {
@@ -249,19 +244,16 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
       if (validatorsBytes == null) {
         // fallback logic in case we can't use the buffer pool
         this.metrics?.cpStateCache.stateReloadValidatorsSerializeAllocCount.inc();
-        validatorsBytes = seedState.validators.serialize();
+        validatorsBytes = seedState.serializeValidators();
       }
       sszTimer?.();
       const timer = this.metrics?.cpStateCache.stateReloadDuration.startTimer();
-      const newCachedState = loadCachedBeaconState(seedState, stateBytes, {}, validatorsBytes);
+      const newCachedState = seedState.loadOtherState(stateBytes, validatorsBytes);
       // hashTreeRoot() calls the commit() inside
       // there is no modification inside the state, it's just that we want to compute and cache all roots
       const stateRoot = toRootHex(newCachedState.hashTreeRoot());
       timer?.();
 
-      // load all cache in order for consumers (usually regen.getState()) to process blocks faster
-      newCachedState.validators.getAllReadonlyValues();
-      newCachedState.balances.getAll();
       this.logger.debug("Reload: cached state load successful", {
         ...logMeta,
         stateSlot: newCachedState.slot,
@@ -284,9 +276,9 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Return either state or state bytes loaded from db.
    */
-  async getStateOrBytes(cp: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | Uint8Array | null> {
+  async getStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null> {
     const stateOrLoadedState = await this.getStateOrLoadDb(cp);
-    if (stateOrLoadedState === null || isCachedBeaconState(stateOrLoadedState)) {
+    if (stateOrLoadedState === null || isBeaconStateView(stateOrLoadedState)) {
       return stateOrLoadedState;
     }
     return stateOrLoadedState.stateBytes;
@@ -295,7 +287,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Return either state or state bytes with persisted key loaded from db.
    */
-  async getStateOrLoadDb(cp: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | LoadedStateBytesData | null> {
+  async getStateOrLoadDb(cp: CheckpointHexPayload): Promise<IBeaconStateView | LoadedStateBytesData | null> {
     const cpKey = toCacheKey(cp);
     const inMemoryState = this.get(cpKey);
     if (inMemoryState) {
@@ -326,7 +318,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Similar to get() api without reloading from disk
    */
-  get(cpOrKey: CheckpointHexPayload | CacheKey): CachedBeaconStateAllForks | null {
+  get(cpOrKey: CheckpointHexPayload | CacheKey): IBeaconStateView | null {
     this.metrics?.cpStateCache.lookups.inc();
     const cpKey = typeof cpOrKey === "string" ? cpOrKey : toCacheKey(cpOrKey);
     const cacheItem = this.cache.get(cpKey);
@@ -355,7 +347,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * @param payloadPresent - For Gloas: true if this is payload state, false if block state.
    *                         Always true for pre-Gloas.
    */
-  add(cp: phase0.Checkpoint, state: CachedBeaconStateAllForks, payloadPresent: boolean): void {
+  add(cp: phase0.Checkpoint, state: IBeaconStateView, payloadPresent: boolean): void {
     const cpHex = toCheckpointHexPayload(cp, payloadPresent);
     const key = toCacheKey(cpHex);
     const cacheItem = this.cache.get(key);
@@ -385,7 +377,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
   /**
    * Searches in-memory state for the latest cached state with a `root` without reload, starting with `epoch` and descending
    */
-  getLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): CachedBeaconStateAllForks | null {
+  getLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): IBeaconStateView | null {
     // sort epochs in descending order, only consider epochs lte `epoch`
     const epochs = Array.from(this.epochIndex.keys())
       .sort((a, b) => b - a)
@@ -412,7 +404,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     rootHex: RootHex,
     maxEpoch: Epoch,
     payloadPresent: boolean
-  ): Promise<CachedBeaconStateAllForks | null> {
+  ): Promise<IBeaconStateView | null> {
     // sort epochs in descending order, only consider epochs lte `epoch`
     const epochs = Array.from(this.epochIndex.keys())
       .sort((a, b) => b - a)
@@ -518,7 +510,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    * For Gloas: Processes both block state and payload state variants together. The decision of which roots to persist/prune
    * is based on root canonicality (from state's view), not payload presence. Both variants are managed as a unit.
    */
-  async processState(blockRootHex: RootHex, state: CachedBeaconStateAllForks): Promise<number> {
+  async processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number> {
     let persistCount = 0;
     // it's important to sort the epochs in ascending order, in case of big reorg we always want to keep the most recent checkpoint states
     const sortedEpochs = Array.from(this.epochIndex.keys()).sort((a, b) => a - b);
@@ -587,10 +579,10 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    *
    * Use seed state from the block cache if cannot find any seed states within this cache.
    */
-  findSeedStateToReload(reloadedCp: CheckpointHexPayload): CachedBeaconStateAllForks {
+  findSeedStateToReload(reloadedCp: CheckpointHexPayload): IBeaconStateView {
     const maxEpoch = Math.max(...Array.from(this.epochIndex.keys()));
     const reloadedCpSlot = computeStartSlotAtEpoch(reloadedCp.epoch);
-    let firstState: CachedBeaconStateAllForks | null = null;
+    let firstState: IBeaconStateView | null = null;
     const logCtx = {reloadedCpEpoch: reloadedCp.epoch, reloadedCpRoot: reloadedCp.rootHex};
 
     // no need to check epochs before `maxEpoch - this.maxEpochsInMemory + 1` before they are all persisted
@@ -620,7 +612,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
               // amongst states of the same epoch, choose the one with the same view of reloadedCp
               if (
                 reloadedCpSlot < state.slot &&
-                toRootHex(getBlockRootAtSlot(state, reloadedCpSlot)) === reloadedCp.rootHex
+                toRootHex(state.getBlockRootAtSlot(reloadedCpSlot)) === reloadedCp.rootHex
               ) {
                 this.logger.verbose("Reload: use checkpoint state as seed state", {...cpLog, ...logCtx});
                 return state;
@@ -685,7 +677,7 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
     });
   }
 
-  getStates(): IterableIterator<CachedBeaconStateAllForks> {
+  getStates(): IterableIterator<IBeaconStateView> {
     const items = Array.from(this.cache.values())
       .filter(isInMemoryCacheItem)
       .map((item) => item.state);
@@ -735,17 +727,13 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    *   - In normal condition, we persist 1 checkpoint state per epoch.
    *   - In reorged condition, we may persist multiple (most likely 2) checkpoint states per epoch.
    */
-  private async processPastEpoch(
-    blockRootHex: RootHex,
-    state: CachedBeaconStateAllForks,
-    epoch: Epoch
-  ): Promise<number> {
+  private async processPastEpoch(blockRootHex: RootHex, state: IBeaconStateView, epoch: Epoch): Promise<number> {
     let persistCount = 0;
     const epochBoundarySlot = computeStartSlotAtEpoch(epoch);
     const epochBoundaryRoot =
-      epochBoundarySlot === state.slot ? fromHex(blockRootHex) : getBlockRootAtSlot(state, epochBoundarySlot);
+      epochBoundarySlot === state.slot ? fromHex(blockRootHex) : state.getBlockRootAtSlot(epochBoundarySlot);
     const epochBoundaryHex = toRootHex(epochBoundaryRoot);
-    const prevEpochRoot = toRootHex(getBlockRootAtSlot(state, epochBoundarySlot - 1));
+    const prevEpochRoot = toRootHex(state.getBlockRootAtSlot(epochBoundarySlot - 1));
 
     // for each epoch, usually there are 2 rootHexes respective to the 2 checkpoint states: Previous Root Checkpoint State and Current Root Checkpoint State
     const cpRootHexMap = this.epochIndex.get(epoch) ?? new Map<RootHex, number>();
@@ -912,15 +900,14 @@ export class PersistentCheckpointStateCache implements CheckpointStateCache {
    *   - Also `serializeState.test.ts` perf test shows a lot of differences allocating validators bytes once vs every time,
    * This is 2x - 3x faster than allocating memory every time.
    */
-  private serializeStateValidators(state: CachedBeaconStateAllForks): BufferWithKey | null {
-    const type = state.type.fields.validators;
-    const size = type.tree_serializedSize(state.validators.node);
+  private serializeStateValidators(state: IBeaconStateView): BufferWithKey | null {
+    const size = state.serializedValidatorsSize();
     if (this.bufferPool) {
       const bufferWithKey = this.bufferPool.alloc(size, AllocSource.PERSISTENT_CHECKPOINTS_CACHE_VALIDATORS);
       if (bufferWithKey) {
         const validatorsBytes = bufferWithKey.buffer;
         const dataView = new DataView(validatorsBytes.buffer, validatorsBytes.byteOffset, validatorsBytes.byteLength);
-        state.validators.serializeToBytes({uint8Array: validatorsBytes, dataView}, 0);
+        state.serializeValidatorsToBytes({uint8Array: validatorsBytes, dataView}, 0);
         return bufferWithKey;
       }
     }
@@ -983,10 +970,8 @@ function fromCacheKey(key: CacheKey): CheckpointHexPayload {
   };
 }
 
-function isCachedBeaconState(
-  stateOrBytes: CachedBeaconStateAllForks | LoadedStateBytesData
-): stateOrBytes is CachedBeaconStateAllForks {
-  return (stateOrBytes as CachedBeaconStateAllForks).slot !== undefined;
+function isBeaconStateView(stateOrBytes: IBeaconStateView | LoadedStateBytesData): stateOrBytes is IBeaconStateView {
+  return (stateOrBytes as IBeaconStateView).slot !== undefined;
 }
 
 function isInMemoryCacheItem(cacheItem: CacheItem): cacheItem is InMemoryCacheItem {

package/src/chain/stateCache/types.ts

@@ -1,5 +1,5 @@
 import {routes} from "@lodestar/api";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {IBeaconStateView} from "@lodestar/state-transition";
 import {Epoch, RootHex, phase0} from "@lodestar/types";
 
 /**
@@ -24,13 +24,13 @@ export type CheckpointHexPayload = {epoch: Epoch; rootHex: RootHex; payloadPrese
  * The cache key is state root
  */
 export interface BlockStateCache {
-  get(rootHex: RootHex): CachedBeaconStateAllForks | null;
-  add(item: CachedBeaconStateAllForks): void;
-  setHeadState(item: CachedBeaconStateAllForks | null): void;
+  get(rootHex: RootHex): IBeaconStateView | null;
+  add(item: IBeaconStateView): void;
+  setHeadState(item: IBeaconStateView | null): void;
   /**
    * Get a seed state for state reload.
    */
-  getSeedState(): CachedBeaconStateAllForks;
+  getSeedState(): IBeaconStateView;
   clear(): void;
   size: number;
   prune(headStateRootHex: RootHex): void;
@@ -39,7 +39,7 @@ export interface BlockStateCache {
   upgradeToGloas(): void;
   dumpSummary(): routes.lodestar.StateCacheItem[];
   /** Expose beacon states stored in cache. Use with caution */
-  getStates(): IterableIterator<CachedBeaconStateAllForks>;
+  getStates(): IterableIterator<IBeaconStateView>;
 }
 
 /**
@@ -65,24 +65,20 @@ export interface BlockStateCache {
  */
 export interface CheckpointStateCache {
   init?: () => Promise<void>;
-  getOrReload(cp: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | null>;
-  getStateOrBytes(cp: CheckpointHexPayload): Promise<CachedBeaconStateAllForks | Uint8Array | null>;
-  get(cpOrKey: CheckpointHexPayload | string): CachedBeaconStateAllForks | null;
-  add(cp: phase0.Checkpoint, state: CachedBeaconStateAllForks, payloadPresent: boolean): void;
-  getLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): CachedBeaconStateAllForks | null;
-  getOrReloadLatest(
-    rootHex: RootHex,
-    maxEpoch: Epoch,
-    payloadPresent: boolean
-  ): Promise<CachedBeaconStateAllForks | null>;
+  getOrReload(cp: CheckpointHexPayload): Promise<IBeaconStateView | null>;
+  getStateOrBytes(cp: CheckpointHexPayload): Promise<IBeaconStateView | Uint8Array | null>;
+  get(cpOrKey: CheckpointHexPayload | string): IBeaconStateView | null;
+  add(cp: phase0.Checkpoint, state: IBeaconStateView, payloadPresent: boolean): void;
+  getLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): IBeaconStateView | null;
+  getOrReloadLatest(rootHex: RootHex, maxEpoch: Epoch, payloadPresent: boolean): Promise<IBeaconStateView | null>;
   updatePreComputedCheckpoint(rootHex: RootHex, epoch: Epoch, payloadPresent: boolean): number | null;
   prune(finalizedEpoch: Epoch, justifiedEpoch: Epoch): void;
   pruneFinalized(finalizedEpoch: Epoch): void;
-  processState(blockRootHex: RootHex, state: CachedBeaconStateAllForks): Promise<number>;
+  processState(blockRootHex: RootHex, state: IBeaconStateView): Promise<number>;
   clear(): void;
   dumpSummary(): routes.lodestar.StateCacheItem[];
   /** Expose beacon states stored in cache. Use with caution */
-  getStates(): IterableIterator<CachedBeaconStateAllForks>;
+  getStates(): IterableIterator<IBeaconStateView>;
 }
 
 export enum CacheItemType {

package/src/chain/validation/attesterSlashing.ts

@@ -48,7 +48,7 @@ export async function validateAttesterSlashing(
       chain.config,
       chain.pubkeyCache,
       state.slot,
-      state.validators.length,
+      state.validatorCount,
       attesterSlashing,
       false
     );
@@ -59,8 +59,8 @@ export async function validateAttesterSlashing(
     });
   }
 
-  const currentEpoch = state.epochCtx.epoch;
-  if (!intersectingIndices.some((index) => isSlashableValidator(state.validators.getReadonly(index), currentEpoch))) {
+  const currentEpoch = state.epoch;
+  if (!intersectingIndices.some((index) => isSlashableValidator(state.getValidator(index), currentEpoch))) {
     throw new AttesterSlashingError(GossipAction.REJECT, {
       code: AttesterSlashingErrorCode.INVALID,
       error: Error("AttesterSlashing has no slashable validators"),

package/src/chain/validation/blobSidecar.ts

@@ -176,7 +176,7 @@ export async function validateGossipBlobSidecar(
   // MAY be queued for later processing while proposers for the block's branch are calculated -- in such
   // a case _do not_ `REJECT`, instead `IGNORE` this message.
   const proposerIndex = blobSidecar.signedBlockHeader.message.proposerIndex;
-  if (blockState.epochCtx.getBeaconProposer(blobSlot) !== proposerIndex) {
+  if (blockState.getBeaconProposer(blobSlot) !== proposerIndex) {
     throw new BlobSidecarGossipError(GossipAction.REJECT, {
       code: BlobSidecarErrorCode.INCORRECT_PROPOSER,
       proposerIndex,

package/src/chain/validation/block.ts

@@ -6,8 +6,6 @@ import {
   computeTimeAtSlot,
   getBlockProposerSignatureSet,
   isExecutionBlockBodyType,
-  isExecutionEnabled,
-  isExecutionStateType,
 } from "@lodestar/state-transition";
 import {SignedBeaconBlock, deneb, gloas, isGloasBeaconBlock} from "@lodestar/types";
 import {byteArrayEquals, sleep, toRootHex} from "@lodestar/utils";
@@ -176,7 +174,7 @@ export async function validateGossipBlock(
   if (isForkPostBellatrix(fork) && !isForkPostGloas(fork)) {
     if (!isExecutionBlockBodyType(block.body)) throw Error("Not execution block body type");
     const executionPayload = block.body.executionPayload;
-    if (isExecutionStateType(blockState) && isExecutionEnabled(blockState, block)) {
+    if (blockState.isExecutionStateType && blockState.isExecutionEnabled(block)) {
       const expectedTimestamp = computeTimeAtSlot(config, blockSlot, chain.genesisTime);
       if (executionPayload.timestamp !== computeTimeAtSlot(config, blockSlot, chain.genesisTime)) {
         throw new BlockGossipError(GossipAction.REJECT, {
@@ -206,7 +204,7 @@ export async function validateGossipBlock(
   // shuffling (defined by parent_root/slot). If the proposer_index cannot immediately be verified against the expected
   // shuffling, the block MAY be queued for later processing while proposers for the block's branch are calculated --
   // in such a case do not REJECT, instead IGNORE this message.
-  if (blockState.epochCtx.getBeaconProposer(blockSlot) !== proposerIndex) {
+  if (blockState.getBeaconProposer(blockSlot) !== proposerIndex) {
     throw new BlockGossipError(GossipAction.REJECT, {code: BlockErrorCode.INCORRECT_PROPOSER, proposerIndex});
   }
 

package/src/chain/validation/blsToExecutionChange.ts

@@ -39,12 +39,12 @@ async function validateBlsToExecutionChange(
   const state = chain.getHeadState();
   const {config} = chain;
   const addressChange = blsToExecutionChange.message;
-  if (addressChange.validatorIndex >= state.validators.length) {
+  if (addressChange.validatorIndex >= state.validatorCount) {
     throw new BlsToExecutionChangeError(GossipAction.REJECT, {
       code: BlsToExecutionChangeErrorCode.INVALID,
     });
   }
-  const validator = state.validators.getReadonly(addressChange.validatorIndex);
+  const validator = state.getValidator(addressChange.validatorIndex);
   // [REJECT] All of the conditions within process_bls_to_execution_change pass validation.
   // verifySignature = false, verified in batch below
   const {valid} = isValidBlsToExecutionChange(config, validator, blsToExecutionChange, false);

package/src/chain/validation/dataColumnSidecar.ts

@@ -122,7 +122,7 @@ export async function validateGossipDataColumnSidecar(
   //              while proposers for the block's branch are calculated -- in such a case do not REJECT, instead IGNORE
   //              this message.
   const proposerIndex = blockHeader.proposerIndex;
-  const expectedProposerIndex = blockState.epochCtx.getBeaconProposer(blockHeader.slot);
+  const expectedProposerIndex = blockState.getBeaconProposer(blockHeader.slot);
 
   if (proposerIndex !== expectedProposerIndex) {
     throw new DataColumnSidecarGossipError(GossipAction.REJECT, {

package/src/chain/validation/executionPayloadBid.ts

@@ -1,7 +1,5 @@
 import {PublicKey} from "@chainsafe/blst";
 import {
-  CachedBeaconStateGloas,
-  canBuilderCoverBid,
   createSingleSignatureSetFromComponents,
   getExecutionPayloadBidSigningRoot,
   isActiveBuilder,
@@ -33,9 +31,7 @@ async function validateExecutionPayloadBid(
   const bid = signedExecutionPayloadBid.message;
   const parentBlockRootHex = toRootHex(bid.parentBlockRoot);
   const parentBlockHashHex = toRootHex(bid.parentBlockHash);
-  const state = (await chain.getHeadStateAtCurrentEpoch(
-    RegenCaller.validateGossipExecutionPayloadBid
-  )) as CachedBeaconStateGloas;
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipExecutionPayloadBid);
 
   // [IGNORE] `bid.slot` is the current slot or the next slot.
   const currentSlot = chain.clock.currentSlot;
@@ -53,7 +49,7 @@ async function validateExecutionPayloadBid(
 
   // [REJECT] `bid.builder_index` is a valid/active builder index -- i.e.
   // `is_active_builder(state, bid.builder_index)` returns `True`.
-  const builder = state.builders.getReadonly(bid.builderIndex);
+  const builder = state.getBuilder(bid.builderIndex);
   if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
     throw new ExecutionPayloadBidError(GossipAction.REJECT, {
       code: ExecutionPayloadBidErrorCode.BUILDER_NOT_ELIGIBLE,
@@ -99,7 +95,7 @@ async function validateExecutionPayloadBid(
   }
   // [IGNORE] `bid.value` is less or equal than the builder's excess balance --
   // i.e. `can_builder_cover_bid(state, builder_index, amount)` returns `True`.
-  if (!canBuilderCoverBid(state, bid.builderIndex, bid.value)) {
+  if (!state.canBuilderCoverBid(bid.builderIndex, bid.value)) {
     throw new ExecutionPayloadBidError(GossipAction.IGNORE, {
       code: ExecutionPayloadBidErrorCode.BID_TOO_HIGH,
       bidValue: bid.value,

package/src/chain/validation/executionPayloadEnvelope.ts

@@ -1,10 +1,5 @@
 import {PayloadStatus} from "@lodestar/fork-choice";
-import {
-  BeaconStateView,
-  CachedBeaconStateGloas,
-  computeStartSlotAtEpoch,
-  getExecutionPayloadEnvelopeSignatureSet,
-} from "@lodestar/state-transition";
+import {computeStartSlotAtEpoch, getExecutionPayloadEnvelopeSignatureSet} from "@lodestar/state-transition";
 import {gloas} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {ExecutionPayloadEnvelopeError, ExecutionPayloadEnvelopeErrorCode, GossipAction} from "../errors/index.js";
@@ -119,11 +114,10 @@ async function validateExecutionPayloadEnvelope(
       });
     });
 
-  const state = blockState as CachedBeaconStateGloas;
   const signatureSet = getExecutionPayloadEnvelopeSignatureSet(
     chain.config,
     chain.pubkeyCache,
-    new BeaconStateView(state),
+    blockState,
     executionPayloadEnvelope,
     payloadInput.proposerIndex
   );

package/src/chain/validation/payloadAttestationMessage.ts

@@ -1,5 +1,4 @@
 import {
-  CachedBeaconStateGloas,
   computeEpochAtSlot,
   createSingleSignatureSetFromComponents,
   getPayloadAttestationDataSigningRoot,
@@ -66,7 +65,7 @@ async function validatePayloadAttestationMessage(
     });
   }
 
-  const state = chain.getHeadState() as CachedBeaconStateGloas;
+  const state = chain.getHeadState();
 
   // [REJECT] The message's block `data.beacon_block_root` passes validation.
   // TODO GLOAS: implement this. Technically if we cannot get proto block from fork choice,
@@ -75,8 +74,7 @@ async function validatePayloadAttestationMessage(
   // [REJECT] The message's validator index is within the payload committee in
   // `get_ptc(state, data.slot)`. The `state` is the head state corresponding to
   // processing the block up to the current slot as determined by the fork choice.
-  const ptc = state.epochCtx.getPayloadTimelinessCommittee(data.slot);
-  const validatorCommitteeIndex = ptc.indexOf(validatorIndex);
+  const validatorCommitteeIndex = state.getIndexInPayloadTimelinessCommittee(validatorIndex, data.slot);
 
   if (validatorCommitteeIndex === -1) {
     throw new PayloadAttestationError(GossipAction.REJECT, {

package/src/chain/validation/proposerSlashing.ts

@@ -35,7 +35,7 @@ async function validateProposerSlashing(
 
   // [REJECT] All of the conditions within process_proposer_slashing pass validation.
   try {
-    const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
+    const proposer = state.getValidator(proposerSlashing.signedHeader1.message.proposerIndex);
     // verifySignature = false, verified in batch below
     assertValidProposerSlashing(chain.config, chain.pubkeyCache, state.slot, proposerSlashing, proposer, false);
   } catch (e) {

package/src/chain/validation/signatureSets/contributionAndProof.ts

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_CONTRIBUTION_AND_PROOF} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getContributionAndProofSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   signedContributionAndProof: altair.SignedContributionAndProof
 ): ISignatureSet {
   const domain = config.getDomain(

package/src/chain/validation/signatureSets/syncCommittee.ts

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage
 ): ISignatureSet {
   const domain = config.getDomain(state.slot, DOMAIN_SYNC_COMMITTEE, syncCommittee.slot);

package/src/chain/validation/signatureSets/syncCommitteeContribution.ts

@@ -1,11 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
-import {CachedBeaconStateAltair, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeContributionSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAltair,
+  state: IBeaconStateView,
   contribution: altair.SyncCommitteeContribution,
   participantIndices: number[]
 ): ISignatureSet {

package/src/chain/validation/signatureSets/syncCommitteeSelectionProof.ts

@@ -1,16 +1,11 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF} from "@lodestar/params";
-import {
-  CachedBeaconStateAllForks,
-  ISignatureSet,
-  SignatureSetType,
-  computeSigningRoot,
-} from "@lodestar/state-transition";
+import {IBeaconStateView, ISignatureSet, SignatureSetType, computeSigningRoot} from "@lodestar/state-transition";
 import {altair, ssz} from "@lodestar/types";
 
 export function getSyncCommitteeSelectionProofSignatureSet(
   config: BeaconConfig,
-  state: CachedBeaconStateAllForks,
+  state: IBeaconStateView,
   contributionAndProof: altair.ContributionAndProof
 ): ISignatureSet {
   const slot = contributionAndProof.contribution.slot;

package/src/chain/validation/syncCommittee.ts

@@ -1,5 +1,5 @@
 import {SYNC_COMMITTEE_SUBNET_COUNT, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
-import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
+import {IBeaconStateView} from "@lodestar/state-transition";
 import {SubnetID, altair} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {GossipAction, SyncCommitteeError, SyncCommitteeErrorCode} from "../errors/index.js";
@@ -15,12 +15,12 @@ export async function validateGossipSyncCommittee(
   chain: IBeaconChain,
   syncCommittee: altair.SyncCommitteeMessage,
   subnet: SubnetID
-): Promise<{indexInSubcommittee: IndexInSubcommittee}> {
+): Promise<{indicesInSubcommittee: IndexInSubcommittee[]}> {
   const {slot, validatorIndex, beaconBlockRoot} = syncCommittee;
   const messageRoot = toRootHex(beaconBlockRoot);
 
   const headState = chain.getHeadState();
-  const indexInSubcommittee = validateGossipSyncCommitteeExceptSig(chain, headState, subnet, syncCommittee);
+  const indicesInSubcommittee = validateGossipSyncCommitteeExceptSig(chain, headState, subnet, syncCommittee);
 
   // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
   // > Checked in validateGossipSyncCommitteeExceptSig()
@@ -68,12 +68,12 @@ export async function validateGossipSyncCommittee(
   // Register this valid item as seen
   chain.seenSyncCommitteeMessages.add(slot, subnet, validatorIndex, messageRoot);
 
-  return {indexInSubcommittee};
+  return {indicesInSubcommittee};
 }
 
 export async function validateApiSyncCommittee(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage
 ): Promise<void> {
   const prioritizeBls = true;
@@ -85,7 +85,7 @@ export async function validateApiSyncCommittee(
  */
 async function validateSyncCommitteeSigOnly(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   syncCommittee: altair.SyncCommitteeMessage,
   prioritizeBls = false
 ): Promise<void> {
@@ -102,10 +102,10 @@ async function validateSyncCommitteeSigOnly(
  */
 export function validateGossipSyncCommitteeExceptSig(
   chain: IBeaconChain,
-  headState: CachedBeaconStateAllForks,
+  headState: IBeaconStateView,
   subnet: SubnetID,
   data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
-): IndexInSubcommittee {
+): IndexInSubcommittee[] {
   const {slot, validatorIndex} = data;
   // [IGNORE] The signature's slot is for the current slot, i.e. sync_committee_signature.slot == current_slot.
   // (with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
@@ -127,39 +127,40 @@ export function validateGossipSyncCommitteeExceptSig(
 
   // [REJECT] The subnet_id is valid for the given validator, i.e. subnet_id in compute_subnets_for_sync_committee(state, sync_committee_signature.validator_index).
   // Note this validation implies the validator is part of the broader current sync committee along with the correct subcommittee.
-  const indexInSubcommittee = getIndexInSubcommittee(headState, subnet, data);
-  if (indexInSubcommittee === null) {
+  const indicesInSubcommittee = getIndicesInSubcommittee(headState, subnet, data);
+  if (indicesInSubcommittee === null) {
     throw new SyncCommitteeError(GossipAction.REJECT, {
       code: SyncCommitteeErrorCode.VALIDATOR_NOT_IN_SYNC_COMMITTEE,
       validatorIndex,
     });
   }
 
-  return indexInSubcommittee;
+  return indicesInSubcommittee;
 }
 
 /**
- * Returns the IndexInSubcommittee of the given `subnet`.
- * Returns `null` if not part of the sync committee or not part of the given `subnet`
+ * Returns all IndexInSubcommittee positions of the given `subnet`.
+ * Returns `null` if not part of the sync committee or not part of the given `subnet`.
+ * A validator may appear multiple times in the same subcommittee.
  */
-function getIndexInSubcommittee(
-  headState: CachedBeaconStateAllForks,
+function getIndicesInSubcommittee(
+  headState: IBeaconStateView,
   subnet: SubnetID,
   data: Pick<altair.SyncCommitteeMessage, "slot" | "validatorIndex">
-): IndexInSubcommittee | null {
-  const syncCommittee = headState.epochCtx.getIndexedSyncCommittee(data.slot);
+): IndexInSubcommittee[] | null {
+  const syncCommittee = headState.getIndexedSyncCommittee(data.slot);
   const indexesInCommittee = syncCommittee.validatorIndexMap.get(data.validatorIndex);
   if (indexesInCommittee === undefined) {
     // Not part of the sync committee
     return null;
   }
 
+  const indices: IndexInSubcommittee[] = [];
   for (const indexInCommittee of indexesInCommittee) {
     if (Math.floor(indexInCommittee / SYNC_COMMITTEE_SUBNET_SIZE) === subnet) {
-      return indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE;
+      indices.push(indexInCommittee % SYNC_COMMITTEE_SUBNET_SIZE);
     }
   }
 
-  // Not part of this specific subnet
-  return null;
+  return indices.length > 0 ? indices : null;
 }