feat: use napi-rs blst bindings

packages/beacon-node/package.json

@@ -95,8 +95,7 @@
   },
   "dependencies": {
     "@chainsafe/as-sha256": "^0.4.1",
-    "@chainsafe/bls": "7.1.3",
-    "@chainsafe/blst": "^0.2.11",
+    "@chainsafe/blst": "^2.0.1",
     "@chainsafe/discv5": "^9.0.0",
     "@chainsafe/enr": "^3.0.0",
     "@chainsafe/libp2p-gossipsub": "^13.0.0",

packages/beacon-node/src/chain/bls/interface.ts

@@ -1,4 +1,4 @@
-import {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {ISignatureSet} from "@lodestar/state-transition";
 
 export type VerifySignatureOpts = {

packages/beacon-node/src/chain/bls/maybeBatch.ts

@@ -1,5 +1,4 @@
-import {CoordType, PublicKey} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
+import {PublicKey, Signature, verify, verifyMultipleAggregateSignatures} from "@chainsafe/blst";
 
 const MIN_SET_COUNT_TO_BATCH = 2;
 
@@ -16,12 +15,12 @@ export type SignatureSetDeserialized = {
 export function verifySignatureSetsMaybeBatch(sets: SignatureSetDeserialized[]): boolean {
   try {
     if (sets.length >= MIN_SET_COUNT_TO_BATCH) {
-      return bls.Signature.verifyMultipleSignatures(
+      return verifyMultipleAggregateSignatures(
         sets.map((s) => ({
-          publicKey: s.publicKey,
-          message: s.message,
+          pk: s.publicKey,
+          msg: s.message,
           // true = validate signature
-          signature: bls.Signature.fromBytes(s.signature, CoordType.affine, true),
+          sig: Signature.fromBytes(s.signature, true),
         }))
       );
     }
@@ -34,8 +33,8 @@ export function verifySignatureSetsMaybeBatch(sets: SignatureSetDeserialized[]):
     // If too few signature sets verify them without batching
     return sets.every((set) => {
       // true = validate signature
-      const sig = bls.Signature.fromBytes(set.signature, CoordType.affine, true);
-      return sig.verify(set.publicKey, set.message);
+      const sig = Signature.fromBytes(set.signature, true);
+      return verify(set.message, set.publicKey, sig);
     });
   } catch (_) {
     // A signature could be malformed, in that case fromBytes throws error

packages/beacon-node/src/chain/bls/multithread/index.ts

@@ -7,8 +7,7 @@ import {spawn, Worker} from "@chainsafe/threads";
 // @ts-ignore
 // eslint-disable-next-line
 self = undefined;
-import bls from "@chainsafe/bls";
-import {Implementation, PointFormat, PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {Logger} from "@lodestar/utils";
 import {ISignatureSet} from "@lodestar/state-transition";
 import {QueueError, QueueErrorCode} from "../../../util/queue/index.js";
@@ -116,7 +115,6 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
   private readonly logger: Logger;
   private readonly metrics: Metrics | null;
 
-  private readonly format: PointFormat;
   private readonly workers: WorkerDescriptor[];
   private readonly jobs = new LinkedList<JobQueueItem>();
   private bufferedJobs: {
@@ -136,14 +134,10 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     this.metrics = metrics;
     this.blsVerifyAllMultiThread = options.blsVerifyAllMultiThread ?? false;
 
-    // TODO: Allow to customize implementation
-    const implementation = bls.implementation;
-
     // Use compressed for herumi for now.
     // THe worker is not able to deserialize from uncompressed
     // `Error: err _wrapDeserialize`
-    this.format = implementation === "blst-native" ? PointFormat.uncompressed : PointFormat.compressed;
-    this.workers = this.createWorkers(implementation, blsPoolSize);
+    this.workers = this.createWorkers(blsPoolSize);
 
     if (metrics) {
       metrics.blsThreadPool.queueLength.addCollect(() => {
@@ -265,11 +259,11 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
     );
   }
 
-  private createWorkers(implementation: Implementation, poolSize: number): WorkerDescriptor[] {
+  private createWorkers(poolSize: number): WorkerDescriptor[] {
     const workers: WorkerDescriptor[] = [];
 
     for (let i = 0; i < poolSize; i++) {
-      const workerData: WorkerData = {implementation, workerId: i};
+      const workerData: WorkerData = {workerId: i};
       const worker = new Worker(path.join(workerDir, "worker.js"), {
         workerData,
       } as ConstructorParameters<typeof Worker>[1]);
@@ -400,7 +394,7 @@ export class BlsMultiThreadWorkerPool implements IBlsVerifier {
         try {
           // Note: This can throw, must be handled per-job.
           // Pubkey and signature aggregation is defered here
-          workReq = jobItemWorkReq(job, this.format, this.metrics);
+          workReq = jobItemWorkReq(job, this.metrics);
         } catch (e) {
           this.metrics?.blsThreadPool.errorAggregateSignatureSetsCount.inc({type: job.type});
 

packages/beacon-node/src/chain/bls/multithread/jobItem.ts

@@ -1,5 +1,4 @@
-import bls from "@chainsafe/bls";
-import {CoordType, PointFormat, PublicKey} from "@chainsafe/bls/types";
+import {PublicKey, aggregateWithRandomness} from "@chainsafe/blst";
 import {ISignatureSet, SignatureSetType} from "@lodestar/state-transition";
 import {VerifySignatureOpts} from "../interface.js";
 import {getAggregatedPubkey} from "../utils.js";
@@ -49,14 +48,14 @@ export function jobItemSigSets(job: JobQueueItem): number {
  * Prepare BlsWorkReq from JobQueueItem
  * WARNING: May throw with untrusted user input
  */
-export function jobItemWorkReq(job: JobQueueItem, format: PointFormat, metrics: Metrics | null): BlsWorkReq {
+export function jobItemWorkReq(job: JobQueueItem, metrics: Metrics | null): BlsWorkReq {
   switch (job.type) {
     case JobQueueItemType.default:
       return {
         opts: job.opts,
         sets: job.sets.map((set) => ({
           // this can throw, handled in the consumer code
-          publicKey: getAggregatedPubkey(set, metrics).toBytes(format),
+          publicKey: getAggregatedPubkey(set, metrics).toBytes(),
           signature: set.signature,
           message: set.signingRoot,
         })),
@@ -70,15 +69,15 @@ export function jobItemWorkReq(job: JobQueueItem, format: PointFormat, metrics:
       // and not a problem in the near future
       // this is monitored on v1.11.0 https://github.com/ChainSafe/lodestar/pull/5912#issuecomment-1700320307
       const timer = metrics?.blsThreadPool.signatureDeserializationMainThreadDuration.startTimer();
-      const signatures = job.sets.map((set) => bls.Signature.fromBytes(set.signature, CoordType.affine, true));
+      const {pk, sig} = aggregateWithRandomness(job.sets.map((set) => ({pk: set.publicKey, sig: set.signature})));
       timer?.();
 
       return {
         opts: job.opts,
         sets: [
           {
-            publicKey: bls.PublicKey.aggregate(job.sets.map((set) => set.publicKey)).toBytes(format),
-            signature: bls.Signature.aggregate(signatures).toBytes(format),
+            publicKey: pk.toBytes(),
+            signature: sig.toBytes(),
             message: job.message,
           },
         ],

packages/beacon-node/src/chain/bls/multithread/types.ts

@@ -1,7 +1,6 @@
 import {VerifySignatureOpts} from "../interface.js";
 
 export type WorkerData = {
-  implementation: "herumi" | "blst-native";
   workerId: number;
 };
 

packages/beacon-node/src/chain/bls/multithread/worker.ts

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
 import worker from "node:worker_threads";
 import {expose} from "@chainsafe/threads/worker";
-import bls from "@chainsafe/bls";
-import {CoordType} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {verifySignatureSetsMaybeBatch, SignatureSetDeserialized} from "../maybeBatch.js";
 import {WorkerData, BlsWorkReq, WorkResult, WorkResultCode, SerializedSet, BlsWorkResult} from "./types.js";
 import {chunkifyMaximizeChunkSize} from "./utils.js";
@@ -109,7 +108,7 @@ function verifyManySignatureSets(workReqArr: BlsWorkReq[]): BlsWorkResult {
 
 function deserializeSet(set: SerializedSet): SignatureSetDeserialized {
   return {
-    publicKey: bls.PublicKey.fromBytes(set.publicKey, CoordType.affine),
+    publicKey: PublicKey.fromBytes(set.publicKey),
     message: set.message,
     signature: set.signature,
   };

packages/beacon-node/src/chain/bls/singleThread.ts

@@ -1,6 +1,4 @@
-import {PublicKey, Signature} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
-import {CoordType} from "@chainsafe/blst";
+import {PublicKey, Signature, aggregatePublicKeys, aggregateSignatures, verify} from "@chainsafe/blst";
 import {ISignatureSet} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/index.js";
 import {IBlsVerifier} from "./interface.js";
@@ -40,12 +38,12 @@ export class BlsSingleThreadVerifier implements IBlsVerifier {
     message: Uint8Array
   ): Promise<boolean[]> {
     const timer = this.metrics?.blsThreadPool.mainThreadDurationInThreadPool.startTimer();
-    const pubkey = bls.PublicKey.aggregate(sets.map((set) => set.publicKey));
+    const pubkey = aggregatePublicKeys(sets.map((set) => set.publicKey));
     let isAllValid = true;
     // validate signature = true
     const signatures = sets.map((set) => {
       try {
-        return bls.Signature.fromBytes(set.signature, CoordType.affine, true);
+        return Signature.fromBytes(set.signature, true);
       } catch (_) {
         // at least one set has malformed signature
         isAllValid = false;
@@ -54,8 +52,8 @@ export class BlsSingleThreadVerifier implements IBlsVerifier {
     });
 
     if (isAllValid) {
-      const signature = bls.Signature.aggregate(signatures as Signature[]);
-      isAllValid = signature.verify(pubkey, message);
+      const signature = aggregateSignatures(signatures as Signature[]);
+      isAllValid = verify(message, pubkey, signature);
     }
 
     let result: boolean[];
@@ -67,7 +65,7 @@ export class BlsSingleThreadVerifier implements IBlsVerifier {
         if (sig === null) {
           return false;
         }
-        return sig.verify(set.publicKey, message);
+        return verify(message, set.publicKey, sig);
       });
     }
 

packages/beacon-node/src/chain/bls/utils.ts

@@ -1,5 +1,4 @@
-import type {PublicKey} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
+import {PublicKey, aggregatePublicKeys} from "@chainsafe/blst";
 import {ISignatureSet, SignatureSetType} from "@lodestar/state-transition";
 import {Metrics} from "../../metrics/metrics.js";
 
@@ -10,7 +9,7 @@ export function getAggregatedPubkey(signatureSet: ISignatureSet, metrics: Metric
 
     case SignatureSetType.aggregate: {
       const timer = metrics?.blsThreadPool.pubkeysAggregationMainThreadDuration.startTimer();
-      const pubkeys = bls.PublicKey.aggregate(signatureSet.pubkeys);
+      const pubkeys = aggregatePublicKeys(signatureSet.pubkeys);
       timer?.();
       return pubkeys;
     }

packages/beacon-node/src/chain/opPools/aggregatedAttestationPool.ts

@@ -1,5 +1,5 @@
-import bls from "@chainsafe/bls";
 import {toHexString} from "@chainsafe/ssz";
+import {aggregateSignatures} from "@chainsafe/blst";
 import {ForkName, ForkSeq, MAX_ATTESTATIONS, MIN_ATTESTATION_INCLUSION_DELAY, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {phase0, Epoch, Slot, ssz, ValidatorIndex, RootHex} from "@lodestar/types";
 import {
@@ -383,7 +383,7 @@ export function aggregateInto(attestation1: AttestationWithIndex, attestation2:
 
   const signature1 = signatureFromBytesNoCheck(attestation1.attestation.signature);
   const signature2 = signatureFromBytesNoCheck(attestation2.attestation.signature);
-  attestation1.attestation.signature = bls.Signature.aggregate([signature1, signature2]).toBytes();
+  attestation1.attestation.signature = aggregateSignatures([signature1, signature2]).toBytes();
 }
 
 /**

packages/beacon-node/src/chain/opPools/attestationPool.ts

@@ -1,6 +1,5 @@
-import {PointFormat, Signature} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
 import {BitArray} from "@chainsafe/ssz";
+import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {phase0, Slot, RootHex} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
 import {IClock} from "../../util/clock.js";
@@ -191,10 +190,7 @@ function aggregateAttestationInto(aggregate: AggregateFast, attestation: phase0.
   }
 
   aggregate.aggregationBits.set(bitIndex, true);
-  aggregate.signature = bls.Signature.aggregate([
-    aggregate.signature,
-    signatureFromBytesNoCheck(attestation.signature),
-  ]);
+  aggregate.signature = aggregateSignatures([aggregate.signature, signatureFromBytesNoCheck(attestation.signature)]);
   return InsertOutcome.Aggregated;
 }
 
@@ -217,6 +213,6 @@ function fastToAttestation(aggFast: AggregateFast): phase0.Attestation {
   return {
     data: aggFast.data,
     aggregationBits: aggFast.aggregationBits,
-    signature: aggFast.signature.toBytes(PointFormat.compressed),
+    signature: aggFast.signature.toBytes(),
   };
 }

packages/beacon-node/src/chain/opPools/syncCommitteeMessagePool.ts

@@ -1,6 +1,5 @@
-import {PointFormat, Signature} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
 import {BitArray, toHexString} from "@chainsafe/ssz";
+import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_COUNT} from "@lodestar/params";
 import {altair, Root, Slot, SubcommitteeIndex} from "@lodestar/types";
 import {MapDef} from "@lodestar/utils";
@@ -108,7 +107,7 @@ export class SyncCommitteeMessagePool {
     return {
       ...contribution,
       aggregationBits: contribution.aggregationBits,
-      signature: contribution.signature.toBytes(PointFormat.compressed),
+      signature: contribution.signature.toBytes(),
     };
   }
 
@@ -136,7 +135,7 @@ function aggregateSignatureInto(
   }
 
   contribution.aggregationBits.set(indexInSubcommittee, true);
-  contribution.signature = bls.Signature.aggregate([
+  contribution.signature = aggregateSignatures([
     contribution.signature,
     signatureFromBytesNoCheck(signature.signature),
   ]);

packages/beacon-node/src/chain/opPools/syncContributionAndProofPool.ts

@@ -1,6 +1,5 @@
-import type {Signature} from "@chainsafe/bls/types";
-import bls from "@chainsafe/bls";
 import {BitArray, toHexString} from "@chainsafe/ssz";
+import {Signature, aggregateSignatures} from "@chainsafe/blst";
 import {SYNC_COMMITTEE_SIZE, SYNC_COMMITTEE_SUBNET_SIZE} from "@lodestar/params";
 import {altair, Slot, Root, ssz} from "@lodestar/types";
 import {G2_POINT_AT_INFINITY} from "@lodestar/state-transition";
@@ -182,6 +181,6 @@ export function aggregate(bestContributionBySubnet: Map<number, SyncContribution
   }
   return {
     syncCommitteeBits,
-    syncCommitteeSignature: bls.Signature.aggregate(signatures).toBytes(),
+    syncCommitteeSignature: aggregateSignatures(signatures).toBytes(),
   };
 }

packages/beacon-node/src/chain/opPools/utils.ts

@@ -1,5 +1,4 @@
-import bls from "@chainsafe/bls";
-import {CoordType, Signature} from "@chainsafe/bls/types";
+import {Signature} from "@chainsafe/blst";
 import {BLS_WITHDRAWAL_PREFIX} from "@lodestar/params";
 import {CachedBeaconStateAllForks} from "@lodestar/state-transition";
 import {Slot, capella} from "@lodestar/types";
@@ -30,7 +29,7 @@ export function pruneBySlot(map: Map<Slot, unknown>, slot: Slot, slotsRetained:
  * No need to verify Signature is valid, already run sig-verify = false
  */
 export function signatureFromBytesNoCheck(signature: Uint8Array): Signature {
-  return bls.Signature.fromBytes(signature, CoordType.affine, false);
+  return Signature.fromBytes(signature);
 }
 
 /**

packages/beacon-node/src/chain/validation/signatureSets/aggregateAndProof.ts

@@ -1,4 +1,4 @@
-import type {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {DOMAIN_AGGREGATE_AND_PROOF} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {Epoch, phase0} from "@lodestar/types";

packages/beacon-node/src/chain/validation/signatureSets/selectionProof.ts

@@ -1,4 +1,4 @@
-import type {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {DOMAIN_SELECTION_PROOF} from "@lodestar/params";
 import {phase0, Slot, ssz} from "@lodestar/types";
 import {computeSigningRoot, createSingleSignatureSetFromComponents, ISignatureSet} from "@lodestar/state-transition";

packages/beacon-node/src/chain/validation/signatureSets/syncCommitteeContribution.ts

@@ -1,4 +1,4 @@
-import type {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {altair, ssz} from "@lodestar/types";
 import {DOMAIN_SYNC_COMMITTEE} from "@lodestar/params";
 import {CachedBeaconStateAltair, computeSigningRoot, ISignatureSet, SignatureSetType} from "@lodestar/state-transition";

packages/beacon-node/test/e2e/api/impl/lightclient/endpoint.test.ts

@@ -1,5 +1,5 @@
 import {describe, it, beforeEach, afterEach, expect} from "vitest";
-import bls from "@chainsafe/bls";
+import {aggregateSerializedPublicKeys} from "@chainsafe/blst";
 import {createBeaconConfig, ChainConfig} from "@lodestar/config";
 import {chainConfig as chainConfigDef} from "@lodestar/config/default";
 import {getClient, HttpHeader, routes} from "@lodestar/api";
@@ -129,7 +129,7 @@ describe("lightclient api", function () {
     const committeePubkeys = Array.from({length: SYNC_COMMITTEE_SIZE}, (_, i) =>
       i % 2 === 0 ? pubkeys[0] : pubkeys[1]
     );
-    const aggregatePubkey = bls.aggregatePublicKeys(committeePubkeys);
+    const aggregatePubkey = aggregateSerializedPublicKeys(committeePubkeys).toBytes();
     // single committee hash since we requested for the first period
     expect(committeeRes.value()).toEqual([
       ssz.altair.SyncCommittee.hashTreeRoot({

packages/beacon-node/test/e2e/chain/bls/multithread.test.ts

@@ -1,6 +1,5 @@
 import {describe, it, beforeAll, expect, beforeEach, afterEach} from "vitest";
-import bls from "@chainsafe/bls";
-import {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey, SecretKey} from "@chainsafe/blst";
 import {ISignatureSet, SignatureSetType} from "@lodestar/state-transition";
 import {BlsMultiThreadWorkerPool} from "../../../../src/chain/bls/multithread/index.js";
 import {testLogger} from "../../../utils/logger.js";
@@ -29,7 +28,7 @@ describe("chain / bls / multithread queue", function () {
 
   beforeAll(() => {
     for (let i = 0; i < 3; i++) {
-      const sk = bls.SecretKey.fromBytes(Buffer.alloc(32, i + 1));
+      const sk = SecretKey.fromBytes(Buffer.alloc(32, i + 1));
       const msg = Buffer.alloc(32, i + 1);
       const pk = sk.toPublicKey();
       const sig = sk.sign(msg);

packages/beacon-node/test/mocks/mockedBls.ts

@@ -1,4 +1,4 @@
-import {PublicKey} from "@chainsafe/bls/types";
+import {PublicKey} from "@chainsafe/blst";
 import {IBlsVerifier} from "../../src/chain/bls/index.js";
 
 export class BlsVerifierMock implements IBlsVerifier {