@lodestar/state-transition 1.41.0-dev.d41697c085 → 1.41.0-dev.dce096d70c

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,
@@ -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,
@@ -71,8 +70,7 @@ export const PROPOSER_WEIGHT_FACTOR = PROPOSER_WEIGHT / (WEIGHT_DENOMINATOR - PR
 
 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,7 +226,9 @@ export class EpochCache {
   /** TODO: Indexed SyncCommitteeCache */
   nextSyncCommitteeIndexed: SyncCommitteeCache;
 
-  // TODO GLOAS: See if we need to cached PTC for prev/next epoch
+  // 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[];
 
@@ -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;
+    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,6 +299,7 @@ export class EpochCache {
     this.previousTargetUnslashedBalanceIncrements = data.previousTargetUnslashedBalanceIncrements;
     this.currentSyncCommitteeIndexed = data.currentSyncCommitteeIndexed;
     this.nextSyncCommitteeIndexed = data.nextSyncCommitteeIndexed;
+    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,14 +444,15 @@ 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 eagerly for all slots in the epoch
+    // Compute PTC for all slots in the prev/current epoch
+    let previousPayloadTimelinessCommittees: Uint32Array[] = [];
     let payloadTimelinessCommittees: Uint32Array[] = [];
     if (currentEpoch >= config.GLOAS_FORK_EPOCH) {
       payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
@@ -466,6 +461,15 @@ export class EpochCache {
         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,6 +544,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed,
+      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,6 +590,7 @@ export class EpochCache {
       currentTargetUnslashedBalanceIncrements: this.currentTargetUnslashedBalanceIncrements,
       currentSyncCommitteeIndexed: this.currentSyncCommitteeIndexed,
       nextSyncCommitteeIndexed: this.nextSyncCommitteeIndexed,
+      previousPayloadTimelinessCommittees: this.previousPayloadTimelinessCommittees,
       payloadTimelinessCommittees: this.payloadTimelinessCommittees,
       epoch: this.epoch,
       syncPeriod: this.syncPeriod,
@@ -698,6 +702,8 @@ export class EpochCache {
 
     this.proposersPrevEpoch = this.proposers;
     if (upcomingEpoch >= this.config.GLOAS_FORK_EPOCH) {
+      // Shift and compute current epoch PTC eagerly for all slots
+      this.previousPayloadTimelinessCommittees = this.payloadTimelinessCommittees;
       this.payloadTimelinessCommittees = computePayloadTimelinessCommitteesForEpoch(
         state,
         upcomingEpoch,
@@ -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 {
@@ -1029,11 +1034,15 @@ export class EpochCache {
       throw new Error("Payload Timeliness Committee is not available before gloas fork");
     }
 
-    if (epoch !== this.epoch) {
-      throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
+    if (epoch === this.epoch) {
+      return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    }
+
+    if (epoch === this.epoch - 1 && this.previousPayloadTimelinessCommittees.length > 0) {
+      return this.previousPayloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
     }
 
-    return this.payloadTimelinessCommittees[slot % SLOTS_PER_EPOCH];
+    throw new Error(`Payload Timeliness Committee is not available for slot=${slot}`);
   }
 
   getIndexedPayloadAttestation(
@@ -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/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,

package/src/lightClient/proofs.ts

@@ -0,0 +1,83 @@
+import {Tree} from "@chainsafe/persistent-merkle-tree";
+import {
+  BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX,
+  FINALIZED_ROOT_GINDEX,
+  FINALIZED_ROOT_GINDEX_ELECTRA,
+  ForkName,
+  ForkPostBellatrix,
+  isForkPostElectra,
+} from "@lodestar/params";
+import {BeaconBlockBody, SSZTypesFor, ssz} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks} from "../types.js";
+import {SyncCommitteeWitness} from "./types.js";
+
+export function getSyncCommitteesWitness(fork: ForkName, state: BeaconStateAllForks): SyncCommitteeWitness {
+  const n1 = state.node;
+  let witness: Uint8Array[];
+  let currentSyncCommitteeRoot: Uint8Array;
+  let nextSyncCommitteeRoot: Uint8Array;
+
+  if (isForkPostElectra(fork)) {
+    const n2 = n1.left;
+    const n5 = n2.right;
+    const n10 = n5.left;
+    const n21 = n10.right;
+    const n43 = n21.right;
+
+    currentSyncCommitteeRoot = n43.left.root; // n86
+    nextSyncCommitteeRoot = n43.right.root; // n87
+
+    // Witness branch is sorted by descending gindex
+    witness = [
+      n21.left.root, // 42
+      n10.left.root, // 20
+      n5.right.root, // 11
+      n2.left.root, // 4
+      n1.right.root, // 3
+    ];
+  } else {
+    const n3 = n1.right; // [1]0110
+    const n6 = n3.left; // 1[0]110
+    const n13 = n6.right; // 10[1]10
+    const n27 = n13.right; // 101[1]0
+    currentSyncCommitteeRoot = n27.left.root; // n54 1011[0]
+    nextSyncCommitteeRoot = n27.right.root; // n55 1011[1]
+
+    // Witness branch is sorted by descending gindex
+    witness = [
+      n13.left.root, // 26
+      n6.left.root, // 12
+      n3.right.root, // 7
+      n1.left.root, // 2
+    ];
+  }
+
+  return {
+    witness,
+    currentSyncCommitteeRoot,
+    nextSyncCommitteeRoot,
+  };
+}
+
+export function getNextSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  // Witness branch is sorted by descending gindex
+  return [syncCommitteesWitness.currentSyncCommitteeRoot, ...syncCommitteesWitness.witness];
+}
+
+export function getCurrentSyncCommitteeBranch(syncCommitteesWitness: SyncCommitteeWitness): Uint8Array[] {
+  // Witness branch is sorted by descending gindex
+  return [syncCommitteesWitness.nextSyncCommitteeRoot, ...syncCommitteesWitness.witness];
+}
+
+export function getFinalizedRootProof(state: CachedBeaconStateAllForks): Uint8Array[] {
+  const finalizedRootGindex = state.epochCtx.isPostElectra() ? FINALIZED_ROOT_GINDEX_ELECTRA : FINALIZED_ROOT_GINDEX;
+  return new Tree(state.node).getSingleProof(BigInt(finalizedRootGindex));
+}
+
+export function getBlockBodyExecutionHeaderProof(
+  fork: ForkPostBellatrix,
+  body: BeaconBlockBody<ForkPostBellatrix>
+): Uint8Array[] {
+  const bodyView = (ssz[fork].BeaconBlockBody as SSZTypesFor<ForkPostBellatrix, "BeaconBlockBody">).toView(body);
+  return new Tree(bodyView.node).getSingleProof(BigInt(BLOCK_BODY_EXECUTION_PAYLOAD_GINDEX));
+}

package/src/lightClient/types.ts

@@ -0,0 +1,33 @@
+/**
+ * We aren't creating the sync committee proofs separately because our ssz library automatically adds leaves to composite types,
+ * so they're already included in the state proof, currently with no way to specify otherwise
+ *
+ * remove two offsets so the # of offsets in the state proof will be the # expected
+ * This is a hack, but properly setting the offsets in the state proof would require either removing witnesses needed for the committees
+ * or setting the roots of the committees in the state proof
+ * this will always be 1, syncProofLeavesLength
+ *
+ *
+ * With empty state (minimal)
+ * - `genesisTime = 0xffffffff`
+ * - `genesisValidatorsRoot = Buffer.alloc(32, 1)`
+ *
+ * Proof:
+ * ```
+ * offsets: [ 5, 4, 3, 2, 1 ]
+ * leaves: [
+ *   '0xffffffff00000000000000000000000000000000000000000000000000000000',
+ *   '0x0101010101010101010101010101010101010101010101010101010101010101',
+ *   '0xb11b8bcf59425d6c99019cca1d2c2e47b51a2f74917a67ad132274f43e13ec43',
+ *   '0x74bd1f2437cdf74b0904ee525d8da070a3fa27570942bf42cbab3dc5939600f0',
+ *   '0x7f06739e5a42360c56e519a511675901c95402ea9877edc0d9a87471b1374a6a',
+ *   '0x9f534204ba3c0b69fcb42a11987bfcbc5aea0463e5b0614312ded4b62cf3a380'
+ * ]
+ * ```
+ */
+export type SyncCommitteeWitness = {
+  /** Vector[Bytes32, 4] or Vector[Bytes32, 5] depending on the fork */
+  witness: Uint8Array[];
+  currentSyncCommitteeRoot: Uint8Array;
+  nextSyncCommitteeRoot: Uint8Array;
+};

package/src/rewards/attestationsRewards.ts

@@ -1,4 +1,3 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
@@ -16,6 +15,7 @@ import {
 import {ValidatorIndex, rewards} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {EpochTransitionCache, beforeProcessEpoch} from "../cache/epochTransitionCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../types.js";
 import {
   FLAG_ELIGIBLE_ATTESTER,
@@ -34,7 +34,7 @@ const defaultAttestationsPenalty = {target: 0, source: 0};
 
 export async function computeAttestationsRewards(
   config: BeaconConfig,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   state: CachedBeaconStateAllForks,
   validatorIds?: (ValidatorIndex | string)[]
 ): Promise<rewards.AttestationsRewards> {
@@ -53,7 +53,7 @@ export async function computeAttestationsRewards(
   );
   const totalRewards = computeTotalAttestationsRewardsAltair(
     config,
-    pubkey2index,
+    pubkeyCache,
     stateAltair,
     transitionCache,
     idealRewards,
@@ -142,7 +142,7 @@ function computeIdealAttestationsRewardsAndPenaltiesAltair(
 // Same calculation as `getRewardsAndPenaltiesAltair` but returns the breakdown of rewards instead of aggregated
 function computeTotalAttestationsRewardsAltair(
   config: BeaconConfig,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   state: CachedBeaconStateAltair,
   transitionCache: EpochTransitionCache,
   idealRewards: rewards.IdealAttestationsReward[],
@@ -153,7 +153,7 @@ function computeTotalAttestationsRewardsAltair(
   const {flags} = transitionCache;
   const {epochCtx} = state;
   const validatorIndices = validatorIds
-    .map((id) => (typeof id === "number" ? id : pubkey2index.get(fromHex(id))))
+    .map((id) => (typeof id === "number" ? id : pubkeyCache.getIndex(fromHex(id))))
     .filter((index) => index !== undefined); // Validator indices to include in the result
 
   const inactivityPenaltyDenominator = config.INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR;

package/src/rewards/syncCommitteeRewards.ts

@@ -1,12 +1,12 @@
 import {BeaconConfig} from "@lodestar/config";
 import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
 
 export async function computeSyncCommitteeRewards(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   block: BeaconBlock,
   preState: CachedBeaconStateAllForks,
   validatorIds: (ValidatorIndex | string)[] = []
@@ -47,9 +47,10 @@ export async function computeSyncCommitteeRewards(
 
   if (validatorIds.length) {
     const filtersSet = new Set(validatorIds);
-    return rewards.filter(
-      (reward) => filtersSet.has(reward.validatorIndex) || filtersSet.has(index2pubkey[reward.validatorIndex].toHex())
-    );
+    return rewards.filter((reward) => {
+      const pubkeyHex = pubkeyCache.get(reward.validatorIndex)?.toHex();
+      return filtersSet.has(reward.validatorIndex) || (pubkeyHex !== undefined && filtersSet.has(pubkeyHex));
+    });
   }
 
   return rewards;

package/src/signatureSets/proposer.ts

@@ -1,17 +1,17 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {computeSigningRoot} from "../util/index.js";
 import {ISignatureSet, SignatureSetType, verifySignatureSet} from "../util/signatureSets.js";
 
 export function verifyProposerSignature(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
   const signatureSet = getBlockProposerSignatureSet(config, signedBlock);
-  return verifySignatureSet(signatureSet, index2pubkey);
+  return verifySignatureSet(signatureSet, pubkeyCache);
 }
 
 export function getBlockProposerSignatureSet(

package/src/signatureSets/randao.ts

@@ -1,7 +1,7 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_RANDAO} from "@lodestar/params";
 import {BeaconBlock, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {
   ISignatureSet,
   SignatureSetType,
@@ -10,12 +10,8 @@ import {
   verifySignatureSet,
 } from "../util/index.js";
 
-export function verifyRandaoSignature(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  block: BeaconBlock
-): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), index2pubkey);
+export function verifyRandaoSignature(config: BeaconConfig, pubkeyCache: PubkeyCache, block: BeaconBlock): boolean {
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), pubkeyCache);
 }
 
 /**