@bitcoin-js/tiny-secp256k1-asmjs 2.2.2

package/lib/validate.d.ts

@@ -0,0 +1,25 @@
+export declare const PRIVATE_KEY_SIZE = 32;
+export declare const PUBLIC_KEY_COMPRESSED_SIZE = 33;
+export declare const PUBLIC_KEY_UNCOMPRESSED_SIZE = 65;
+export declare const X_ONLY_PUBLIC_KEY_SIZE = 32;
+export declare const TWEAK_SIZE = 32;
+export declare const HASH_SIZE = 32;
+export declare const EXTRA_DATA_SIZE = 32;
+export declare const SIGNATURE_SIZE = 64;
+export declare function isZero(x: Uint8Array): boolean;
+export declare function isPrivate(x: Uint8Array): boolean;
+export declare function isPoint(p: Uint8Array): boolean;
+export declare function isXOnlyPoint(p: Uint8Array): boolean;
+export declare function isDERPoint(p: Uint8Array): boolean;
+export declare function isPointCompressed(p: Uint8Array): boolean;
+export declare function validateParity(p: 1 | 0): void;
+export declare function validatePrivate(d: Uint8Array): void;
+export declare function validatePoint(p: Uint8Array): void;
+export declare function validateXOnlyPoint(p: Uint8Array): void;
+export declare function validateTweak(tweak: Uint8Array): void;
+export declare function validateHash(h: Uint8Array): void;
+export declare function validateExtraData(e?: Uint8Array): void;
+export declare function validateSignature(signature: Uint8Array): void;
+export declare function validateSignatureCustom(validatorFn: () => boolean): void;
+export declare function validateSignatureNonzeroRS(signature: Uint8Array): void;
+export declare function validateSigrPMinusN(signature: Uint8Array): void;

package/lib/validate.js

@@ -0,0 +1,124 @@
+import { ERROR_BAD_PRIVATE, ERROR_BAD_POINT, ERROR_BAD_TWEAK, throwError, ERROR_BAD_HASH, ERROR_BAD_EXTRA_DATA, ERROR_BAD_SIGNATURE, ERROR_BAD_PARITY, ERROR_BAD_RECOVERY_ID, } from "./validate_error.js";
+export const PRIVATE_KEY_SIZE = 32;
+export const PUBLIC_KEY_COMPRESSED_SIZE = 33;
+export const PUBLIC_KEY_UNCOMPRESSED_SIZE = 65;
+export const X_ONLY_PUBLIC_KEY_SIZE = 32;
+export const TWEAK_SIZE = 32;
+export const HASH_SIZE = 32;
+export const EXTRA_DATA_SIZE = 32;
+export const SIGNATURE_SIZE = 64;
+const BN32_ZERO = new Uint8Array(32);
+const BN32_N = new Uint8Array([
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    254, 186, 174, 220, 230, 175, 72, 160, 59, 191, 210, 94, 140, 208, 54, 65, 65,
+]);
+// Difference between field and order
+const BN32_P_MINUS_N = new Uint8Array([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 69, 81, 35, 25, 80, 183, 95,
+    196, 64, 45, 161, 114, 47, 201, 186, 238,
+]);
+function isUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+function cmpBN32(data1, data2) {
+    for (let i = 0; i < 32; ++i) {
+        if (data1[i] !== data2[i]) {
+            return data1[i] < data2[i] ? -1 : 1;
+        }
+    }
+    return 0;
+}
+export function isZero(x) {
+    return cmpBN32(x, BN32_ZERO) === 0;
+}
+export function isPrivate(x) {
+    return (isUint8Array(x) &&
+        x.length === PRIVATE_KEY_SIZE &&
+        cmpBN32(x, BN32_ZERO) > 0 &&
+        cmpBN32(x, BN32_N) < 0);
+}
+export function isPoint(p) {
+    return (isUint8Array(p) &&
+        (p.length === PUBLIC_KEY_COMPRESSED_SIZE ||
+            p.length === PUBLIC_KEY_UNCOMPRESSED_SIZE ||
+            p.length === X_ONLY_PUBLIC_KEY_SIZE));
+}
+export function isXOnlyPoint(p) {
+    return isUint8Array(p) && p.length === X_ONLY_PUBLIC_KEY_SIZE;
+}
+export function isDERPoint(p) {
+    return (isUint8Array(p) &&
+        (p.length === PUBLIC_KEY_COMPRESSED_SIZE ||
+            p.length === PUBLIC_KEY_UNCOMPRESSED_SIZE));
+}
+export function isPointCompressed(p) {
+    return isUint8Array(p) && p.length === PUBLIC_KEY_COMPRESSED_SIZE;
+}
+function isTweak(tweak) {
+    return (isUint8Array(tweak) &&
+        tweak.length === TWEAK_SIZE &&
+        cmpBN32(tweak, BN32_N) < 0);
+}
+function isHash(h) {
+    return isUint8Array(h) && h.length === HASH_SIZE;
+}
+function isExtraData(e) {
+    return e === undefined || (isUint8Array(e) && e.length === EXTRA_DATA_SIZE);
+}
+function isSignature(signature) {
+    return (isUint8Array(signature) &&
+        signature.length === 64 &&
+        cmpBN32(signature.subarray(0, 32), BN32_N) < 0 &&
+        cmpBN32(signature.subarray(32, 64), BN32_N) < 0);
+}
+function isSigrLessThanPMinusN(signature) {
+    return (isUint8Array(signature) &&
+        signature.length === 64 &&
+        cmpBN32(signature.subarray(0, 32), BN32_P_MINUS_N) < 0);
+}
+export function validateParity(p) {
+    if (p !== 0 && p !== 1)
+        throwError(ERROR_BAD_PARITY);
+}
+export function validatePrivate(d) {
+    if (!isPrivate(d))
+        throwError(ERROR_BAD_PRIVATE);
+}
+export function validatePoint(p) {
+    if (!isPoint(p))
+        throwError(ERROR_BAD_POINT);
+}
+export function validateXOnlyPoint(p) {
+    if (!isXOnlyPoint(p))
+        throwError(ERROR_BAD_POINT);
+}
+export function validateTweak(tweak) {
+    if (!isTweak(tweak))
+        throwError(ERROR_BAD_TWEAK);
+}
+export function validateHash(h) {
+    if (!isHash(h))
+        throwError(ERROR_BAD_HASH);
+}
+export function validateExtraData(e) {
+    if (!isExtraData(e))
+        throwError(ERROR_BAD_EXTRA_DATA);
+}
+export function validateSignature(signature) {
+    if (!isSignature(signature))
+        throwError(ERROR_BAD_SIGNATURE);
+}
+export function validateSignatureCustom(validatorFn) {
+    if (!validatorFn())
+        throwError(ERROR_BAD_SIGNATURE);
+}
+export function validateSignatureNonzeroRS(signature) {
+    if (isZero(signature.subarray(0, 32)))
+        throwError(ERROR_BAD_SIGNATURE);
+    if (isZero(signature.subarray(32, 64)))
+        throwError(ERROR_BAD_SIGNATURE);
+}
+export function validateSigrPMinusN(signature) {
+    if (!isSigrLessThanPMinusN(signature))
+        throwError(ERROR_BAD_RECOVERY_ID);
+}

