add benches

.gitignore

@@ -1,3 +1,4 @@
+/benches/node_modules
 /node_modules
 /target
 /tests/browser

.prettierignore

@@ -3,4 +3,5 @@
 /tests/fixtures
 /util/gen-fixtures/secp256k1
 
+benches/package-lock.json
 package-lock.json

Makefile

@@ -34,7 +34,8 @@ clean:
 .PHONY: format
 format:
 	cargo-fmt
-	npx prettier -w . 
+	npx prettier -w .
+	npx sort-package-json package.json benches/package.json
 
 .PHONY: lint
 lint:

benches/README.md

@@ -0,0 +1,6 @@
+## Run benches
+
+```
+npm install
+npm start
+```

benches/cryptocoinjs_secp256k1.js

@@ -0,0 +1,24 @@
+import secp256k1_js from "secp256k1/elliptic.js";
+import secp256k1_native from "secp256k1/bindings.js";
+
+export const js = createApi(secp256k1_js);
+export const native = createApi(secp256k1_native);
+
+function createApi(secp256k1) {
+  return {
+    isPoint: (p) => secp256k1.publicKeyVerify(p),
+    // isPointCompressed
+    isPrivate: (d) => secp256k1.privateKeyVerify(d),
+    pointAdd: (pA, pB) => secp256k1.publicKeyCombine([pA, pB]),
+    pointAddScalar: (p, tweak) => secp256k1.publicKeyTweakAdd(p, tweak),
+    // pointCompress
+    pointFromScalar: (d) => secp256k1.publicKeyCreate(d),
+    pointMultiply: (p, tweak) => secp256k1.publicKeyTweakMul(p, tweak),
+    privateAdd: (d, tweak) =>
+      secp256k1.privateKeyTweakAdd(new Uint8Array(d), tweak),
+    // privateSub
+    sign: (h, d) => secp256k1.ecdsaSign(h, d),
+    // signWithEntropy
+    verify: (h, Q, signature) => secp256k1.ecdsaVerify(signature, h, Q),
+  };
+}

benches/fixtures.js

@@ -0,0 +1,59 @@
+import * as tiny_secp256k1 from "../lib/index.js";
+import _fecdsa from "../tests/fixtures/ecdsa.json";
+import _fpoints from "../tests/fixtures/points.json";
+import _fprivates from "../tests/fixtures/privates.json";
+
+export const fecdsa = _fecdsa.valid.map((f) => ({
+  d: Buffer.from(f.d, "hex"),
+  Q: Buffer.from(tiny_secp256k1.pointFromScalar(Buffer.from(f.d, "hex"))),
+  m: Buffer.from(f.m, "hex"),
+  signature: Buffer.from(f.signature, "hex"),
+}));
+
+export const fpoints = {
+  isPoint: _fpoints.valid.isPoint.map((f) => ({
+    P: Buffer.from(f.P, "hex"),
+  })),
+  pointAdd: _fpoints.valid.pointAdd
+    .filter((f) => f.expected !== null)
+    .map((f) => ({
+      P: Buffer.from(f.P, "hex"),
+      Q: Buffer.from(f.Q, "hex"),
+    })),
+  pointAddScalar: _fpoints.valid.pointAddScalar
+    .filter((f) => f.expected !== null)
+    .map((f) => ({
+      P: Buffer.from(f.P, "hex"),
+      d: Buffer.from(f.d, "hex"),
+    })),
+  pointCompress: _fpoints.valid.pointCompress.map((f) => ({
+    P: Buffer.from(f.P, "hex"),
+  })),
+  pointFromScalar: _fpoints.valid.pointFromScalar.map((f) => ({
+    d: Buffer.from(f.d, "hex"),
+  })),
+  pointMultiply: _fpoints.valid.pointMultiply
+    .filter((f) => f.expected !== null)
+    .map((f) => ({
+      P: Buffer.from(f.P, "hex"),
+      d: Buffer.from(f.d, "hex"),
+    })),
+};
+
+export const fprivates = {
+  isPrivate: _fprivates.valid.isPrivate.map((f) => ({
+    d: Buffer.from(f.d, "hex"),
+  })),
+  privateAdd: _fprivates.valid.privateAdd
+    .filter((f) => f.expected !== null)
+    .map((f) => ({
+      d: Buffer.from(f.d, "hex"),
+      tweak: Buffer.from(f.tweak, "hex"),
+    })),
+  privateSub: _fprivates.valid.privateSub
+    .filter((f) => f.expected !== null)
+    .map((f) => ({
+      d: Buffer.from(f.d, "hex"),
+      tweak: Buffer.from(f.tweak, "hex"),
+    })),
+};

