@lodestar/state-transition 1.47.0-dev.f591cb177e → 1.48.0-dev.67344272c0

package/src/stateView/computeNewStateRoot.ts

@@ -0,0 +1,35 @@
+import {DataAvailabilityStatus, ExecutionPayloadStatus} from "../block/externalData.js";
+import {StateHashTreeRootSource, StateTransitionModules, StateTransitionOpts} from "../stateTransition.js";
+import {ComputeNewStateRootResult, IBeaconStateView} from "./interface.js";
+
+/** State transition options for computing the state root of a locally produced block. */
+export const computeNewStateRootStateTransitionOpts: StateTransitionOpts = {
+  // ExecutionPayloadStatus.valid: Assume payload valid, it has been produced by a trusted EL
+  executionPayloadStatus: ExecutionPayloadStatus.valid,
+  // DataAvailabilityStatus.available: Assume the blobs to be available, have just been produced by trusted EL
+  dataAvailabilityStatus: DataAvailabilityStatus.Available,
+  // verifyStateRoot: false  | the root in the block is zero-ed, it's being computed here
+  verifyStateRoot: false,
+  // verifyProposer: false   | as the block signature is zero-ed
+  verifyProposer: false,
+  // verifySignatures: false | since the data to assemble the block is trusted
+  verifySignatures: false,
+  // Preserve cache in source state, since the resulting state is not added to the state cache
+  dontTransferCache: true,
+};
+
+export function getComputeNewStateRootResult(
+  postState: IBeaconStateView,
+  {metrics}: StateTransitionModules
+): ComputeNewStateRootResult {
+  const {attestations, syncAggregate, slashing} = postState.proposerRewards;
+  const proposerReward = BigInt(attestations + syncAggregate + slashing);
+
+  const hashTreeRootTimer = metrics?.stateHashTreeRootTime.startTimer({
+    source: StateHashTreeRootSource.computeNewStateRoot,
+  });
+  const newStateRoot = postState.hashTreeRoot();
+  hashTreeRootTimer?.();
+
+  return {newStateRoot, proposerReward, postState};
+}

package/src/stateView/interface.ts