package/lib/validate_error.d.ts

@@ -0,0 +1,9 @@
+export declare const ERROR_BAD_PRIVATE = 0;
+export declare const ERROR_BAD_POINT = 1;
+export declare const ERROR_BAD_TWEAK = 2;
+export declare const ERROR_BAD_HASH = 3;
+export declare const ERROR_BAD_SIGNATURE = 4;
+export declare const ERROR_BAD_EXTRA_DATA = 5;
+export declare const ERROR_BAD_PARITY = 6;
+export declare const ERROR_BAD_RECOVERY_ID = 7;
+export declare function throwError(errcode: number): never;

package/lib/validate_error.js

@@ -0,0 +1,22 @@
+export const ERROR_BAD_PRIVATE = 0;
+export const ERROR_BAD_POINT = 1;
+export const ERROR_BAD_TWEAK = 2;
+export const ERROR_BAD_HASH = 3;
+export const ERROR_BAD_SIGNATURE = 4;
+export const ERROR_BAD_EXTRA_DATA = 5;
+export const ERROR_BAD_PARITY = 6;
+export const ERROR_BAD_RECOVERY_ID = 7;
+const ERRORS_MESSAGES = {
+    [ERROR_BAD_PRIVATE.toString()]: "Expected Private",
+    [ERROR_BAD_POINT.toString()]: "Expected Point",
+    [ERROR_BAD_TWEAK.toString()]: "Expected Tweak",
+    [ERROR_BAD_HASH.toString()]: "Expected Hash",
+    [ERROR_BAD_SIGNATURE.toString()]: "Expected Signature",
+    [ERROR_BAD_EXTRA_DATA.toString()]: "Expected Extra Data (32 bytes)",
+    [ERROR_BAD_PARITY.toString()]: "Expected Parity (1 | 0)",
+    [ERROR_BAD_RECOVERY_ID.toString()]: "Bad Recovery Id",
+};
+export function throwError(errcode) {
+    const message = ERRORS_MESSAGES[errcode.toString()] || `Unknow error code: ${errcode}`;
+    throw new TypeError(message);
+}