benches/index.js

@@ -0,0 +1,207 @@
+import tiny_secp256k1_prev_js from "tiny-secp256k1/js.js";
+import tiny_secp256k1_prev_native from "tiny-secp256k1/native.js";
+import * as tiny_secp256k1 from "../lib/index.js";
+import * as cryptocoinjs_secp256k1 from "./cryptocoinjs_secp256k1.js";
+import { fecdsa, fpoints, fprivates } from "./fixtures.js";
+
+const modules = [
+  {
+    name: "tiny-secp256k1 (rust addon)",
+    secp256k1: tiny_secp256k1.__addon,
+  },
+  {
+    name: "tiny-secp256k1 (wasm)",
+    secp256k1: tiny_secp256k1.__wasm,
+  },
+  {
+    name: "tiny-secp256k1@1.1.6 (C++ addon, NAN/V8)",
+    secp256k1: tiny_secp256k1_prev_native,
+  },
+  {
+    name: "tiny-secp256k1@1.1.6 (elliptic)",
+    secp256k1: tiny_secp256k1_prev_js,
+  },
+  {
+    name: "secp256k1@4.0.2 (C++ addon, N-API)",
+    secp256k1: cryptocoinjs_secp256k1.native,
+  },
+  {
+    name: "secp256k1@4.0.2 (elliptic)",
+    secp256k1: cryptocoinjs_secp256k1.js,
+  },
+];
+
+const benchmarks = [
+  {
+    name: "isPoint",
+    bench: createBenchmarkFn(fpoints.isPoint, (secp256k1, f) =>
+      secp256k1.isPoint(f.P)
+    ),
+  },
+  {
+    name: "isPrivate",
+    bench: createBenchmarkFn(fprivates.isPrivate, (secp256k1, f) =>
+      secp256k1.isPrivate(f.d)
+    ),
+  },
+  {
+    name: "pointAdd",
+    bench: createBenchmarkFn(fpoints.pointAdd, (secp256k1, f) =>
+      secp256k1.pointAdd(f.P, f.Q)
+    ),
+  },
+  {
+    name: "pointAddScalar",
+    bench: createBenchmarkFn(fpoints.pointAddScalar, (secp256k1, f) =>
+      secp256k1.pointAddScalar(f.P, f.d)
+    ),
+  },
+  {
+    name: "pointCompress",
+    bench: createBenchmarkFn(fpoints.pointCompress, (secp256k1, f) =>
+      secp256k1.pointCompress(f.P)
+    ),
+  },
+  {
+    name: "pointFromScalar",
+    bench: createBenchmarkFn(fpoints.pointFromScalar, (secp256k1, f) =>
+      secp256k1.pointFromScalar(f.d)
+    ),
+  },
+  {
+    name: "pointMultiply",
+    bench: createBenchmarkFn(fpoints.pointMultiply, (secp256k1, f) =>
+      secp256k1.pointMultiply(f.P, f.d)
+    ),
+  },
+  {
+    name: "privateAdd",
+    bench: createBenchmarkFn(fprivates.privateAdd, (secp256k1, f) =>
+      secp256k1.privateAdd(f.d, f.tweak)
+    ),
+  },
+  {
+    name: "privateSub",
+    bench: createBenchmarkFn(fprivates.privateSub, (secp256k1, f) =>
+      secp256k1.privateSub(f.d, f.tweak)
+    ),
+  },
+  {
+    name: "sign",
+    bench: createBenchmarkFn(fecdsa, (secp256k1, f) =>
+      secp256k1.sign(f.m, f.d)
+    ),
+  },
+  {
+    name: "verify",
+    bench: createBenchmarkFn(fecdsa, (secp256k1, f) =>
+      secp256k1.verify(f.m, f.Q, f.signature)
+    ),
+  },
+];
+
+// Covert milliseconds as Number to nanoseconds as BigInt
+const millis2nanos = (ms) => BigInt(ms) * 10n ** 6n;
+
+// Warmup bench function during
+function warmingUp(bench, minIter, maxTime) {
+  const start = process.hrtime.bigint();
+  for (let i = 0; ; ) {
+    bench();
+    if (process.hrtime.bigint() - start > maxTime && ++i >= minIter) {
+      break;
+    }
+  }
+}
+
+// Create benchmark function from fixtures
+function createBenchmarkFn(fixtures, fn) {
+  return function (secp256k1) {
+    for (const f of fixtures) {
+      fn(secp256k1, f);
+    }
+    return fixtures.length;
+  };
+}
+
+// Run benchmarks
+const lineEqual = new Array(100).fill("=").join("");
+const lineDash = new Array(100).fill("-").join("");
+let isFirstResult = true;
+for (const benchmark of benchmarks) {
+  const {
+    name,
+    bench,
+    warmingUpMinIter,
+    warmingUpMaxTime,
+    benchmarkMinIter,
+    benchmarkMaxTime,
+  } = {
+    warmingUpMinIter: 1,
+    benchmarkMinIter: 2,
+    warmingUpMaxTime: millis2nanos(2000),
+    benchmarkMaxTime: millis2nanos(5000),
+    ...benchmark,
+  };
+
+  if (isFirstResult) {
+    console.log(lineEqual);
+    isFirstResult = false;
+  }
+  console.log(`Benchmarking function: ${name}`);
+  console.log(lineDash);
+  const results = [];
+  for (const module of modules) {
+    if (module.secp256k1[name] === undefined) {
+      continue;
+    }
+
+    warmingUp(
+      () => bench(module.secp256k1),
+      warmingUpMinIter,
+      warmingUpMaxTime
+    );
+
+    const results_ns = [];
+    const start = process.hrtime.bigint();
+    let start_fn = start;
+    for (let i = 0; ; ) {
+      const ops = bench(module.secp256k1);
+      const current = process.hrtime.bigint();
+      results_ns.push(Number(current - start_fn) / ops);
+      if (current - start > benchmarkMaxTime && ++i >= benchmarkMinIter) {
+        break;
+      }
+      start_fn = current;
+    }
+
+    const ops_avg_ns =
+      results_ns.reduce((total, time) => total + time, 0) / results_ns.length;
+    const ops_err_ns =
+      results_ns.length > 1
+        ? results_ns.reduce(
+            (total, time) => total + Math.abs(ops_avg_ns - time),
+            0
+          ) /
+          (results_ns.length - 1)
+        : 0;
+    const ops_err = (ops_err_ns / ops_avg_ns) * 100;
+
+    console.log(
+      `${module.name}: ${(ops_avg_ns / 1000).toFixed(2)} us/op (${(
+        10 ** 9 /
+        ops_avg_ns
+      ).toFixed(2)} op/s), ±${ops_err.toFixed(2)} %`
+    );
+
+    results.push({ name: module.name, ops_avg_ns });
+  }
+  if (results.length > 1) {
+    const fastest = results.reduce((a, b) =>
+      a.ops_avg_ns < b.ops_avg_ns ? a : b
+    );
+    console.log(lineDash);
+    console.log(`Fastest: ${fastest.name}`);
+  }
+  console.log(lineEqual);
+}