@@ -29,6 +29,7 @@ import {
   Epoch,
   ExecutionPayloadBid,
   ExecutionPayloadHeader,
+  Gwei,
   Root,
   RootHex,
   SignedBeaconBlock,
@@ -54,6 +55,20 @@ import {StateTransitionModules, StateTransitionOpts} from "../stateTransition.js
 import {EpochShuffling} from "../util/epochShuffling.js";
 import {PreVerifyBuilderDepositsResult} from "../util/preVerifyBuilderDeposits.js";
 
+/** Inputs for computing the state root of a locally produced block. */
+export type ComputeNewStateRootInput = {
+  block: SignedBeaconBlock | SignedBlindedBeaconBlock;
+  /** Pre-serialized block bytes for native implementations. */
+  ssz?: Uint8Array;
+};
+
+/** State root computation result. Includes data derived from the post-state. */
+export type ComputeNewStateRootResult = {
+  newStateRoot: Root;
+  proposerReward: Gwei;
+  postState: IBeaconStateView;
+};
+
 /**
  * A read-only view of the BeaconState.
  */
@@ -161,6 +176,7 @@ export interface IBeaconStateView {
   hashTreeRoot(): Uint8Array;
 
   // State transition
+  computeNewStateRoot(input: ComputeNewStateRootInput, modules: StateTransitionModules): ComputeNewStateRootResult;
   stateTransition(
     signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock,
     options: StateTransitionOpts,
@@ -308,13 +324,20 @@ export type IBeaconStateViewLatestFork = Omit<
  *   `loadOtherState`, `withParentPayloadApplied`) return `IBeaconStateViewNative`
  *   so callers can re-wrap without an `as unknown` cast. Param lists are reused
  *   via `Parameters<...>` to avoid duplicating signatures.
+ * - `computeNewStateRoot` is implemented by the wrapper because its inputs differ
+ *   between the TypeScript and Zig implementations.
  *
  * The TS-side `BeaconStateView` also structurally satisfies this contract since
  * `BitArray` exposes `uint8Array` and `bitLen`.
  */
 export type IBeaconStateViewNative = Omit<
   IBeaconStateViewLatestFork,
-  "executionPayloadAvailability" | "loadOtherState" | "stateTransition" | "processSlots" | "withParentPayloadApplied"
+  | "computeNewStateRoot"
+  | "executionPayloadAvailability"
+  | "loadOtherState"
+  | "stateTransition"
+  | "processSlots"
+  | "withParentPayloadApplied"
 > & {
   executionPayloadAvailability: {uint8Array: Uint8Array; bitLen: number};
   loadOtherState(...args: Parameters<IBeaconStateViewLatestFork["loadOtherState"]>): IBeaconStateViewNative;

package/src/stateView/nativeBeaconStateView.ts

@@ -36,7 +36,10 @@ import {SyncCommitteeWitness} from "../lightClient/types.js";
 import {StateTransitionModules, StateTransitionOpts} from "../stateTransition.js";
 import {EpochShuffling} from "../util/epochShuffling.js";
 import {PreVerifyBuilderDepositsResult} from "../util/preVerifyBuilderDeposits.js";
+import {computeNewStateRootStateTransitionOpts, getComputeNewStateRootResult} from "./computeNewStateRoot.js";
 import {
+  ComputeNewStateRootInput,
+  ComputeNewStateRootResult,
   IBeaconStateView,
   IBeaconStateViewGloas,
   IBeaconStateViewLatestFork,
@@ -637,6 +640,13 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
 
   // State transition
 
+  computeNewStateRoot(input: ComputeNewStateRootInput, modules: StateTransitionModules): ComputeNewStateRootResult {
+    const postState = new NativeBeaconStateView(
+      this.binding.stateTransition(input.block, computeNewStateRootStateTransitionOpts, modules)
+    );
+    return getComputeNewStateRootResult(postState, modules);
+  }
+
   stateTransition(
     signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock,
     options: StateTransitionOpts,

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";

package/src/testUtils/interopPubkeyCache.ts

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import path from "node:path";
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
+import {interopSecretKey} from "../util/interop.js";
+import {testCachePath} from "./cache.js";
+
+/**
+ * This util persists generated keys as a PKIX snapshot in the local test-cache dir, so
+ * they are generated once per machine and reloaded for tests.
+ *
+ * The snapshot grows to satisfy larger requests. Smaller requests may load more entries
+ * than they need since cache contents do not define validator-registry membership.
+ */
+
+/** Below this count, generating keys is faster than snapshot bookkeeping (~80ms) */
+const MIN_PERSIST_SIZE = 1000;
+const MAX_SNAPSHOT_CAPACITY = 0xffffffff;
+const defaultSnapshotPath = path.join(testCachePath, "interop-pubkeys.pkix");
+
+/** Sentinel pubkeys used to verify cache contents, memoized as they are re-checked often */
+const interopPubkeyByIndex = new Map<number, Uint8Array>();
+
+function interopPubkey(index: number): Uint8Array {
+  let pubkey = interopPubkeyByIndex.get(index);
+  if (!pubkey) {
+    pubkey = interopSecretKey(index).toPublicKey().toBytes();
+    interopPubkeyByIndex.set(index, pubkey);
+  }
+  return pubkey;
+}
+
+function isInteropKeyAt(index: number): boolean {
+  const pubkey = pubkeyCache.get(index);
+  return pubkey !== undefined && Buffer.compare(pubkey.toBytes(), interopPubkey(index)) === 0;
+}
+
+/**
+ * True if cache entries [0, count) are the index-matching interop pubkeys. Checking the
+ * two endpoints suffices: the native cache is append-only and never remaps an index, so
+ * replacing any entry in between would have required a reset() clearing index 0 too.
+ */
+function hasInteropPrefix(count: number): boolean {
+  return pubkeyCache.size >= count && isInteropKeyAt(0) && isInteropKeyAt(count - 1);
+}
+
+function loadSnapshot(snapshotPath: string): void {
+  if (!fs.existsSync(snapshotPath)) return;
+
+  try {
+    pubkeyCache.load(snapshotPath, MAX_SNAPSHOT_CAPACITY);
+  } catch {
+    // Stale ABI, corrupt or torn file: drop it so future runs regenerate it
+    fs.rmSync(snapshotPath, {force: true});
+  }
+}
+
+function saveSnapshot(snapshotPath: string): void {
+  fs.mkdirSync(path.dirname(snapshotPath), {recursive: true});
+  // Write-then-rename so concurrent test processes never observe a partial file
+  const tmpPath = `${snapshotPath}.tmp-${process.pid}`;
+  try {
+    pubkeyCache.save(tmpPath);
+    fs.renameSync(tmpPath, snapshotPath);
+  } catch {
+    fs.rmSync(tmpPath, {force: true});
+  }
+}
+
+/**
+ * Ensure the process-wide pubkey cache holds the interop pubkeys for indices [0, vc),
+ * loading persisted snapshots and generating as few keys as possible. No-op if the cache
+ * already holds them.
+ */
+export function ensureInteropPubkeyCache(vc: number, snapshotPath = defaultSnapshotPath): void {
+  if (vc <= 0 || hasInteropPrefix(vc)) return;
+
+  // The cache is append-only, so extend a shorter interop prefix in place. Otherwise,
+  // replace unrelated contents with the persisted interop cache when available.
+  const size = pubkeyCache.size;
+  const sizeToExtend = size > 0 && size < vc && hasInteropPrefix(size) ? size : 0;
+  if (sizeToExtend === 0) {
+    pubkeyCache.reset();
+    loadSnapshot(snapshotPath);
+  }
+
+  let loadedSize = pubkeyCache.size;
+  if (loadedSize > 0 && !hasInteropPrefix(loadedSize)) {
+    pubkeyCache.reset();
+    loadedSize = 0;
+  }
+  if (loadedSize >= vc) return;
+
+  for (let i = loadedSize; i < vc; i++) {
+    pubkeyCache.append(i, interopSecretKey(i).toPublicKey().toBytes());
+  }
+
+  if (vc >= MIN_PERSIST_SIZE) {
+    saveSnapshot(snapshotPath);
+  }
+}

package/src/testUtils/state.ts

@@ -1,3 +1,4 @@
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {ChainForkConfig, createBeaconConfig} from "@lodestar/config";
 import {config, config as minimalConfig} from "@lodestar/config/default";
 import {
@@ -11,13 +12,7 @@ import {phase0, ssz} from "@lodestar/types";
 import {EpochCacheOpts} from "../cache/epochCache.js";
 import {BeaconStateCache} from "../cache/stateCache.js";
 import {ZERO_HASH} from "../constants/index.js";
-import {
-  BeaconStateAllForks,
-  BeaconStatePhase0,
-  CachedBeaconStateAllForks,
-  createCachedBeaconState,
-  createPubkeyCache,
-} from "../index.js";
+import {BeaconStateAllForks, BeaconStatePhase0, CachedBeaconStateAllForks, createCachedBeaconState} from "../index.js";
 import {newZeroedArray} from "../util/index.js";
 
 /**
@@ -86,10 +81,10 @@ export function generateCachedState(
   opts: TestBeaconState = {}
 ): CachedBeaconStateAllForks {
   const state = generateState(opts);
+  pubkeyCache.reset();
   return createCachedBeaconState(state, {
     config: createBeaconConfig(config, state.genesisValidatorsRoot),
-    // This is a test state, there's no need to have a global shared cache of keys
-    pubkeyCache: createPubkeyCache(),
+    pubkeyCache,
   });
 }
 
@@ -102,8 +97,7 @@ export function createCachedBeaconStateTest<T extends BeaconStateAllForks>(
     state,
     {
       config: createBeaconConfig(configCustom, state.genesisValidatorsRoot),
-      // This is a test state, there's no need to have a global shared cache of keys
-      pubkeyCache: createPubkeyCache(),
+      pubkeyCache,
     },
     opts
   );

package/src/testUtils/testFileCache.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {getClient} from "@lodestar/api";
 import {ChainForkConfig, createChainForkConfig} from "@lodestar/config";
 import {NetworkName, networksChainConfig} from "@lodestar/config/networks";
@@ -40,6 +41,7 @@ export async function getNetworkCachedState(
 
   if (fs.existsSync(filepath)) {
     const stateSsz = fs.readFileSync(filepath);
+    pubkeyCache.reset();
     return createCachedBeaconStateTest(config.getForkTypes(slot).BeaconState.deserializeToViewDU(stateSsz), config);
   }
 
@@ -57,6 +59,7 @@ export async function getNetworkCachedState(
   ]);
 
   fs.writeFileSync(filepath, stateSsz);
+  pubkeyCache.reset();
   return createCachedBeaconStateTest(config.getForkTypes(slot).BeaconState.deserializeToViewDU(stateSsz), config);
 }
 

package/src/testUtils/util.ts

@@ -1,4 +1,5 @@
-import {PublicKey, SecretKey} from "@chainsafe/blst";
+import {PublicKey, SecretKey} from "@chainsafe/lodestar-z/blst";
+import {pubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {BitArray, fromHexString} from "@chainsafe/ssz";
 import {BeaconConfig, createBeaconConfig, createChainForkConfig} from "@lodestar/config";
 import {config} from "@lodestar/config/default";
@@ -22,7 +23,6 @@ import {
   computeCommitteeCount,
   computeEpochAtSlot,
   createCachedBeaconState,
-  createPubkeyCache,
   newFilledArray,
   processSlots,
 } from "../index.js";
@@ -40,7 +40,7 @@ import {interopSecretKey} from "../util/interop.js";
 import {computeSigningRoot} from "../util/signingRoot.js";
 import {getNextSyncCommittee} from "../util/syncCommittee.js";
 import {getActiveValidatorIndices} from "../util/validator.js";
-import {interopPubkeysCached} from "./interop.js";
+import {ensureInteropPubkeyCache} from "./interopPubkeyCache.js";
 
 let phase0State: BeaconStatePhase0 | null = null;
 let phase0CachedState23637: CachedBeaconStatePhase0 | null = null;
@@ -69,47 +69,45 @@ export const perfStateId = `${numValidators} vs - 7PWei`;
 
 /** Cache interop secret keys */
 const secretKeyByModIndex = new Map<number, SecretKey>();
+const pubkeysByCount = new Map<number, Uint8Array[]>();
 const epoch = 23638;
 export const perfStateEpoch = epoch;
 
 export function getPubkeys(vc = numValidators) {
-  const pubkeysMod = interopPubkeysCached(keypairsMod);
-  const pubkeysModObj = pubkeysMod.map((pk) => PublicKey.fromBytes(pk));
-  const pubkeys = Array.from({length: vc}, (_, i) => pubkeysMod[i % keypairsMod]);
+  ensureInteropPubkeyCache(vc);
+  let pubkeys = pubkeysByCount.get(vc);
+  if (!pubkeys) {
+    for (const [count, cached] of pubkeysByCount) {
+      if (count >= vc) {
+        pubkeys = cached.slice(0, vc);
+        break;
+      }
+    }
+    pubkeys ??= Array.from({length: vc}, (_, i) => pubkeyCache.getPubkeyBytesOrThrow(i));
+    pubkeysByCount.set(vc, pubkeys);
+  }
+  const pubkeysMod = pubkeys;
+  const pubkeysModObj = pubkeys.slice(0, keypairsMod).map((pk) => PublicKey.fromBytes(pk));
   return {pubkeysMod, pubkeysModObj, pubkeys};
 }
 
 /** Get secret key of a validatorIndex, if the pubkeys are generated with `getPubkeys()` */
 export function getSecretKeyFromIndex(validatorIndex: number): SecretKey {
-  return interopSecretKey(validatorIndex % keypairsMod);
+  return interopSecretKey(validatorIndex);
 }
 
 /** Get secret key of a validatorIndex, if the pubkeys are generated with `getPubkeys()` */
 export function getSecretKeyFromIndexCached(validatorIndex: number): SecretKey {
-  const keyIndex = validatorIndex % keypairsMod;
-  let sk = secretKeyByModIndex.get(keyIndex);
+  let sk = secretKeyByModIndex.get(validatorIndex);
   if (!sk) {
-    sk = interopSecretKey(keyIndex);
-    secretKeyByModIndex.set(keyIndex, sk);
+    sk = interopSecretKey(validatorIndex);
+    secretKeyByModIndex.set(validatorIndex, sk);
   }
   return sk;
 }
 
-function getPubkeyCaches({pubkeysMod}: ReturnType<typeof getPubkeys>, vc = numValidators) {
-  // Manually sync pubkeys to prevent doing BLS opts 110_000 times
-  const pubkeyCache = createPubkeyCache();
-  for (let i = 0; i < vc; i++) {
-    const pubkey = pubkeysMod[i % keypairsMod];
-    pubkeyCache.set(i, pubkey);
-  }
-
-  return {pubkeyCache};
-}
-
 export function generatePerfTestCachedStatePhase0(opts?: {goBackOneSlot: boolean}): CachedBeaconStatePhase0 {
-  // Generate only some publicKeys
-  const {pubkeys, pubkeysMod, pubkeysModObj} = getPubkeys();
-  const {pubkeyCache} = getPubkeyCaches({pubkeys, pubkeysMod, pubkeysModObj});
+  const {pubkeys} = getPubkeys();
 
   if (!phase0State) {
     const state = buildPerformanceStatePhase0();
@@ -218,8 +216,7 @@ export function generatePerfTestCachedStateAltair(opts?: {
   vc?: number;
 }): CachedBeaconStateAltair {
   const vc = opts?.vc ?? numValidators;
-  const {pubkeys, pubkeysMod, pubkeysModObj} = getPubkeys(vc);
-  const {pubkeyCache} = getPubkeyCaches({pubkeys, pubkeysMod, pubkeysModObj}, vc);
+  const {pubkeys} = getPubkeys(vc);
 
   const altairConfig = createChainForkConfig({ALTAIR_FORK_EPOCH: 0});
 
@@ -259,8 +256,7 @@ export function generatePerfTestCachedStateElectra(opts?: {
   vc?: number;
 }): CachedBeaconStateElectra {
   const vc = opts?.vc ?? numValidators;
-  const {pubkeys, pubkeysMod, pubkeysModObj} = getPubkeys(vc);
-  const {pubkeyCache} = getPubkeyCaches({pubkeys, pubkeysMod, pubkeysModObj}, vc);
+  const {pubkeys} = getPubkeys(vc);
 
   const electraConfig = createChainForkConfig({
     ALTAIR_FORK_EPOCH: 0,
@@ -495,15 +491,7 @@ export function generateTestCachedBeaconStateOnlyValidators({
   vc: number;
   slot: Slot;
 }): CachedBeaconStateAllForks {
-  // Generate only some publicKeys
-  const {pubkeys, pubkeysMod} = getPubkeys(vc);
-
-  // Manually sync pubkeys to prevent doing BLS opts 110_000 times
-  const pubkeyCache = createPubkeyCache();
-  for (let i = 0; i < vc; i++) {
-    const pubkey = pubkeysMod[i % keypairsMod];
-    pubkeyCache.set(i, pubkey);
-  }
+  const {pubkeys} = getPubkeys(vc);
 
   const state = ssz.phase0.BeaconState.defaultViewDU();
   state.slot = slot;

package/src/util/gloas.ts

@@ -1,4 +1,3 @@
-import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {
   BUILDER_INDEX_FLAG,
@@ -23,6 +22,7 @@ import {computeEpochAtSlot} from "./epoch.js";
 import {computeEpochShuffling} from "./epochShuffling.js";
 import {RootCache} from "./rootCache.js";
 import {computePayloadTimelinessCommitteesForEpoch} from "./seed.js";
+import {createSingleSignatureSetFromComponents, verifySignatureSet} from "./signatureSets.js";
 import {computeSigningRoot} from "./signingRoot.js";
 import {getActiveValidatorIndices} from "./validator.js";
 
@@ -339,9 +339,7 @@ export function isValidBuilderDepositSignature(
   const domain = computeDomain(DOMAIN_BUILDER_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
   const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, depositMessage, domain);
   try {
-    const publicKey = PublicKey.fromBytes(pubkey, true);
-    const sig = Signature.fromBytes(signature, true);
-    return verify(signingRoot, publicKey, sig);
+    return verifySignatureSet(createSingleSignatureSetFromComponents(pubkey, signingRoot, signature));
   } catch (_e) {
     return false;
   }

package/src/util/interop.ts

@@ -1,6 +1,6 @@
 import {toBufferBE} from "@vekexasia/bigint-buffer2";
 import {digest} from "@chainsafe/as-sha256";
-import {SecretKey} from "@chainsafe/blst";
+import {SecretKey} from "@chainsafe/lodestar-z/blst";
 import {bytesToBigInt, intToBytes} from "@lodestar/utils";
 
 let curveOrder: bigint;

package/src/util/signatureSets.ts

@@ -1,6 +1,5 @@
-import {PublicKey, Signature, aggregatePublicKeys, fastAggregateVerify, verify} from "@chainsafe/blst";
+import {BLS_VERIFIER_SET_TYPE, type BlsSignatureSet, verifySignatureSets} from "@chainsafe/lodestar-z/bls-verifier";
 import {Root} from "@lodestar/types";
-import {PubkeyCache} from "../cache/pubkeyCache.js";
 
 export enum SignatureSetType {
   single = "single",
@@ -18,7 +17,7 @@ export enum SignatureSetType {
  */
 export type SingleSignatureSet = {
   type: SignatureSetType.single;
-  pubkey: PublicKey;
+  pubkey: Uint8Array;
   signingRoot: Root;
   signature: Uint8Array;
 };
@@ -47,59 +46,39 @@ export type AggregatedSignatureSet = {
 
 export type ISignatureSet = SingleSignatureSet | IndexedSignatureSet | AggregatedSignatureSet;
 
-/**
- * Get the pubkey for a signature set, performing aggregation if necessary.
- * Requires pubkeyCache for indexed and aggregate sets.
- */
-export function getSignatureSetPubkey(signatureSet: ISignatureSet, pubkeyCache: PubkeyCache): PublicKey {
+export function toBlsSignatureSet(signatureSet: ISignatureSet): BlsSignatureSet {
   switch (signatureSet.type) {
     case SignatureSetType.single:
-      return signatureSet.pubkey;
-
-    case SignatureSetType.indexed: {
-      return pubkeyCache.getOrThrow(signatureSet.index);
-    }
+      return {
+        type: BLS_VERIFIER_SET_TYPE.single,
+        pubkey: signatureSet.pubkey,
+        message: signatureSet.signingRoot,
+        signature: signatureSet.signature,
+      };
+
+    case SignatureSetType.indexed:
+      return {
+        type: BLS_VERIFIER_SET_TYPE.indexed,
+        index: signatureSet.index,
+        message: signatureSet.signingRoot,
+        signature: signatureSet.signature,
+      };
 
     case SignatureSetType.aggregate: {
-      const pubkeys = signatureSet.indices.map((i) => {
-        return pubkeyCache.getOrThrow(i);
-      });
-      return aggregatePublicKeys(pubkeys);
-    }
-
-    default:
-      throw Error("Unknown signature set type");
-  }
-}
-
-export function verifySignatureSet(signatureSet: SingleSignatureSet, pubkeyCache?: PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: IndexedSignatureSet, pubkeyCache: PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: AggregatedSignatureSet, pubkeyCache: PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: ISignatureSet, pubkeyCache: PubkeyCache): boolean;
-export function verifySignatureSet(signatureSet: ISignatureSet, pubkeyCache?: PubkeyCache): boolean {
-  // All signatures are not trusted and must be group checked (p2.subgroup_check)
-  const signature = Signature.fromBytes(signatureSet.signature, true);
-
-  switch (signatureSet.type) {
-    case SignatureSetType.single:
-      return verify(signatureSet.signingRoot, signatureSet.pubkey, signature);
-
-    case SignatureSetType.indexed: {
-      if (!pubkeyCache) {
-        throw Error("pubkeyCache required for indexed signature set");
+      const indices = new Uint32Array(signatureSet.indices.length);
+      for (const [i, index] of signatureSet.indices.entries()) {
+        if (!Number.isInteger(index) || index < 0 || index > 0xffffffff) {
+          throw new RangeError(`Invalid validator index ${index}`);
+        }
+        indices[i] = index;
       }
-      const pubkey = pubkeyCache.getOrThrow(signatureSet.index);
-      return verify(signatureSet.signingRoot, pubkey, signature);
-    }
 
-    case SignatureSetType.aggregate: {
-      if (!pubkeyCache) {
-        throw Error("pubkeyCache required for aggregate signature set");
-      }
-      const pubkeys = signatureSet.indices.map((i) => {
-        return pubkeyCache.getOrThrow(i);
-      });
-      return fastAggregateVerify(signatureSet.signingRoot, pubkeys, signature);
+      return {
+        type: BLS_VERIFIER_SET_TYPE.aggregate,
+        indices,
+        message: signatureSet.signingRoot,
+        signature: signatureSet.signature,
+      };
     }
 
     default:
@@ -107,8 +86,12 @@ export function verifySignatureSet(signatureSet: ISignatureSet, pubkeyCache?: Pu
   }
 }
 
+export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
+  return verifySignatureSets([toBlsSignatureSet(signatureSet)]);
+}
+
 export function createSingleSignatureSetFromComponents(
-  pubkey: PublicKey,
+  pubkey: Uint8Array,
   signingRoot: Root,
   signature: Uint8Array
 ): SingleSignatureSet {

package/src/util/syncCommittee.ts

@@ -1,4 +1,4 @@
-import {aggregateSerializedPublicKeys} from "@chainsafe/blst";
+import {aggregateSerializedPublicKeys} from "@chainsafe/lodestar-z/blst";
 import {
   BASE_REWARD_FACTOR,
   EFFECTIVE_BALANCE_INCREMENT,

package/lib/cache/pubkeyCache.d.ts

@@ -1,28 +0,0 @@
-import { PublicKey } from "@chainsafe/blst";
-import { ValidatorIndex, phase0 } from "@lodestar/types";
-/**
- * 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;
-}
-export declare function createPubkeyCache(): PubkeyCache;
-/**
- * Checks the pubkey indices against a state and adds missing pubkeys
- *
- * Mutates `pubkeyCache`
- *
- * If pubkey cache is empty: SLOW CODE - 🐢
- */
-export declare function syncPubkeys(pubkeyCache: PubkeyCache, validators: phase0.Validator[]): void;
-//# sourceMappingURL=pubkeyCache.d.ts.map

package/lib/cache/pubkeyCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pubkeyCache.d.ts","sourceRoot":"","sources":["../../src/cache/pubkeyCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAC,cAAc,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,oDAAoD;IACpD,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,GAAG,SAAS,CAAC;IAClD,0EAA0E;IAC1E,UAAU,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAAC;IAC7C,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAAC;IACpD,sGAAsG;IACtG,GAAG,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACrD,wBAAwB;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAsCD,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,CAAC,SAAS,EAAE,GAAG,IAAI,CAK1F"}