@lodestar/state-transition 1.41.0-dev.702f7932c2 → 1.41.0-dev.8578102bd2

package/src/block/processPayloadAttestation.ts

@@ -1,7 +1,7 @@
 import {gloas} from "@lodestar/types";
 import {byteArrayEquals} from "@lodestar/utils";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.js";
 
 export function processPayloadAttestation(
   state: CachedBeaconStateGloas,

package/src/block/processProposerSlashing.ts

@@ -2,7 +2,7 @@ import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {Slot, phase0, ssz} from "@lodestar/types";
 import {Validator} from "@lodestar/types/phase0";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
@@ -24,7 +24,7 @@ export function processProposerSlashing(
   const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
   assertValidProposerSlashing(
     state.config,
-    state.epochCtx.index2pubkey,
+    state.epochCtx.pubkeyCache,
     state.slot,
     proposerSlashing,
     proposer,
@@ -57,7 +57,7 @@ export function processProposerSlashing(
 
 export function assertValidProposerSlashing(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing,
   proposer: Validator,
@@ -94,7 +94,7 @@ export function assertValidProposerSlashing(
   if (verifySignatures) {
     const signatureSets = getProposerSlashingSignatureSets(config, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
-      if (!verifySignatureSet(signatureSets[i], index2pubkey)) {
+      if (!verifySignatureSet(signatureSets[i], pubkeyCache)) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);
       }
     }

package/src/block/processRandao.ts

@@ -17,7 +17,7 @@ export function processRandao(state: CachedBeaconStateAllForks, block: BeaconBlo
   const randaoReveal = block.body.randaoReveal;
 
   // verify RANDAO reveal
-  if (verifySignature && !verifyRandaoSignature(config, epochCtx.index2pubkey, block)) {
+  if (verifySignature && !verifyRandaoSignature(config, epochCtx.pubkeyCache, block)) {
     throw new Error("RANDAO reveal is an invalid signature");
   }
 

package/src/block/processSyncCommittee.ts

@@ -32,7 +32,7 @@ export function processSyncAggregate(
       participantIndices
     );
     // When there's no participation we consider the signature valid and just ignore it
-    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.index2pubkey)) {
+    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.pubkeyCache)) {
       throw Error("Sync committee signature invalid");
     }
   }

package/src/block/processVoluntaryExit.ts

@@ -131,7 +131,7 @@ export function getVoluntaryExitValidity(
 
   if (
     verifySignature &&
-    !verifyVoluntaryExitSignature(state.config, epochCtx.index2pubkey, state.slot, signedVoluntaryExit)
+    !verifyVoluntaryExitSignature(state.config, epochCtx.pubkeyCache, state.slot, signedVoluntaryExit)
   ) {
     return VoluntaryExitValidity.invalidSignature;
   }

package/src/block/processWithdrawalRequest.ts

@@ -21,7 +21,7 @@ export function processWithdrawalRequest(
   const amount = Number(withdrawalRequest.amount);
   const {pendingPartialWithdrawals, validators, epochCtx} = state;
   // no need to use unfinalized pubkey cache from 6110 as validator won't be active anyway
-  const {pubkey2index, config} = epochCtx;
+  const {pubkeyCache, config} = epochCtx;
   const isFullExitRequest = amount === FULL_EXIT_REQUEST_AMOUNT;
 
   // If partial withdrawal queue is full, only full exits are processed
@@ -31,7 +31,7 @@ export function processWithdrawalRequest(
 
   // bail out if validator is not in beacon state
   // note that we don't need to check for 6110 unfinalized vals as they won't be eligible for withdraw/exit anyway
-  const validatorIndex = pubkey2index.get(withdrawalRequest.validatorPubkey);
+  const validatorIndex = pubkeyCache.getIndex(withdrawalRequest.validatorPubkey);
   if (validatorIndex === null) {
     return;
   }

package/src/block/processWithdrawals.ts

@@ -16,7 +16,7 @@ import {
   convertValidatorIndexToBuilderIndex,
   isBuilderIndex,
   isParentBlockFull,
-} from "../util/gloas.ts";
+} from "../util/gloas.js";
 import {
   decreaseBalance,
   getMaxEffectiveBalance,
@@ -249,6 +249,10 @@ function getPendingPartialWithdrawals(
     numPriorWithdrawal + MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP,
     MAX_WITHDRAWALS_PER_PAYLOAD - 1
   );
+  // There must be at least one space reserved for validator sweep withdrawals
+  if (numPriorWithdrawal > partialWithdrawalBound) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} > ${partialWithdrawalBound}`);
+  }
 
   // MAX_PENDING_PARTIALS_PER_WITHDRAWALS_SWEEP = 8, PENDING_PARTIAL_WITHDRAWALS_LIMIT: 134217728 so we should only call getAllReadonly() if it makes sense
   // pendingPartialWithdrawals comes from EIP-7002 smart contract where it takes fee so it's more likely than not validator is in correct condition to withdraw
@@ -309,6 +313,11 @@ function getValidatorsSweepWithdrawals(
   numPriorWithdrawal: number,
   validatorBalanceAfterWithdrawals: Map<ValidatorIndex, number>
 ): {sweepWithdrawals: capella.Withdrawal[]; processedCount: number} {
+  // There must be at least one space reserved for validator sweep withdrawals
+  if (numPriorWithdrawal >= MAX_WITHDRAWALS_PER_PAYLOAD) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} >= ${MAX_WITHDRAWALS_PER_PAYLOAD}`);
+  }
+
   const sweepWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
   const {validators, balances, nextWithdrawalValidatorIndex} = state;
@@ -319,7 +328,7 @@ function getValidatorsSweepWithdrawals(
   // Just run a bounded loop max iterating over all withdrawals
   // however breaks out once we have MAX_WITHDRAWALS_PER_PAYLOAD
   for (let n = 0; n < validatorsLimit; n++) {
-    if (sweepWithdrawals.length + numPriorWithdrawal === MAX_WITHDRAWALS_PER_PAYLOAD) {
+    if (sweepWithdrawals.length + numPriorWithdrawal >= MAX_WITHDRAWALS_PER_PAYLOAD) {
       break;
     }
 

package/src/cache/epochCache.ts

@@ -1,5 +1,4 @@
 import {PublicKey} from "@chainsafe/blst";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig, ChainConfig, createBeaconConfig} from "@lodestar/config";
 import {
   ATTESTATION_SUBNET_COUNT,
@@ -36,6 +35,7 @@ import {
 import {
   computeActivationExitEpoch,
   computeEpochAtSlot,
+  computePayloadTimelinessCommitteesForEpoch,
   computeProposers,
   computeSyncPeriodAtEpoch,
   getActivationChurnLimit,
@@ -43,7 +43,6 @@ import {
   getSeed,
   isActiveValidator,
   isAggregatorFromCommitteeLength,
-  naiveGetPayloadTimlinessCommitteeIndices,
 } from "../util/index.js";
 import {
   AttesterDuty,
@@ -56,7 +55,7 @@ import {computeBaseRewardPerIncrement, computeSyncParticipantReward} from "../ut
 import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalance.js";
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
 import {EpochTransitionCache} from "./epochTransitionCache.js";
-import {Index2PubkeyCache, syncPubkeys} from "./pubkeyCache.js";
+import {PubkeyCache, createPubkeyCache, syncPubkeys} from "./pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateFulu} from "./stateCache.js";
 import {
   SyncCommitteeCache,
@@ -64,15 +63,14 @@ import {
   computeSyncCommitteeCache,
   getSyncCommitteeCache,
 } from "./syncCommitteeCache.js";
-import {BeaconStateAllForks, BeaconStateAltair, BeaconStateGloas, ShufflingGetter} from "./types.js";
+import {BeaconStateAllForks, BeaconStateAltair, ShufflingGetter} from "./types.js";
 
 /** `= PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT)` */
 export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PROPOSER_WEIGHT);
 
 export type EpochCacheImmutableData = {
   config: BeaconConfig;
-  pubkey2index: PubkeyIndexMap;
-  index2pubkey: Index2PubkeyCache;
+  pubkeyCache: PubkeyCache;
 };
 
 export type EpochCacheOpts = {
@@ -111,15 +109,9 @@ export class EpochCache {
   /**
    * Unique globally shared pubkey registry. There should only exist one for the entire application.
    *
-   * $VALIDATOR_COUNT x 192 char String -> Number Map
+   * Couples both index→pubkey and pubkey→index lookups, keeping them in sync atomically.
    */
-  pubkey2index: PubkeyIndexMap;
-  /**
-   * Unique globally shared pubkey registry. There should only exist one for the entire application.
-   *
-   * $VALIDATOR_COUNT x BLST deserialized pubkey (Jacobian coordinates)
-   */
-  index2pubkey: Index2PubkeyCache;
+  pubkeyCache: PubkeyCache;
   /**
    * Indexes of the block proposers for the current epoch.
    * For pre-fulu, this is computed and cached from the current shuffling.
@@ -234,9 +226,11 @@ export class EpochCache {
   /** TODO: Indexed SyncCommitteeCache */
   nextSyncCommitteeIndexed: SyncCommitteeCache;
 
-  // TODO GLOAS: See if we need to cached PTC for prev/next epoch
-  // PTC for current epoch
-  payloadTimelinessCommittee: ValidatorIndex[][];
+  // TODO GLOAS: See if we need to cache PTC for next epoch
+  // PTC for previous epoch, required for slot N block validating slot N-1 attestations
+  previousPayloadTimelinessCommittees: Uint32Array[];
+  // PTC for current epoch, computed eagerly at epoch transition
+  payloadTimelinessCommittees: Uint32Array[];
 
   // TODO: Helper stats
   syncPeriod: SyncPeriod;
@@ -249,8 +243,7 @@ export class EpochCache {
 
   constructor(data: {
     config: BeaconConfig;
-    pubkey2index: PubkeyIndexMap;
-    index2pubkey: Index2PubkeyCache;
+    pubkeyCache: PubkeyCache;
     proposers: number[];
     proposersPrevEpoch: number[] | null;
     proposersNextEpoch: ProposersDeferred;
@@ -275,13 +268,13 @@ export class EpochCache {
     previousTargetUnslashedBalanceIncrements: number;
     currentSyncCommitteeIndexed: SyncCommitteeCache;
     nextSyncCommitteeIndexed: SyncCommitteeCache;
-    payloadTimelinessCommittee: ValidatorIndex[][];
+    previousPayloadTimelinessCommittees: Uint32Array[];
+    payloadTimelinessCommittees: Uint32Array[];
     epoch: Epoch;
     syncPeriod: SyncPeriod;
   }) {
     this.config = data.config;
-    this.pubkey2index = data.pubkey2index;
-    this.index2pubkey = data.index2pubkey;
+    this.pubkeyCache = data.pubkeyCache;
     this.proposers = data.proposers;
     this.proposersPrevEpoch = data.proposersPrevEpoch;
     this.proposersNextEpoch = data.proposersNextEpoch;
@@ -306,7 +299,8 @@ export class EpochCache {
     this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
     this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
-    this.payloadTimelinessCommittee = data.payloadTimelinessCommittee;
+    this.previousPayloadTimelinessCommittees = data.previousPayloadTimelinessCommittees;
+    this.payloadTimelinessCommittees = data.payloadTimelinessCommittees;
     this.epoch = data.epoch;
     this.syncPeriod = data.syncPeriod;
   }
@@ -319,7 +313,7 @@ export class EpochCache {
    */
   static createFromState(
     state: BeaconStateAllForks,
-    {config, pubkey2index, index2pubkey}: EpochCacheImmutableData,
+    {config, pubkeyCache}: EpochCacheImmutableData,
     opts?: EpochCacheOpts
   ): EpochCache {
     const currentEpoch = computeEpochAtSlot(state.slot);
@@ -335,9 +329,9 @@ export class EpochCache {
     const validatorCount = validators.length;
 
     // syncPubkeys here to ensure EpochCacheImmutableData is popualted before computing the rest of caches
-    // - computeSyncCommitteeCache() needs a fully populated pubkey2index cache
+    // - computeSyncCommitteeCache() needs a fully populated pubkeyCache
     if (!opts?.skipSyncPubkeys) {
-      syncPubkeys(validators, pubkey2index, index2pubkey);
+      syncPubkeys(pubkeyCache, validators);
     }
 
     const effectiveBalanceIncrements = getEffectiveBalanceIncrementsWithLen(validatorCount);
@@ -450,22 +444,32 @@ export class EpochCache {
     // Allow to skip populating sync committee for initializeBeaconStateFromEth1()
     if (afterAltairFork && !opts?.skipSyncCommitteeCache) {
       const altairState = state as BeaconStateAltair;
-      currentSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.currentSyncCommittee, pubkey2index);
-      nextSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.nextSyncCommittee, pubkey2index);
+      currentSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.currentSyncCommittee, pubkeyCache);
+      nextSyncCommitteeIndexed = computeSyncCommitteeCache(altairState.nextSyncCommittee, pubkeyCache);
     } else {
       currentSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
       nextSyncCommitteeIndexed = new SyncCommitteeCacheEmpty();
     }
 
-    // Compute PTC for this epoch
-    let payloadTimelinessCommittee: ValidatorIndex[][] = [];
+    // Compute PTC for all slots in the prev/current epoch
+    let previousPayloadTimelinessCommittees: Uint32Array[] = [];
+    let payloadTimelinessCommittees: Uint32Array[] = [];
     if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
-      payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        currentShuffling,
-        effectiveBalanceIncrements,
-        currentEpoch
+      payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        currentEpoch,
+        currentShuffling.committees,
+        effectiveBalanceIncrements
       );
+
+      if (!isGenesis && previousEpoch >= config.GLOAS_FORK_EPOCH) {
+        previousPayloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+          state,
+          previousEpoch,
+          previousShuffling.committees,
+          effectiveBalanceIncrements
+        );
+      }
     }
 
     // Precompute churnLimit for efficient initiateValidatorExit() during block proposing MUST be recompute everytime the
@@ -514,8 +518,7 @@ export class EpochCache {
 
     return new EpochCache({
       config,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
       proposers,
       // On first epoch, set to null to prevent unnecessary work since this is only used for metrics
       proposersPrevEpoch: null,
@@ -541,7 +544,8 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: payloadTimelinessCommittee,
+      previousPayloadTimelinessCommittees,
+      payloadTimelinessCommittees,
       epoch: currentEpoch,
       syncPeriod: computeSyncPeriodAtEpoch(currentEpoch),
     });
@@ -557,8 +561,7 @@ export class EpochCache {
     return new EpochCache({
       config: this.config,
       // Common append-only structures shared with all states, no need to clone
-      pubkey2index: this.pubkey2index,
-      index2pubkey: this.index2pubkey,
+      pubkeyCache: this.pubkeyCache,
       // Immutable data
       proposers: this.proposers,
       proposersPrevEpoch: this.proposersPrevEpoch,
@@ -587,7 +590,8 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
-      payloadTimelinessCommittee: this.payloadTimelinessCommittee,
+      previousPayloadTimelinessCommittees: this.previousPayloadTimelinessCommittees,
+      payloadTimelinessCommittees: this.payloadTimelinessCommittees,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
     });
@@ -698,11 +702,13 @@ export class EpochCache {
 
     this.proposersPrevEpoch = this.proposers;
     if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
-      this.payloadTimelinessCommittee = naiveGetPayloadTimlinessCommitteeIndices(
-        state as BeaconStateGloas,
-        this.currentShuffling,
-        this.effectiveBalanceIncrements,
-        upcomingEpoch
+      // Shift and compute current epoch PTC eagerly for all slots
+      this.previousPayloadTimelinessCommittees = this.payloadTimelinessCommittees;
+      this.payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
+        state,
+        upcomingEpoch,
+        this.currentShuffling.committees,
+        this.effectiveBalanceIncrements
       );
     }
     if (upcomingEpoch >= this.config.FULU_FORK_EPOCH) {
@@ -882,16 +888,15 @@ export class EpochCache {
    * Return pubkey given the validator index.
    */
   getPubkey(index: ValidatorIndex): PublicKey | undefined {
-    return this.index2pubkey[index];
+    return this.pubkeyCache.get(index);
   }
 
   getValidatorIndex(pubkey: Uint8Array): ValidatorIndex | null {
-    return this.pubkey2index.get(pubkey);
+    return this.pubkeyCache.getIndex(pubkey);
   }
 
   addPubkey(index: ValidatorIndex, pubkey: Uint8Array): void {
-    this.pubkey2index.set(pubkey, index);
-    this.index2pubkey[index] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+    this.pubkeyCache.set(index, pubkey);
   }
 
   getShufflingAtSlot(slot: Slot): EpochShuffling {
@@ -1022,7 +1027,7 @@ export class EpochCache {
     return this.epoch >= this.config.ELECTRA_FORK_EPOCH;
   }
 
-  getPayloadTimelinessCommittee(slot: Slot): ValidatorIndex[] {
+  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
     const epoch = computeEpochAtSlot(slot);
 
     if (epoch < this.config.GLOAS_FORK_EPOCH) {
@@ -1030,7 +1035,11 @@ export class EpochCache {
     }
 
     if (epoch === this.epoch) {
-      return this.payloadTimelinessCommittee[slot % SLOTS_PER_EPOCH];
+      return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    }
+
+    if (epoch === this.epoch - 1 && this.previousPayloadTimelinessCommittees.length > 0) {
+      return this.previousPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
     }
 
     throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
@@ -1099,7 +1108,6 @@ export function createEmptyEpochCacheImmutableData(
   return {
     config: createBeaconConfig(chainConfig, state.genesisValidatorsRoot),
     // This is a test state, there's no need to have a global shared cache of keys
-    pubkey2index: new PubkeyIndexMap(),
-    index2pubkey: [],
+    pubkeyCache: createPubkeyCache(),
   };
 }

package/src/cache/pubkeyCache.ts

@@ -1,33 +1,74 @@
 import {PublicKey} from "@chainsafe/blst";
 import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-import {phase0} from "@lodestar/types";
+import {ValidatorIndex, phase0} from "@lodestar/types";
 
-export type Index2PubkeyCache = PublicKey[];
+/**
+ * Unified pubkey cache coupling index→pubkey and pubkey→index lookups.
+ * Both directions are kept in sync atomically via `set()`.
+ */
+export interface PubkeyCache {
+  /** Get deserialized PublicKey by validator index */
+  get(index: ValidatorIndex): PublicKey | undefined;
+  /** Get deserialized PublicKey by validator index or throw if not found */
+  getOrThrow(index: ValidatorIndex): PublicKey;
+  /** Get validator index by pubkey bytes */
+  getIndex(pubkey: Uint8Array): ValidatorIndex | null;
+  /** Set both directions atomically. Takes raw pubkey bytes — deserialization is handled internally. */
+  set(index: ValidatorIndex, pubkey: Uint8Array): void;
+  /** Number of entries */
+  readonly size: number;
+}
+
+class StandardPubkeyCache implements PubkeyCache {
+  private readonly pubkey2index: PubkeyIndexMap;
+  private readonly index2pubkey: (PublicKey | undefined)[];
+
+  constructor(pubkey2index?: PubkeyIndexMap, index2pubkey?: (PublicKey | undefined)[]) {
+    this.pubkey2index = pubkey2index ?? new PubkeyIndexMap();
+    this.index2pubkey = index2pubkey ?? [];
+  }
+
+  get size(): number {
+    return this.pubkey2index.size;
+  }
+
+  get(index: ValidatorIndex): PublicKey | undefined {
+    return this.index2pubkey[index];
+  }
+
+  getOrThrow(index: ValidatorIndex): PublicKey {
+    const pubkey = this.get(index);
+    if (!pubkey) throw Error(`Missing pubkey for validator index ${index}`);
+    return pubkey;
+  }
+
+  getIndex(pubkey: Uint8Array): ValidatorIndex | null {
+    return this.pubkey2index.get(pubkey);
+  }
+
+  set(index: ValidatorIndex, pubkey: Uint8Array): void {
+    this.pubkey2index.set(pubkey, index);
+    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed.
+    // Afterwards any public key in the state is considered validated.
+    // > Do not do any validation here
+    this.index2pubkey[index] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+  }
+}
+
+export function createPubkeyCache(): PubkeyCache {
+  return new StandardPubkeyCache();
+}
 
 /**
  * Checks the pubkey indices against a state and adds missing pubkeys
  *
- * Mutates `pubkey2index` and `index2pubkey`
+ * Mutates `pubkeyCache`
  *
- * If pubkey caches are empty: SLOW CODE - 🐢
+ * If pubkey cache is empty: SLOW CODE - 🐢
  */
-export function syncPubkeys(
-  validators: phase0.Validator[],
-  pubkey2index: PubkeyIndexMap,
-  index2pubkey: Index2PubkeyCache
-): void {
-  if (pubkey2index.size !== index2pubkey.length) {
-    throw new Error(`Pubkey indices have fallen out of sync: ${pubkey2index.size} != ${index2pubkey.length}`);
-  }
-
+export function syncPubkeys(pubkeyCache: PubkeyCache, validators: phase0.Validator[]): void {
   const newCount = validators.length;
-  index2pubkey.length = newCount;
-  for (let i = pubkey2index.size; i < newCount; i++) {
-    const pubkey = validators[i].pubkey;
-    pubkey2index.set(pubkey, i);
-    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed.
-    // Afterwards any public key is the state consider validated.
-    // > Do not do any validation here
-    index2pubkey[i] = PublicKey.fromBytes(pubkey); // Optimize for aggregation
+  for (let i = pubkeyCache.size; i < newCount; i++) {
+    pubkeyCache.set(i, validators[i].pubkey);
   }
 }

package/src/cache/stateCache.ts

@@ -1,4 +1,3 @@
-import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {loadState} from "../util/loadState/loadState.js";
 import {EpochCache, EpochCacheImmutableData, EpochCacheOpts} from "./epochCache.js";
@@ -168,7 +167,7 @@ export function createCachedBeaconState<T extends BeaconStateAllForks>(
  * Check loadState() api for more details
  * // TODO: rename to loadUnfinalizedCachedBeaconState() due to ELECTRA
  */
-export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStateCache>(
+export function loadCachedBeaconState<T extends CachedBeaconStateAllForks>(
   cachedSeedState: T,
   stateBytes: Uint8Array,
   opts?: EpochCacheOpts,
@@ -180,22 +179,19 @@ export function loadCachedBeaconState<T extends BeaconStateAllForks & BeaconStat
     stateBytes,
     seedValidatorsBytes
   );
-  const {pubkey2index, index2pubkey} = cachedSeedState.epochCtx;
+  const {pubkeyCache} = cachedSeedState.epochCtx;
   // Get the validators sub tree once for all the loop
   const validators = migratedState.validators;
   for (const validatorIndex of modifiedValidators) {
     const validator = validators.getReadonly(validatorIndex);
-    const pubkey = validator.pubkey;
-    pubkey2index.set(pubkey, validatorIndex);
-    index2pubkey[validatorIndex] = PublicKey.fromBytes(pubkey);
+    pubkeyCache.set(validatorIndex, validator.pubkey);
   }
 
   return createCachedBeaconState(
     migratedState,
     {
       config: cachedSeedState.config,
-      pubkey2index,
-      index2pubkey,
+      pubkeyCache,
     },
     {...(opts ?? {}), ...{skipSyncPubkeys: true}}
   ) as T;

package/src/cache/syncCommitteeCache.ts

@@ -1,4 +1,3 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {CompositeViewDU} from "@chainsafe/ssz";
 import {ValidatorIndex, ssz} from "@lodestar/types";
 import {toPubkeyHex} from "@lodestar/utils";
@@ -39,9 +38,9 @@ export function getSyncCommitteeCache(validatorIndices: Uint32Array): SyncCommit
 
 export function computeSyncCommitteeCache(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
 ): SyncCommitteeCache {
-  const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkey2index);
+  const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkeyCache);
   const validatorIndexMap = computeValidatorSyncCommitteeIndexMap(validatorIndices);
   return {
     validatorIndices,
@@ -79,12 +78,12 @@ export function computeValidatorSyncCommitteeIndexMap(
  */
 function computeSyncCommitteeValidatorIndices(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
 ): Uint32Array {
   const pubkeys = syncCommittee.pubkeys.getAllReadonly();
   const validatorIndices = new Uint32Array(pubkeys.length);
   for (const [i, pubkey] of pubkeys.entries()) {
-    const validatorIndex = pubkey2index.get(pubkey);
+    const validatorIndex = pubkeyCache.getIndex(pubkey);
     if (validatorIndex === null) {
       throw Error(`SyncCommittee pubkey is unknown ${toPubkeyHex(pubkey)}`);
     }

package/src/epoch/index.ts

@@ -16,7 +16,7 @@ import {
   CachedBeaconStatePhase0,
   EpochTransitionCache,
 } from "../types.js";
-import {processBuilderPendingPayments} from "./processBuilderPendingPayments.ts";
+import {processBuilderPendingPayments} from "./processBuilderPendingPayments.js";
 import {processEffectiveBalanceUpdates} from "./processEffectiveBalanceUpdates.js";
 import {processEth1DataReset} from "./processEth1DataReset.js";
 import {processHistoricalRootsUpdate} from "./processHistoricalRootsUpdate.js";

package/src/epoch/processBuilderPendingPayments.ts

@@ -1,7 +1,7 @@
 import {SLOTS_PER_EPOCH} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {getBuilderPaymentQuorumThreshold} from "../util/gloas.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {getBuilderPaymentQuorumThreshold} from "../util/gloas.js";
 
 /**
  * Processes the builder pending payments from the previous epoch.

package/src/index.ts

@@ -25,7 +25,7 @@ export {
   createEmptyEpochCacheImmutableData,
 } from "./cache/epochCache.js";
 export {type EpochTransitionCache, beforeProcessEpoch} from "./cache/epochTransitionCache.js";
-export {type Index2PubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
+export {type PubkeyCache, createPubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
 // Main state caches
 export {
   type BeaconStateCache,
@@ -35,12 +35,14 @@ export {
   isStateValidatorsNodesPopulated,
   loadCachedBeaconState,
 } from "./cache/stateCache.js";
+export {type SyncCommitteeCache} from "./cache/syncCommitteeCache.js";
 export * from "./constants/index.js";
 export type {EpochTransitionStep} from "./epoch/index.js";
 export {type BeaconStateTransitionMetrics, getMetrics} from "./metrics.js";
 export * from "./rewards/index.js";
 export * from "./signatureSets/index.js";
 export * from "./stateTransition.js";
+export * from "./stateView/index.js";
 export type {
   BeaconStateAllForks,
   BeaconStateAltair,