@lodestar/state-transition 1.47.0-dev.a27526c22a → 1.47.0-dev.a3a363b2f7

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

package/lib/cache/pubkeyCache.js

@@ -1,49 +0,0 @@
-import { PublicKey } from "@chainsafe/blst";
-import { PubkeyIndexMap } from "@chainsafe/pubkey-index-map";
-class StandardPubkeyCache {
-    pubkey2index;
-    index2pubkey;
-    constructor(pubkey2index, index2pubkey) {
-        this.pubkey2index = pubkey2index ?? new PubkeyIndexMap();
-        this.index2pubkey = index2pubkey ?? [];
-    }
-    get size() {
-        return this.pubkey2index.size;
-    }
-    get(index) {
-        return this.index2pubkey[index];
-    }
-    getOrThrow(index) {
-        const pubkey = this.get(index);
-        if (!pubkey)
-            throw Error(`Missing pubkey for validator index ${index}`);
-        return pubkey;
-    }
-    getIndex(pubkey) {
-        return this.pubkey2index.get(pubkey);
-    }
-    set(index, pubkey) {
-        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() {
-    return new StandardPubkeyCache();
-}
-/**
- * Checks the pubkey indices against a state and adds missing pubkeys
- *
- * Mutates `pubkeyCache`
- *
- * If pubkey cache is empty: SLOW CODE - 🐢
- */
-export function syncPubkeys(pubkeyCache, validators) {
-    const newCount = validators.length;
-    for (let i = pubkeyCache.size; i < newCount; i++) {
-        pubkeyCache.set(i, validators[i].pubkey);
-    }
-}
-//# sourceMappingURL=pubkeyCache.js.map

package/lib/cache/pubkeyCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pubkeyCache.js","sourceRoot":"","sources":["../../src/cache/pubkeyCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAoB3D,MAAM,mBAAmB;IACN,YAAY,CAAiB;IAC7B,YAAY,CAA4B;IAEzD,YAAY,YAA6B,EAAE,YAAwC;QACjF,IAAI,CAAC,YAAY,GAAG,YAAY,IAAI,IAAI,cAAc,EAAE,CAAC;QACzD,IAAI,CAAC,YAAY,GAAG,YAAY,IAAI,EAAE,CAAC;IACzC,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC;IAChC,CAAC;IAED,GAAG,CAAC,KAAqB;QACvB,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,UAAU,CAAC,KAAqB;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM;YAAE,MAAM,KAAK,CAAC,sCAAsC,KAAK,EAAE,CAAC,CAAC;QACxE,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,QAAQ,CAAC,MAAkB;QACzB,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,GAAG,CAAC,KAAqB,EAAE,MAAkB;QAC3C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACrC,gHAAgH;QAChH,kEAAkE;QAClE,kCAAkC;QAClC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,2BAA2B;IACrF,CAAC;CACF;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO,IAAI,mBAAmB,EAAE,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,WAAwB,EAAE,UAA8B;IAClF,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;QACjD,WAAW,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC"}

package/src/cache/pubkeyCache.ts

@@ -1,74 +0,0 @@
-import {PublicKey} from "@chainsafe/blst";
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
-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;
-}
-
-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 `pubkeyCache`
- *
- * If pubkey cache is empty: SLOW CODE - 🐢
- */
-export function syncPubkeys(pubkeyCache: PubkeyCache, validators: phase0.Validator[]): void {
-  const newCount = validators.length;
-  for (let i = pubkeyCache.size; i < newCount; i++) {
-    pubkeyCache.set(i, validators[i].pubkey);
-  }
-}