@lodestar/state-transition 1.47.0-dev.a64cdf7144 → 1.47.0-dev.aa6eaee53a

package/src/block/processAttesterSlashing.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
 import {AttesterSlashing, Slot} from "@lodestar/types";
-import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
 import {isValidIndexedAttestationBigint} from "./isValidIndexedAttestation.js";
@@ -20,14 +19,7 @@ export function processAttesterSlashing(
   verifySignatures = true
 ): void {
   const {epochCtx} = state;
-  assertValidAttesterSlashing(
-    state.config,
-    epochCtx.pubkeyCache,
-    state.slot,
-    state.validators.length,
-    attesterSlashing,
-    verifySignatures
-  );
+  assertValidAttesterSlashing(state.config, state.slot, state.validators.length, attesterSlashing, verifySignatures);
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -48,7 +40,6 @@ export function processAttesterSlashing(
 
 export function assertValidAttesterSlashing(
   config: BeaconConfig,
-  pubkeyCache: PubkeyCache,
   stateSlot: Slot,
   validatorsLen: number,
   attesterSlashing: AttesterSlashing,
@@ -65,9 +56,7 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (
-      !isValidIndexedAttestationBigint(config, pubkeyCache, stateSlot, validatorsLen, attestation, verifySignatures)
-    ) {
+    if (!isValidIndexedAttestationBigint(config, stateSlot, validatorsLen, attestation, verifySignatures)) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

package/src/block/processDeposit.ts

@@ -1,4 +1,9 @@
-import {PublicKey, Signature, verify, verifyMultipleAggregateSignatures} from "@chainsafe/blst";
+import {
+  BLS_VERIFIER_MAX_BATCH_SIZE,
+  BLS_VERIFIER_SET_TYPE,
+  type BlsSignatureSet,
+  verifySignatureSets,
+} from "@chainsafe/lodestar-z/bls-verifier";
 import {BeaconConfig} from "@lodestar/config";
 import {
   DEPOSIT_CONTRACT_TREE_DEPTH,
@@ -13,7 +18,14 @@ import {BLSPubkey, Bytes32, UintNum64, electra, phase0, ssz} from "@lodestar/typ
 import {verifyMerkleBranch} from "@lodestar/utils";
 import {ZERO_HASH} from "../constants/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair, CachedBeaconStateElectra} from "../types.js";
-import {computeDomain, computeSigningRoot, getMaxEffectiveBalance, increaseBalance} from "../util/index.js";
+import {
+  computeDomain,
+  computeSigningRoot,
+  createSingleSignatureSetFromComponents,
+  getMaxEffectiveBalance,
+  increaseBalance,
+  verifySignatureSet,
+} from "../util/index.js";
 
 /**
  * Process a Deposit operation. Potentially adds a new validator to the registry. Mutates the validators and balances
@@ -159,11 +171,7 @@ export function isValidDepositSignature(
   const domain = computeDomain(DOMAIN_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
   const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, depositMessage, domain);
   try {
-    // Pubkeys must be checked for group + inf. This must be done only once when the validator deposit is processed
-    const publicKey = PublicKey.fromBytes(pubkey, true);
-    const signature = Signature.fromBytes(depositSignature, true);
-
-    return verify(signingRoot, publicKey, signature);
+    return verifySignatureSet(createSingleSignatureSetFromComponents(pubkey, signingRoot, depositSignature));
   } catch (_e) {
     return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
   }
@@ -184,54 +192,34 @@ export function verifyDepositSignatures(config: BeaconConfig, deposits: electra.
   // fork-agnostic domain since deposits are valid across forks, matching isValidDepositSignature
   const domain = computeDomain(DOMAIN_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
 
-  const signatureSets: {pk: PublicKey; msg: Uint8Array; sig: Signature}[] = [];
-  const signatureSetDepositIndices: number[] = [];
-  for (let i = 0; i < deposits.length; i++) {
-    const {pubkey, withdrawalCredentials, amount, signature} = deposits[i];
-    let pk: PublicKey;
-    let sig: Signature;
+  const signatureSets: BlsSignatureSet[] = deposits.map(({pubkey, withdrawalCredentials, amount, signature}) => ({
+    type: BLS_VERIFIER_SET_TYPE.single,
+    pubkey,
+    message: computeSigningRoot(ssz.phase0.DepositMessage, {pubkey, withdrawalCredentials, amount}, domain),
+    signature,
+  }));
+
+  for (let chunkStart = 0; chunkStart < signatureSets.length; chunkStart += BLS_VERIFIER_MAX_BATCH_SIZE) {
+    const chunk = signatureSets.slice(chunkStart, chunkStart + BLS_VERIFIER_MAX_BATCH_SIZE);
+    let chunkValid: boolean;
     try {
-      // Parse without group/infinity checks; deferred to the verify call below so it can be
-      // batched across all sets.
-      pk = PublicKey.fromBytes(pubkey);
-      sig = Signature.fromBytes(signature);
+      chunkValid = verifySignatureSets(chunk);
     } catch (_) {
-      // Malformed pubkey or signature bytes - invalid deposit, results[i] stays false
-      continue;
+      chunkValid = false;
     }
-    const msg = computeSigningRoot(ssz.phase0.DepositMessage, {pubkey, withdrawalCredentials, amount}, domain);
-    signatureSets.push({pk, msg, sig});
-    signatureSetDepositIndices.push(i);
-  }
 
-  if (signatureSets.length === 0) {
-    return results;
-  }
-
-  // Deposit pubkeys and signatures are untrusted, so group + infinity checks are required.
-  // The trailing (true, true) args delegate those checks to blst, amortized across the batch.
-  let batchValid: boolean;
-  try {
-    batchValid =
-      signatureSets.length >= 2
-        ? verifyMultipleAggregateSignatures(signatureSets, true, true)
-        : verify(signatureSets[0].msg, signatureSets[0].pk, signatureSets[0].sig, true, true);
-  } catch (_) {
-    batchValid = false;
-  }
-
-  if (batchValid) {
-    for (const depositIndex of signatureSetDepositIndices) {
-      results[depositIndex] = true;
+    if (chunkValid) {
+      results.fill(true, chunkStart, chunkStart + chunk.length);
+      continue;
     }
-  } else {
-    for (let s = 0; s < signatureSets.length; s++) {
+
+    for (let i = 0; i < chunk.length; i++) {
       try {
-        if (verify(signatureSets[s].msg, signatureSets[s].pk, signatureSets[s].sig, true, true)) {
-          results[signatureSetDepositIndices[s]] = true;
+        if (verifySignatureSets([chunk[i]])) {
+          results[chunkStart + i] = true;
         }
       } catch (_) {
-        // invalid point / malformed → invalid signature, results[i] stays false
+        // Invalid point or malformed bytes leave this deposit false.
       }
     }
   }

package/src/block/processExecutionPayloadBid.ts

@@ -1,4 +1,3 @@
-import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {
   BUILDER_INDEX_SELF_BUILD,
   ForkSeq,
@@ -12,7 +11,13 @@ import {G2_POINT_AT_INFINITY} from "../constants/constants.js";
 import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
 import {CachedBeaconStateGloas, CachedBeaconStateHeze} from "../types.js";
 import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.js";
-import {getBlockRootAtSlot, getCurrentEpoch, getRandaoMix} from "../util/index.js";
+import {
+  createSingleSignatureSetFromComponents,
+  getBlockRootAtSlot,
+  getCurrentEpoch,
+  getRandaoMix,
+  verifySignatureSet,
+} from "../util/index.js";
 
 export function processExecutionPayloadBid(
   state: CachedBeaconStateGloas | CachedBeaconStateHeze,
@@ -123,10 +128,7 @@ function verifyExecutionPayloadBidSignature(
   const signingRoot = getExecutionPayloadBidSigningRoot(state.config, signedBid.message);
 
   try {
-    const publicKey = PublicKey.fromBytes(pubkey);
-    const signature = Signature.fromBytes(signedBid.signature, true);
-
-    return verify(signingRoot, publicKey, signature);
+    return verifySignatureSet(createSingleSignatureSetFromComponents(pubkey, signingRoot, signedBid.signature));
   } catch (_e) {
     return false; // Catch all BLS errors: failed key validation, failed signature validation, invalid signature
   }

package/src/block/processProposerSlashing.ts

@@ -2,7 +2,6 @@ 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 {PubkeyCache} from "../cache/pubkeyCache.js";
 import {getProposerSlashingSignatureSets} from "../signatureSets/index.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateGloas} from "../types.js";
 import {computeEpochAtSlot, isSlashableValidator} from "../util/index.js";
@@ -22,14 +21,7 @@ export function processProposerSlashing(
   verifySignatures = true
 ): void {
   const proposer = state.validators.getReadonly(proposerSlashing.signedHeader1.message.proposerIndex);
-  assertValidProposerSlashing(
-    state.config,
-    state.epochCtx.pubkeyCache,
-    state.slot,
-    proposerSlashing,
-    proposer,
-    verifySignatures
-  );
+  assertValidProposerSlashing(state.config, state.slot, proposerSlashing, proposer, verifySignatures);
 
   if (fork >= ForkSeq.gloas) {
     // Remove the BuilderPendingPayment corresponding to this proposal if it is still in the
@@ -62,7 +54,6 @@ export function processProposerSlashing(
 
 export function assertValidProposerSlashing(
   config: BeaconConfig,
-  pubkeyCache: PubkeyCache,
   stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing,
   proposer: Validator,
@@ -99,7 +90,7 @@ export function assertValidProposerSlashing(
   if (verifySignatures) {
     const signatureSets = getProposerSlashingSignatureSets(config, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
-      if (!verifySignatureSet(signatureSets[i], pubkeyCache)) {
+      if (!verifySignatureSet(signatureSets[i])) {
         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.pubkeyCache, block)) {
+  if (verifySignature && !verifyRandaoSignature(config, 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.pubkeyCache)) {
+    if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
       throw Error("Sync committee signature invalid");
     }
   }

package/src/block/processVoluntaryExit.ts

@@ -93,10 +93,7 @@ function getValidatorVoluntaryExitValidity(
   }
 
   // Verify signature
-  if (
-    verifySignature &&
-    !verifyVoluntaryExitSignature(config, epochCtx.pubkeyCache, new BeaconStateView(state), signedVoluntaryExit)
-  ) {
+  if (verifySignature && !verifyVoluntaryExitSignature(config, new BeaconStateView(state), signedVoluntaryExit)) {
     return VoluntaryExitValidity.invalidSignature;
   }
 

package/src/cache/epochCache.ts

@@ -1,4 +1,5 @@
-import {PublicKey} from "@chainsafe/blst";
+import {PublicKey} from "@chainsafe/lodestar-z/blst";
+import {type PubkeyCache, pubkeyCache as defaultPubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig, ChainConfig, createBeaconConfig} from "@lodestar/config";
 import {
   ATTESTATION_SUBNET_COUNT,
@@ -56,7 +57,6 @@ import {sumTargetUnslashedBalanceIncrements} from "../util/targetUnslashedBalanc
 import {BuilderDepositSignatureCache} from "./builderDepositSignatureCache.js";
 import {EffectiveBalanceIncrements, getEffectiveBalanceIncrementsWithLen} from "./effectiveBalanceIncrements.js";
 import {EpochTransitionCache} from "./epochTransitionCache.js";
-import {PubkeyCache, createPubkeyCache, syncPubkeys} from "./pubkeyCache.js";
 import {CachedBeaconStateAllForks, CachedBeaconStateFulu, CachedBeaconStateGloas} from "./stateCache.js";
 import {
   SyncCommitteeCache,
@@ -341,10 +341,10 @@ export class EpochCache {
     const validators = state.validators.getAllReadonlyValues();
     const validatorCount = validators.length;
 
-    // syncPubkeys here to ensure EpochCacheImmutableData is popualted before computing the rest of caches
+    // syncPubkeys here to ensure EpochCacheImmutableData is populated before computing the rest of caches
     // - computeSyncCommitteeCache() needs a fully populated pubkeyCache
     if (!opts?.skipSyncPubkeys) {
-      syncPubkeys(pubkeyCache, validators);
+      pubkeyCache.syncPubkeys(validators);
     }
 
     const effectiveBalanceIncrements = getEffectiveBalanceIncrementsWithLen(validatorCount);
@@ -908,7 +908,7 @@ export class EpochCache {
   }
 
   addPubkey(index: ValidatorIndex, pubkey: Uint8Array): void {
-    this.pubkeyCache.set(index, pubkey);
+    this.pubkeyCache.append(index, pubkey);
   }
 
   getShufflingAtSlot(slot: Slot): EpochShuffling {
@@ -1123,7 +1123,6 @@ export function createEmptyEpochCacheImmutableData(
 ): EpochCacheImmutableData {
   return {
     config: createBeaconConfig(chainConfig, state.genesisValidatorsRoot),
-    // This is a test state, there's no need to have a global shared cache of keys
-    pubkeyCache: createPubkeyCache(),
+    pubkeyCache: defaultPubkeyCache,
   };
 }

package/src/cache/stateCache.ts

@@ -187,7 +187,7 @@ export function loadCachedBeaconState<T extends CachedBeaconStateAllForks>(
   const validators = migratedState.validators;
   for (const validatorIndex of modifiedValidators) {
     const validator = validators.getReadonly(validatorIndex);
-    pubkeyCache.set(validatorIndex, validator.pubkey);
+    pubkeyCache.append(validatorIndex, validator.pubkey);
   }
 
   return createCachedBeaconState(

package/src/cache/syncCommitteeCache.ts

@@ -1,3 +1,4 @@
+import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {CompositeViewDU} from "@chainsafe/ssz";
 import {ValidatorIndex, ssz} from "@lodestar/types";
 import {toPubkeyHex} from "@lodestar/utils";
@@ -38,7 +39,7 @@ export function getSyncCommitteeCache(validatorIndices: Uint32Array): SyncCommit
 
 export function computeSyncCommitteeCache(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
+  pubkeyCache: PubkeyCache
 ): SyncCommitteeCache {
   const validatorIndices = computeSyncCommitteeValidatorIndices(syncCommittee, pubkeyCache);
   const validatorIndexMap = computeValidatorSyncCommitteeIndexMap(validatorIndices);
@@ -78,7 +79,7 @@ export function computeValidatorSyncCommitteeIndexMap(
  */
 function computeSyncCommitteeValidatorIndices(
   syncCommittee: CompositeViewDU<typeof ssz.altair.SyncCommittee>,
-  pubkeyCache: {getIndex(pubkey: Uint8Array): number | null}
+  pubkeyCache: PubkeyCache
 ): Uint32Array {
   const pubkeys = syncCommittee.pubkeys.getAllReadonly();
   const validatorIndices = new Uint32Array(pubkeys.length);

package/src/epoch/processSyncCommitteeUpdates.ts

@@ -1,4 +1,4 @@
-import {aggregateSerializedPublicKeys} from "@chainsafe/blst";
+import {aggregateSerializedPublicKeys} from "@chainsafe/lodestar-z/blst";
 import {EPOCHS_PER_SYNC_COMMITTEE_PERIOD, ForkSeq} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {CachedBeaconStateAltair} from "../types.js";

package/src/index.ts

@@ -1,8 +1,4 @@
-export {
-  type BlockExternalData,
-  DataAvailabilityStatus,
-  ExecutionPayloadStatus,
-} from "./block/externalData.js";
+export {type BlockExternalData, DataAvailabilityStatus, ExecutionPayloadStatus} from "./block/externalData.js";
 export {getAttestationParticipationStatus, processAttestationsAltair} from "./block/processAttestationsAltair.js";
 export {assertValidAttesterSlashing} from "./block/processAttesterSlashing.js";
 export {isValidBlsToExecutionChange} from "./block/processBlsToExecutionChange.js";
@@ -25,7 +21,6 @@ export {
   createEmptyEpochCacheImmutableData,
 } from "./cache/epochCache.js";
 export {type EpochTransitionCache, beforeProcessEpoch} from "./cache/epochTransitionCache.js";
-export {type PubkeyCache, createPubkeyCache, syncPubkeys} from "./cache/pubkeyCache.js";
 // Main state caches
 export {
   type BeaconStateCache,

package/src/lightClient/spec/store.ts

@@ -1,4 +1,4 @@
-import type {PublicKey} from "@chainsafe/blst";
+import type {PublicKey} from "@chainsafe/lodestar-z/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {LightClientBootstrap, LightClientHeader, LightClientUpdate, SyncPeriod} from "@lodestar/types";
 import {computeSyncPeriodAtSlot} from "../../util/epoch.js";

package/src/lightClient/spec/utils.ts

@@ -1,4 +1,4 @@
-import {PublicKey} from "@chainsafe/blst";
+import {PublicKey} from "@chainsafe/lodestar-z/blst";
 import {Tree} from "@chainsafe/persistent-merkle-tree";
 import {BitArray} from "@chainsafe/ssz";
 import {ChainForkConfig} from "@lodestar/config";

package/src/lightClient/spec/validateLightClientUpdate.ts

@@ -1,4 +1,4 @@
-import {PublicKey, Signature, fastAggregateVerify} from "@chainsafe/blst";
+import {PublicKey, Signature, fastAggregateVerify} from "@chainsafe/lodestar-z/blst";
 import {ChainForkConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE, GENESIS_SLOT, MIN_SYNC_COMMITTEE_PARTICIPANTS} from "@lodestar/params";
 import {LightClientUpdate, Root, ssz} from "@lodestar/types";

package/src/rewards/attestationsRewards.ts

@@ -1,3 +1,4 @@
+import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
@@ -15,7 +16,6 @@ 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,

package/src/rewards/syncCommitteeRewards.ts

@@ -1,7 +1,8 @@
+import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
 import {ForkName, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {BeaconBlock, ValidatorIndex, altair, rewards} from "@lodestar/types";
-import {PubkeyCache} from "../cache/pubkeyCache.js";
+import {toPubkeyHex} from "@lodestar/utils";
 import {CachedBeaconStateAllForks, CachedBeaconStateAltair} from "../cache/stateCache.js";
 
 export async function computeSyncCommitteeRewards(
@@ -48,7 +49,8 @@ export async function computeSyncCommitteeRewards(
   if (validatorIds.length) {
     const filtersSet = new Set(validatorIds);
     return rewards.filter((reward) => {
-      const pubkeyHex = pubkeyCache.get(reward.validatorIndex)?.toHex();
+      const pubkey = pubkeyCache.getPubkeyBytes(reward.validatorIndex);
+      const pubkeyHex = pubkey === undefined ? undefined : toPubkeyHex(pubkey);
       return filtersSet.has(reward.validatorIndex) || (pubkeyHex !== undefined && filtersSet.has(pubkeyHex));
     });
   }

package/src/signatureSets/blsToExecutionChange.ts

@@ -1,4 +1,3 @@
-import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
 import {capella, ssz} from "@lodestar/types";
@@ -26,7 +25,7 @@ export function getBlsToExecutionChangeSignatureSet(
     type: SignatureSetType.single,
     // The withdrawal pubkey is the same as signedBLSToExecutionChange's fromBlsPubkey as it should
     // be validated against the withdrawal credentials digest
-    pubkey: PublicKey.fromBytes(signedBLSToExecutionChange.message.fromBlsPubkey, true),
+    pubkey: signedBLSToExecutionChange.message.fromBlsPubkey,
     signingRoot: computeSigningRoot(ssz.capella.BLSToExecutionChange, signedBLSToExecutionChange.message, domain),
     signature: signedBLSToExecutionChange.signature,
   };

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -1,11 +1,13 @@
-import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {BUILDER_INDEX_SELF_BUILD, DOMAIN_BEACON_BUILDER} from "@lodestar/params";
 import {ValidatorIndex, gloas, ssz} from "@lodestar/types";
-import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {IBeaconStateView, isStatePostGloas} from "../stateView/interface.js";
 import {computeSigningRoot} from "../util/index.js";
-import {type SingleSignatureSet, createSingleSignatureSetFromComponents} from "../util/signatureSets.js";
+import {
+  type ISignatureSet,
+  createIndexedSignatureSetFromComponents,
+  createSingleSignatureSetFromComponents,
+} from "../util/signatureSets.js";
 
 export function getExecutionPayloadEnvelopeSigningRoot(
   config: BeaconConfig,
@@ -18,24 +20,21 @@ export function getExecutionPayloadEnvelopeSigningRoot(
 
 export function getExecutionPayloadEnvelopeSignatureSet(
   config: BeaconConfig,
-  pubkeyCache: PubkeyCache,
   state: IBeaconStateView,
   signedEnvelope: gloas.SignedExecutionPayloadEnvelope,
   proposerIndex: ValidatorIndex
-): SingleSignatureSet {
+): ISignatureSet {
   if (!isStatePostGloas(state)) {
     throw new Error(`Expected gloas+ state for execution payload envelope signature, got fork=${state.forkName}`);
   }
 
   const envelope = signedEnvelope.message;
-  const pubkey =
-    envelope.builderIndex === BUILDER_INDEX_SELF_BUILD
-      ? pubkeyCache.getOrThrow(proposerIndex)
-      : PublicKey.fromBytes(state.getBuilder(envelope.builderIndex).pubkey);
-
-  return createSingleSignatureSetFromComponents(
-    pubkey,
-    getExecutionPayloadEnvelopeSigningRoot(config, envelope),
-    signedEnvelope.signature
-  );
+  const signingRoot = getExecutionPayloadEnvelopeSigningRoot(config, envelope);
+  return envelope.builderIndex === BUILDER_INDEX_SELF_BUILD
+    ? createIndexedSignatureSetFromComponents(proposerIndex, signingRoot, signedEnvelope.signature)
+    : createSingleSignatureSetFromComponents(
+        state.getBuilder(envelope.builderIndex).pubkey,
+        signingRoot,
+        signedEnvelope.signature
+      );
 }

package/src/signatureSets/proposer.ts

@@ -1,17 +1,15 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, SignedBlindedBeaconBlock, Slot, isBlindedBeaconBlock, phase0, ssz} from "@lodestar/types";
-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,
-  pubkeyCache: PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
   const signatureSet = getBlockProposerSignatureSet(config, signedBlock);
-  return verifySignatureSet(signatureSet, pubkeyCache);
+  return verifySignatureSet(signatureSet);
 }
 
 export function getBlockProposerSignatureSet(

package/src/signatureSets/randao.ts

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

package/src/signatureSets/voluntaryExits.ts

@@ -1,8 +1,6 @@
-import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {PubkeyCache} from "../cache/pubkeyCache.js";
 import {IBeaconStateView, IBeaconStateViewGloas, isStatePostGloas} from "../stateView/interface.js";
 import {
   ISignatureSet,
@@ -16,11 +14,10 @@ import {
 
 export function verifyVoluntaryExitSignature(
   config: BeaconConfig,
-  pubkeyCache: PubkeyCache,
   state: IBeaconStateView,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, state, signedVoluntaryExit), pubkeyCache);
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, state, signedVoluntaryExit));
 }
 
 /**
@@ -81,7 +78,7 @@ export function getBuilderVoluntaryExitSignatureSet(
 
   return {
     type: SignatureSetType.single,
-    pubkey: PublicKey.fromBytes(builder.pubkey),
+    pubkey: builder.pubkey,
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };

package/src/stateTransition.ts

@@ -113,7 +113,7 @@ export function stateTransition(
   postState = processSlotsWithTransientCache(postState, blockSlot, options, {metrics, validatorMonitor});
 
   // Verify proposer signature only
-  if (verifyProposer && !verifyProposerSignature(postState.config, postState.epochCtx.pubkeyCache, signedBlock)) {
+  if (verifyProposer && !verifyProposerSignature(postState.config, signedBlock)) {
     throw new Error("Invalid block signature");
   }
 

package/src/stateView/stateViewFactory.ts

@@ -1,5 +1,5 @@
+import {type PubkeyCache, pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BeaconConfig} from "@lodestar/config";
-import {PubkeyCache, createPubkeyCache} from "../cache/pubkeyCache.js";
 import {createCachedBeaconState} from "../cache/stateCache.js";
 import {BeaconStateAllForks} from "../cache/types.js";
 import {getStateTypeFromBytes} from "../util/sszBytes.js";
@@ -40,17 +40,6 @@ export function createBeaconStateView(opts: NodeJSOpts | NativeOpts): IBeaconSta
 
 // ---- createBeaconStateViewForHistoricalRegen (regen path) ----
 
-// Reused across all historical state regen calls in the worker thread
-const pubkeyCacheRegen = createPubkeyCache();
-
-function syncPubkeyCache(state: BeaconStateAllForks, pubkeyCache: PubkeyCache): void {
-  const newCount = state.validators.length;
-  for (let i = pubkeyCache.size; i < newCount; i++) {
-    const pubkey = state.validators.getReadonly(i).pubkey;
-    pubkeyCache.set(i, pubkey);
-  }
-}
-
 type RegenNodeJSOpts = {
   useNative: false;
   config: BeaconConfig;
@@ -74,7 +63,6 @@ export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts |
   }
   const {config, stateBytes} = opts;
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);
-  syncPubkeyCache(state, pubkeyCacheRegen);
-  const cachedState = createCachedBeaconState(state, {config, pubkeyCache: pubkeyCacheRegen}, {skipSyncPubkeys: true});
+  const cachedState = createCachedBeaconState(state, {config, pubkeyCache}, {skipSyncPubkeys: true});
   return new BeaconStateView(cachedState);
 }

package/src/testUtils/index.ts

@@ -1,5 +1,6 @@
 export * from "./cache.js";
 export * from "./interop.js";
+export * from "./interopPubkeyCache.js";
 export * from "./params.js";
 export * from "./testFileCache.js";
 export * from "./util.js";