feat!: napi-rs binding

.github/workflows/main.yml

@@ -54,7 +54,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-20.04, macos-12, macos-14, windows-latest]
-        node: [16, 17, 18, 20]
+        node: [16, 17, 18, 20, 22]
     defaults:
       run:
         shell: bash
@@ -120,7 +120,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node: [14, 16, 18, 20]
+        node: [14, 16, 18, 20, 22]
     defaults:
       run:
         shell: bash

benchmark/batchVerify.ts

@@ -1,5 +1,6 @@
 import crypto from "crypto";
 import * as bls from "../src/lib";
+import * as next from "../next/index.js";
 import {Csv} from "./utils/csv";
 import {BenchmarkRunner} from "./utils/runner";
 
@@ -44,6 +45,45 @@ import {BenchmarkRunner} from "./utils/runner";
       batch: batch / i,
       ratio: batch / serie,
     });
+
+    {
+    const serie = await runner.run({
+      id: `${i} - BLS verification - next`,
+      before: () => {
+        const msg = Buffer.alloc(32, i);
+        const sk = next.SecretKey.fromKeygen(crypto.randomBytes(32));
+        const pk = sk.toPublicKey();
+        const sig = sk.sign(msg);
+        return {msg, pk, sig};
+      },
+      run: ({msg, pk, sig}) => {
+        for (let j = 0; j < i; j++) {
+          next.verify(msg, pk, sig);
+        }
+      },
+    });
+
+    const batch = await runner.run({
+      id: `${i} - BLS verification batch - next`,
+      before: () => {
+        const msg = Buffer.alloc(32, i);
+        const sk = next.SecretKey.fromKeygen(crypto.randomBytes(32));
+        const pk = sk.toPublicKey();
+        const sig = sk.sign(msg);
+        return Array.from({length: i}, (_, i) => ({msg, pk, sig}));
+      },
+      run: (sets) => {
+        next.verifyMultipleAggregateSignatures(sets);
+      },
+    });
+
+    csv.addRow({
+      n: i,
+      serie: serie / i,
+      batch: batch / i,
+      ratio: batch / serie,
+    });
+    }
   }
 
   csv.logToConsole();

benchmark/blstOps.ts

@@ -2,6 +2,7 @@ import crypto from "crypto";
 import {blst, BLST_ERROR, P1_Affine, P2_Affine, Pairing} from "../src/bindings";
 import {aggregateSignatures, fastAggregateVerify, PublicKey, SecretKey, Signature, verify} from "../src/lib";
 import {BenchmarkRunner} from "./utils/runner";
+import * as next from "../next/index.js";
 
 const dst = "BLS_SIG_BLS12381G2-SHA256-SSWU-RO_POP_";
 const hashOrEncode = true;
@@ -279,6 +280,50 @@ const msg = Buffer.from("Mr F was here");
     });
   }
 
+  await runner.run({
+    id: "BLS signature - next",
+    before: () => {},
+    beforeEach: () => next.SecretKey.fromKeygen(crypto.randomBytes(32)),
+    run: (sk) => {
+      sk.sign(msg);
+    },
+  });
+
+  await runner.run<{pk: next.PublicKey; sig: next.Signature}>({
+    id: "BLS verification - next",
+    before: () => {
+      const sk = next.SecretKey.fromKeygen(crypto.randomBytes(32));
+      const pk = sk.toPublicKey();
+      const sig = sk.sign(msg);
+      return {pk, sig};
+    },
+    run: ({pk, sig}) => {
+      next.verify(msg, pk, sig);
+    },
+  });
+
+  for (const n of [32, 128]) {
+    await runner.run<{pks: next.PublicKey[]; sig: next.Signature}>({
+      id: `BLS agg verif of 1 msg by ${n} pubkeys - next`,
+      before: () => {
+        const pks: next.PublicKey[] = [];
+        const sigs: next.Signature[] = [];
+
+        for (let i = 0; i < n; i++) {
+          const sk = next.SecretKey.fromKeygen(Buffer.alloc(32, i));
+          pks.push(sk.toPublicKey());
+          sigs.push(sk.sign(msg));
+        }
+
+        const sig = next.aggregateSignatures(sigs);
+        return {pks, sig};
+      },
+      run: ({pks, sig}) => {
+        next.fastAggregateVerify(msg, pks, sig);
+      },
+    });
+  }
+
   // BLS verif of 6 msgs by 6 pubkeys
   // Serial batch verify 6 msgs by 6 pubkeys (with blinding)
   // Parallel batch verify of 6 msgs by 6 pubkeys (with blinding)

benchmark/multithread.ts

@@ -1,5 +1,6 @@
 import os from "os";
 import * as bls from "../src/lib";
+import * as next from "../next/index.js";
 import {BlsMultiThreadNaive} from "../test/unit/multithread/naive";
 import {warmUpWorkers, chunkify} from "../test/unit/multithread/naive/utils";
 import {Csv} from "./utils/csv";
@@ -24,10 +25,13 @@ import {BenchmarkRunner} from "./utils/runner";
 
   // Preparing test data
   const sets: bls.SignatureSet[] = [];
+  const setsNext: next.SignatureSet[] = [];
   for (let i = 0; i < sigCount; i++) {
     const msg = Buffer.alloc(32, i);
     const sk = bls.SecretKey.fromKeygen(Buffer.alloc(32, i));
     sets.push({msg, pk: sk.toPublicKey(), sig: sk.sign(msg)});
+    const skNext = next.SecretKey.fromKeygen(Buffer.alloc(32, i));
+    setsNext.push({msg, pk: skNext.toPublicKey(), sig: skNext.sign(msg)});
   }
 
   // BLS batch verify
@@ -51,6 +55,14 @@ import {BenchmarkRunner} from "./utils/runner";
       },
     });
 
+    const serieNext = await runner.run({
+      id: `BLS batch verify ${sigCount} sigs - main thread - next`,
+      before: () => {},
+      run: () => {
+        next.verifyMultipleAggregateSignatures(setsNext);
+      },
+    });
+
     for (let workers = 1; workers <= logicalCpuCount; workers++) {
       const parallel = await runner.run({
         id: `BLS batch verify ${sigCount} sigs - ${workers} worker_threads`,
@@ -68,6 +80,23 @@ import {BenchmarkRunner} from "./utils/runner";
         parallel: parallel,
         ratio: serie / parallel,
       });
+
+      const parallelNext = await runner.run({
+        id: `BLS batch verify ${sigCount} sigs - ${workers} worker_threads - next`,
+        before: () => {},
+        run: async () => {
+          await Promise.all(
+            chunkify(setsNext, workers).map((setsWorker) => next.verifyMultipleAggregateSignaturesAsync(setsWorker))
+          );
+        },
+      });
+
+      csv.addRow({
+        workers,
+        serie: serieNext,
+        parallel: parallelNext,
+        ratio: serieNext / parallelNext,
+      });
     }
     csv.logToConsole();
   }

next/.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.x86_64-pc-windows-msvc]
+rustflags = ["-C", "target-feature=+crt-static"]