@lodestar/beacon-node 1.41.0-dev.2074a31ba7 → 1.41.0-dev.20f622cc52

package/src/chain/archiveStore/historicalState/getHistoricalState.ts

@@ -1,10 +1,10 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {BeaconConfig} from "@lodestar/config";
 import {
   BeaconStateAllForks,
   CachedBeaconStateAllForks,
   DataAvailabilityStatus,
   ExecutionPayloadStatus,
+  PubkeyCache,
   createCachedBeaconState,
   stateTransition,
 } from "@lodestar/state-transition";
@@ -15,16 +15,16 @@ import {HistoricalStateRegenMetrics} from "./metrics.js";
 import {RegenErrorType} from "./types.js";
 
 /**
- * Populate a PubkeyIndexMap with any new entries based on a BeaconState
+ * Populate a PubkeyCache with any new entries based on a BeaconState
  */
-export function syncPubkeyCache(state: BeaconStateAllForks, pubkey2index: PubkeyIndexMap): void {
+export function syncPubkeyCache(state: BeaconStateAllForks, pubkeyCache: PubkeyCache): void {
   // Get the validators sub tree once for all the loop
   const validators = state.validators;
 
   const newCount = state.validators.length;
-  for (let i = pubkey2index.size; i < newCount; i++) {
+  for (let i = pubkeyCache.size; i < newCount; i++) {
     const pubkey = validators.getReadonly(i).pubkey;
-    pubkey2index.set(pubkey, i);
+    pubkeyCache.set(i, pubkey);
   }
 }
 
@@ -35,7 +35,7 @@ export async function getNearestState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: PubkeyCache
 ): Promise<CachedBeaconStateAllForks> {
   const stateBytesArr = await db.stateArchive.binaries({limit: 1, lte: slot, reverse: true});
   if (!stateBytesArr.length) {
@@ -44,14 +44,13 @@ export async function getNearestState(
 
   const stateBytes = stateBytesArr[0];
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
-  syncPubkeyCache(state, pubkey2index);
+  syncPubkeyCache(state, pubkeyCache);
 
   return createCachedBeaconState(
     state,
     {
       config,
-      pubkey2index,
-      index2pubkey: [],
+      pubkeyCache,
     },
     {
       skipSyncPubkeys: true,
@@ -66,13 +65,13 @@ export async function getHistoricalState(
   slot: number,
   config: BeaconConfig,
   db: IBeaconDb,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   metrics?: HistoricalStateRegenMetrics
 ): Promise<Uint8Array> {
   const regenTimer = metrics?.regenTime.startTimer();
 
   const loadStateTimer = metrics?.loadStateTime.startTimer();
-  let state = await getNearestState(slot, config, db, pubkey2index).catch((e) => {
+  let state = await getNearestState(slot, config, db, pubkeyCache).catch((e) => {
     metrics?.regenErrorCount.inc({reason: RegenErrorType.loadState});
     throw e;
   });

package/src/chain/archiveStore/historicalState/worker.ts

@@ -1,9 +1,9 @@
 import worker from "node:worker_threads";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {Transfer, expose} from "@chainsafe/threads/worker";
 import {chainConfigFromJson, createBeaconConfig} from "@lodestar/config";
 import {LevelDbController} from "@lodestar/db/controller/level";
 import {getNodeLogger} from "@lodestar/logger/node";
+import {createPubkeyCache} from "@lodestar/state-transition";
 import {BeaconDb} from "../../../db/index.js";
 import {RegistryMetricCreator, collectNodeJSMetrics} from "../../../metrics/index.js";
 import {JobFnQueue} from "../../../util/queue/fnQueue.js";
@@ -52,7 +52,7 @@ const queue = new JobFnQueue(
   queueMetrics
 );
 
-const pubkey2index = new PubkeyIndexMap();
+const pubkeyCache = createPubkeyCache();
 
 const api: HistoricalStateWorkerApi = {
   async close() {
@@ -65,7 +65,7 @@ const api: HistoricalStateWorkerApi = {
     historicalStateRegenMetrics?.regenRequestCount.inc();
 
     const stateBytes = await queue.push<Uint8Array>(() =>
-      getHistoricalState(slot, config, db, pubkey2index, historicalStateRegenMetrics)
+      getHistoricalState(slot, config, db, pubkeyCache, historicalStateRegenMetrics)
     );
     const result = Transfer(stateBytes, [stateBytes.buffer]) as unknown as Uint8Array;
 

package/src/chain/archiveStore/utils/archivePayloads.ts

@@ -0,0 +1,15 @@
+import {CheckpointWithHex} from "@lodestar/fork-choice";
+import {IBeaconChain} from "../../interface.js";
+
+/**
+ * Archives execution payload envelopes from hot DB to archive DB after finalization.
+ */
+export async function archiveExecutionPayloadEnvelopes(
+  chain: IBeaconChain,
+  _finalized: CheckpointWithHex
+): Promise<void> {
+  const finalizedBlock = chain.forkChoice.getFinalizedBlock();
+  if (!finalizedBlock) return;
+
+  // TODO GLOAS: Implement payload envelope archival after epbs fork choice changes are merged
+}

package/src/chain/archiveStore/utils/updateBackfillRange.ts

@@ -20,7 +20,7 @@ export async function updateBackfillRange(
   try {
     // Mark the sequence in backfill db from finalized block's slot till anchor slot as
     // filled.
-    const finalizedBlockFC = chain.forkChoice.getBlockHex(finalized.rootHex);
+    const finalizedBlockFC = chain.forkChoice.getBlockHexDefaultStatus(finalized.rootHex);
     if (finalizedBlockFC && finalizedBlockFC.slot > chain.anchorStateLatestBlockSlot) {
       await db.backfilledRanges.put(finalizedBlockFC.slot, chain.anchorStateLatestBlockSlot);
 

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

@@ -1,5 +1,5 @@
-import {ForkName, ForkPostFulu, ForkPreDeneb, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
-import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu} from "@lodestar/types";
+import {ForkName, ForkPostFulu, ForkPostGloas, ForkPreDeneb, ForkPreGloas, NUMBER_OF_COLUMNS} from "@lodestar/params";
+import {BeaconBlockBody, BlobIndex, ColumnIndex, SignedBeaconBlock, Slot, deneb, fulu, gloas} from "@lodestar/types";
 import {byteArrayEquals, fromHex, prettyBytes, toRootHex, withTimeout} from "@lodestar/utils";
 import {VersionedHashes} from "../../../execution/index.js";
 import {kzgCommitmentToVersionedHash} from "../../../util/blobs.js";
@@ -24,7 +24,7 @@ import {
   SourceMeta,
 } from "./types.js";
 
-export type BlockInput = BlockInputPreData | BlockInputBlobs | BlockInputColumns;
+export type BlockInput = BlockInputPreData | BlockInputBlobs | BlockInputColumns | BlockInputNoData;
 
 export function isBlockInputPreDeneb(blockInput: IBlockInput): blockInput is BlockInputPreData {
   return blockInput.type === DAType.PreData;
@@ -37,6 +37,10 @@ export function isBlockInputColumns(blockInput: IBlockInput): blockInput is Bloc
   return blockInput.type === DAType.Columns;
 }
 
+export function isBlockInputNoData(blockInput: IBlockInput): blockInput is BlockInputNoData {
+  return blockInput.type === DAType.NoData;
+}
+
 function createPromise<T>(): PromiseParts<T> {
   let resolve!: (value: T) => void;
   let reject!: (e: Error) => void;
@@ -903,3 +907,64 @@ export class BlockInputColumns extends AbstractBlockInput<ForkColumnsDA, fulu.Da
     return Promise.resolve(this.getSampledColumns());
   }
 }
+
+type BlockInputNoDataState = {
+  hasBlock: true;
+  hasAllData: true;
+  block: SignedBeaconBlock<ForkPostGloas>;
+  source: SourceMeta;
+  timeCompleteSec: number;
+};
+
+export class BlockInputNoData extends AbstractBlockInput<ForkPostGloas, null> {
+  type = DAType.NoData as const;
+
+  state: BlockInputNoDataState;
+
+  private constructor(init: BlockInputInit, state: BlockInputNoDataState) {
+    super(init);
+    this.state = state;
+    this.dataPromise.resolve(null);
+    this.blockPromise.resolve(state.block);
+  }
+
+  static createFromBlock(props: AddBlock<ForkPostGloas> & CreateBlockInputMeta): BlockInputNoData {
+    const init: BlockInputInit = {
+      daOutOfRange: props.daOutOfRange,
+      timeCreated: props.seenTimestampSec,
+      forkName: props.forkName,
+      slot: props.block.message.slot,
+      blockRootHex: props.blockRootHex,
+      parentRootHex: toRootHex(props.block.message.parentRoot),
+    };
+    const state: BlockInputNoDataState = {
+      hasBlock: true,
+      hasAllData: true,
+      block: props.block,
+      source: {
+        source: props.source,
+        seenTimestampSec: props.seenTimestampSec,
+        peerIdStr: props.peerIdStr,
+      },
+      timeCompleteSec: props.seenTimestampSec,
+    };
+    return new BlockInputNoData(init, state);
+  }
+
+  addBlock(_: AddBlock<ForkPostGloas>, opts = {throwOnDuplicateAdd: true}): void {
+    if (opts.throwOnDuplicateAdd) {
+      throw new BlockInputError(
+        {
+          code: BlockInputErrorCode.INVALID_CONSTRUCTION,
+          blockRoot: this.blockRootHex,
+        },
+        "Cannot addBlock to BlockInputNoData - block already exists"
+      );
+    }
+  }
+
+  getBlobKzgCommitments(): deneb.BlobKzgCommitments {
+    return (this.state.block.message.body as gloas.BeaconBlockBody).signedExecutionPayloadBid.message
+      .blobKzgCommitments;
+  }
+}

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

@@ -6,6 +6,7 @@ export enum DAType {
   PreData = "pre-data",
   Blobs = "blobs",
   Columns = "columns",
+  NoData = "no-data",
 }
 
 export type DAData = null | deneb.BlobSidecars | fulu.DataColumnSidecars;

package/src/chain/blocks/importBlock.ts

@@ -20,7 +20,7 @@ import {
   isStartSlotOfEpoch,
   isStateValidatorsNodesPopulated,
 } from "@lodestar/state-transition";
-import {Attestation, BeaconBlock, altair, capella, electra, phase0, ssz} from "@lodestar/types";
+import {Attestation, BeaconBlock, altair, capella, electra, isGloasBeaconBlock, phase0, ssz} from "@lodestar/types";
 import {isErrorAborted, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH_HEX} from "../../constants/index.js";
 import {callInNextEventLoop} from "../../util/eventLoop.js";
@@ -230,6 +230,32 @@ export async function importBlock(
     }
   }
 
+  // 4.5. Import payload attestations to fork choice (Gloas)
+  //
+  if (isGloasBeaconBlock(block.message)) {
+    for (const payloadAttestation of block.message.body.payloadAttestations) {
+      try {
+        // Extract PTC indices from aggregation bits
+        const ptcIndices: number[] = [];
+        for (let i = 0; i < payloadAttestation.aggregationBits.bitLen; i++) {
+          if (payloadAttestation.aggregationBits.get(i)) {
+            ptcIndices.push(i);
+          }
+        }
+
+        if (ptcIndices.length > 0) {
+          this.forkChoice.notifyPtcMessages(
+            toRootHex(payloadAttestation.data.beaconBlockRoot),
+            ptcIndices,
+            payloadAttestation.data.payloadPresent
+          );
+        }
+      } catch (e) {
+        this.logger.warn("Error processing PayloadAttestation from block", {slot: blockSlot}, e as Error);
+      }
+    }
+  }
+
   // 5. Compute head. If new head, immediately stateCache.setHeadState()
 
   const oldHead = this.forkChoice.getHead();
@@ -345,7 +371,7 @@ export async function importBlock(
         //  3) Proposer boost reorg related flag is turned on (this is checked inside the function)
         //  4) Block meets the criteria of being re-orged out (this is also checked inside the function)
         const result = this.forkChoice.shouldOverrideForkChoiceUpdate(
-          blockSummary.blockRoot,
+          blockSummary,
           this.clock.secFromSlot(currentSlot),
           currentSlot
         );
@@ -441,7 +467,12 @@ export async function importBlock(
     this.metrics?.currentActiveValidators.set(activeValidatorsCount);
     this.metrics?.currentValidators.set({status: "active"}, activeValidatorsCount);
 
-    const parentBlockSummary = this.forkChoice.getBlock(checkpointState.latestBlockHeader.parentRoot);
+    const parentBlockSummary = isGloasBeaconBlock(block.message)
+      ? this.forkChoice.getBlockHexAndBlockHash(
+          toRootHex(checkpointState.latestBlockHeader.parentRoot),
+          toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
+        )
+      : this.forkChoice.getBlockDefaultStatus(checkpointState.latestBlockHeader.parentRoot);
 
     if (parentBlockSummary) {
       const justifiedCheckpoint = checkpointState.currentJustifiedCheckpoint;

package/src/chain/blocks/verifyBlocksDataAvailability.ts

@@ -29,6 +29,9 @@ export async function verifyBlocksDataAvailability(
 
   const availableTime = Math.max(0, Math.max(...blocks.map((blockInput) => blockInput.getTimeComplete())));
   const dataAvailabilityStatuses: DataAvailabilityStatus[] = blocks.map((blockInput) => {
+    if (blockInput.type === DAType.NoData) {
+      return DataAvailabilityStatus.NotRequired;
+    }
     if (blockInput.type === DAType.PreData) {
       return DataAvailabilityStatus.PreData;
     }

package/src/chain/blocks/verifyBlocksExecutionPayloads.ts

@@ -21,7 +21,7 @@ import {Metrics} from "../../metrics/metrics.js";
 import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
 import {BlockProcessOpts} from "../options.js";
-import {isBlockInputBlobs, isBlockInputColumns} from "./blockInput/blockInput.js";
+import {isBlockInputBlobs, isBlockInputColumns, isBlockInputNoData} from "./blockInput/blockInput.js";
 import {IBlockInput} from "./blockInput/types.js";
 import {ImportBlockOpts} from "./types.js";
 
@@ -51,7 +51,8 @@ type VerifyBlockExecutionResponse =
   | VerifyExecutionErrorResponse
   | {executionStatus: ExecutionStatus.Valid; lvhResponse: LVHValidResponse; execError: null}
   | {executionStatus: ExecutionStatus.Syncing; lvhResponse?: LVHValidResponse; execError: null}
-  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null};
+  | {executionStatus: ExecutionStatus.PreMerge; lvhResponse: undefined; execError: null}
+  | {executionStatus: ExecutionStatus.PayloadSeparated; lvhResponse: undefined; execError: null};
 
 /**
  * Verifies 1 or more execution payloads from a linear sequence of blocks.
@@ -148,6 +149,12 @@ export async function verifyBlockExecutionPayload(
   preState0: CachedBeaconStateAllForks
 ): Promise<VerifyBlockExecutionResponse> {
   const block = blockInput.getBlock();
+
+  // Gloas block doesn't have execution payload. Return right away
+  if (isBlockInputNoData(blockInput)) {
+    return {executionStatus: ExecutionStatus.PayloadSeparated, lvhResponse: undefined, execError: null};
+  }
+
   /** Not null if execution is enabled */
   const executionPayloadEnabled =
     isExecutionStateType(preState0) &&

package/src/chain/blocks/verifyBlocksSanityChecks.ts

@@ -1,7 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {IForkChoice, ProtoBlock} from "@lodestar/fork-choice";
 import {computeStartSlotAtEpoch} from "@lodestar/state-transition";
-import {RootHex, Slot} from "@lodestar/types";
+import {RootHex, Slot, isGloasBeaconBlock} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
 import {BlockError, BlockErrorCode} from "../errors/index.js";
@@ -90,7 +90,12 @@ export function verifyBlocksSanityChecks(
     } else {
       // When importing a block segment, only the first NON-IGNORED block must be known to the fork-choice.
       const parentRoot = toRootHex(block.message.parentRoot);
-      parentBlock = chain.forkChoice.getBlockHex(parentRoot);
+      parentBlock = isGloasBeaconBlock(block.message)
+        ? chain.forkChoice.getBlockHexAndBlockHash(
+            parentRoot,
+            toRootHex(block.message.body.signedExecutionPayloadBid.message.parentBlockHash)
+          )
+        : chain.forkChoice.getBlockHexDefaultStatus(parentRoot);
       if (!parentBlock) {
         throw new BlockError(block, {code: BlockErrorCode.PARENT_UNKNOWN, parentRoot});
       }

package/src/chain/bls/multithread/index.ts

@@ -7,7 +7,7 @@ import {Worker, spawn} from "@chainsafe/threads";
 self = undefined;
 
 import {PublicKey} from "@chainsafe/blst";
-import {ISignatureSet, Index2PubkeyCache} from "@lodestar/state-transition";
+import {ISignatureSet, PubkeyCache} from "@lodestar/state-transition";
 import {Logger} from "@lodestar/utils";
 import {Metrics} from "../../../metrics/index.js";
 import {LinkedList} from "../../../util/array.js";
@@ -34,7 +34,7 @@ const workerDir = process.env.NODE_ENV === "test" ? "../../../../lib/chain/bls/m
 export type BlsMultiThreadWorkerPoolModules = {
   logger: Logger;
   metrics: Metrics | null;
-  index2pubkey: Index2PubkeyCache;
+  pubkeyCache: PubkeyCache;
 };
 
 export type BlsMultiThreadWorkerPoolOptions = {
@@ -114,7 +114,7 @@ type WorkerDescriptor = {
 export class BlsMultiThreadWorkerPool implements IBlsVerifier {
   private readonly logger: Logger;
   private readonly metrics: Metrics | null;
-  private readonly index2pubkey: Index2PubkeyCache;
+  private readonly pubkeyCache: PubkeyCache;
 
   private readonly workers: WorkerDescriptor[];
   private readonly jobs = new LinkedList<JobQueueItem>();
@@ -130,10 +130,10 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
   private workersBusy = 0;
 
   constructor(options: BlsMultiThreadWorkerPoolOptions, modules: BlsMultiThreadWorkerPoolModules) {
-    const {logger, metrics, index2pubkey} = modules;
+    const {logger, metrics, pubkeyCache} = modules;
     this.logger = logger;
     this.metrics = metrics;
-    this.index2pubkey = index2pubkey;
+    this.pubkeyCache = pubkeyCache;
     this.blsVerifyAllMultiThread = options.blsVerifyAllMultiThread ?? false;
 
     // Use compressed for herumi for now.
@@ -173,7 +173,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
       try {
         return verifySignatureSetsMaybeBatch(
           sets.map((set) => ({
-            publicKey: getAggregatedPubkey(set, this.index2pubkey),
+            publicKey: getAggregatedPubkey(set, this.pubkeyCache),
             message: set.signingRoot.valueOf(),
             signature: set.signature,
           }))
@@ -398,7 +398,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
         try {
           // Note: This can throw, must be handled per-job.
           // Pubkey and signature aggregation is defered here
-          workReq = await jobItemWorkReq(job, this.index2pubkey, this.metrics);
+          workReq = await jobItemWorkReq(job, this.pubkeyCache, this.metrics);
         } catch (e) {
           this.metrics?.blsThreadPool.errorAggregateSignatureSetsCount.inc({type: job.type});
 

package/src/chain/bls/multithread/jobItem.ts

@@ -1,5 +1,5 @@
 import {PublicKey, asyncAggregateWithRandomness} from "@chainsafe/blst";
-import {ISignatureSet, Index2PubkeyCache, SignatureSetType} from "@lodestar/state-transition";
+import {ISignatureSet, PubkeyCache, SignatureSetType} from "@lodestar/state-transition";
 import {Metrics} from "../../../metrics/metrics.js";
 import {LinkedList} from "../../../util/array.js";
 import {VerifySignatureOpts} from "../interface.js";
@@ -50,7 +50,7 @@ export function jobItemSigSets(job: JobQueueItem): number {
  */
 export async function jobItemWorkReq(
   job: JobQueueItem,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   metrics: Metrics | null
 ): Promise<BlsWorkReq> {
   switch (job.type) {
@@ -59,7 +59,7 @@ export async function jobItemWorkReq(
         opts: job.opts,
         sets: job.sets.map((set) => ({
           // this can throw, handled in the consumer code
-          publicKey: getAggregatedPubkey(set, index2pubkey, metrics).toBytes(),
+          publicKey: getAggregatedPubkey(set, pubkeyCache, metrics).toBytes(),
           signature: set.signature,
           message: set.signingRoot,
         })),

package/src/chain/bls/singleThread.ts

@@ -1,5 +1,5 @@
 import {PublicKey, Signature, aggregatePublicKeys, aggregateSignatures, verify} from "@chainsafe/blst";
-import {ISignatureSet, Index2PubkeyCache} from "@lodestar/state-transition";
+import {ISignatureSet, PubkeyCache} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/index.js";
 import {IBlsVerifier} from "./interface.js";
 import {verifySignatureSetsMaybeBatch} from "./maybeBatch.js";
@@ -7,18 +7,18 @@ import {getAggregatedPubkey, getAggregatedPubkeysCount} from "./utils.js";
 
 export class BlsSingleThreadVerifier implements IBlsVerifier {
   private readonly metrics: Metrics | null;
-  private readonly index2pubkey: Index2PubkeyCache;
+  private readonly pubkeyCache: PubkeyCache;
 
-  constructor({metrics = null, index2pubkey}: {metrics: Metrics | null; index2pubkey: Index2PubkeyCache}) {
+  constructor({metrics = null, pubkeyCache}: {metrics: Metrics | null; pubkeyCache: PubkeyCache}) {
     this.metrics = metrics;
-    this.index2pubkey = index2pubkey;
+    this.pubkeyCache = pubkeyCache;
   }
 
   async verifySignatureSets(sets: ISignatureSet[]): Promise<boolean> {
     this.metrics?.bls.aggregatedPubkeys.inc(getAggregatedPubkeysCount(sets));
 
     const setsAggregated = sets.map((set) => ({
-      publicKey: getAggregatedPubkey(set, this.index2pubkey, this.metrics),
+      publicKey: getAggregatedPubkey(set, this.pubkeyCache, this.metrics),
       message: set.signingRoot,
       signature: set.signature,
     }));

package/src/chain/bls/utils.ts

@@ -1,22 +1,25 @@
 import {PublicKey, aggregatePublicKeys} from "@chainsafe/blst";
-import {ISignatureSet, Index2PubkeyCache, SignatureSetType} from "@lodestar/state-transition";
+import {ISignatureSet, PubkeyCache, SignatureSetType} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/metrics.js";
 
 export function getAggregatedPubkey(
   signatureSet: ISignatureSet,
-  index2pubkey: Index2PubkeyCache,
+  pubkeyCache: PubkeyCache,
   metrics: Metrics | null = null
 ): PublicKey {
   switch (signatureSet.type) {
     case SignatureSetType.single:
       return signatureSet.pubkey;
 
-    case SignatureSetType.indexed:
-      return index2pubkey[signatureSet.index];
+    case SignatureSetType.indexed: {
+      return pubkeyCache.getOrThrow(signatureSet.index);
+    }
 
     case SignatureSetType.aggregate: {
       const timer = metrics?.blsThreadPool.pubkeysAggregationMainThreadDuration.startTimer();
-      const pubkeys = signatureSet.indices.map((i) => index2pubkey[i]);
+      const pubkeys = signatureSet.indices.map((i) => {
+        return pubkeyCache.getOrThrow(i);
+      });
       const aggregated = aggregatePublicKeys(pubkeys);
       timer?.();
       return aggregated;