package/lib/wasm_loader.d.ts

@@ -0,0 +1,41 @@
+interface WebAssemblyMemory {
+    buffer: Uint8Array;
+}
+interface WebAssemblyGlobal {
+    value: number;
+}
+declare type RecoveryIdType = 0 | 1 | 2 | 3;
+interface Secp256k1WASM {
+    memory: WebAssemblyMemory;
+    PRIVATE_INPUT: WebAssemblyGlobal;
+    PUBLIC_KEY_INPUT: WebAssemblyGlobal;
+    PUBLIC_KEY_INPUT2: WebAssemblyGlobal;
+    X_ONLY_PUBLIC_KEY_INPUT: WebAssemblyGlobal;
+    X_ONLY_PUBLIC_KEY_INPUT2: WebAssemblyGlobal;
+    TWEAK_INPUT: WebAssemblyGlobal;
+    HASH_INPUT: WebAssemblyGlobal;
+    EXTRA_DATA_INPUT: WebAssemblyGlobal;
+    SIGNATURE_INPUT: WebAssemblyGlobal;
+    initializeContext: () => void;
+    isPoint: (p: number) => number;
+    pointAdd: (pA: number, pB: number, outputlen: number) => number;
+    pointAddScalar: (p: number, outputlen: number) => number;
+    pointCompress: (p: number, outputlen: number) => number;
+    pointFromScalar: (outputlen: number) => number;
+    xOnlyPointFromScalar: () => number;
+    xOnlyPointFromPoint: (inputLen: number) => number;
+    xOnlyPointAddTweak: () => 1 | 0 | -1;
+    xOnlyPointAddTweakCheck: (parity: number) => number;
+    pointMultiply: (p: number, outputlen: number) => number;
+    privateAdd: () => number;
+    privateSub: () => number;
+    privateNegate: () => void;
+    sign: (e: number) => void;
+    signRecoverable: (e: number) => 0 | 1 | 2 | 3;
+    signSchnorr: (e: number) => void;
+    verify: (Q: number, strict: number) => number;
+    verifySchnorr: () => number;
+    recover: (outputlen: number, recoveryId: RecoveryIdType) => number;
+}
+declare const _default: Secp256k1WASM;
+export default _default;

package/lib/wasm_loader.js

@@ -0,0 +1,5 @@
+// Suppress TS2792: Cannot find module './secp256k1.asm.js'.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import * as wasm from "./secp256k1.asm.js";
+export default wasm;

package/lib/wasm_path.d.ts

@@ -0,0 +1 @@
+export declare function path(wasmFilename: string): string;

package/lib/wasm_path.js

@@ -0,0 +1,5 @@
+import { URL, fileURLToPath } from "url";
+export function path(wasmFilename) {
+    const url = new URL(wasmFilename, import.meta.url);
+    return fileURLToPath(url);
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@bitcoin-js/tiny-secp256k1-asmjs",
+  "version": "2.2.2",
+  "description": "A tiny secp256k1 JS",
+  "homepage": "https://github.com/bitcoinjs/tiny-secp256k1#readme",
+  "bugs": {
+    "url": "https://github.com/bitcoinjs/tiny-secp256k1/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bitcoinjs/tiny-secp256k1.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./lib/cjs/index.cjs",
+  "exports": {
+    ".": {
+      "node": {
+        "module": "./lib/index.js",
+        "require": "./lib/cjs/index.cjs",
+        "import": "./lib/index.js"
+      },
+      "browser": "./lib/index.js",
+      "default": "./lib/index.js"
+    }
+  },
+  "browser": {
+    "./lib/rand.js": "./lib/rand.browser.js"
+  },
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "uint8array-tools": "0.0.7"
+  },
+  "devDependencies": {
+    "@babel/eslint-parser": "^7.22.5",
+    "@babel/plugin-syntax-import-assertions": "^7.22.5",
+    "@types/node": "^14.14.35",
+    "@typescript-eslint/eslint-plugin": "^4.18.0",
+    "@typescript-eslint/parser": "^4.18.0",
+    "browser-run": "^10.1.0",
+    "buffer": "^6.0.3",
+    "eslint": "^7.22.0",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-plugin-prettier": "^3.3.1",
+    "nyc": "^15.1.0",
+    "path-browserify": "^1.0.1",
+    "prettier": "^2.2.1",
+    "process": "^0.11.10",
+    "sort-package-json": "^1.49.0",
+    "stream-browserify": "^3.0.0",
+    "tap-summary": "^4.0.0",
+    "tape": "^5.2.2",
+    "typescript": "^4.2.3",
+    "webpack": "^5.24.4",
+    "webpack-cli": "^4.5.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}