@bitcoin-js/tiny-secp256k1-asmjs 2.2.2

package/lib/cjs/validate.cjs

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSigrPMinusN = exports.validateSignatureNonzeroRS = exports.validateSignatureCustom = exports.validateSignature = exports.validateExtraData = exports.validateHash = exports.validateTweak = exports.validateXOnlyPoint = exports.validatePoint = exports.validatePrivate = exports.validateParity = exports.isPointCompressed = exports.isDERPoint = exports.isXOnlyPoint = exports.isPoint = exports.isPrivate = exports.isZero = exports.SIGNATURE_SIZE = exports.EXTRA_DATA_SIZE = exports.HASH_SIZE = exports.TWEAK_SIZE = exports.X_ONLY_PUBLIC_KEY_SIZE = exports.PUBLIC_KEY_UNCOMPRESSED_SIZE = exports.PUBLIC_KEY_COMPRESSED_SIZE = exports.PRIVATE_KEY_SIZE = void 0;
+const validate_error_js_1 = require("./validate_error.cjs");
+exports.PRIVATE_KEY_SIZE = 32;
+exports.PUBLIC_KEY_COMPRESSED_SIZE = 33;
+exports.PUBLIC_KEY_UNCOMPRESSED_SIZE = 65;
+exports.X_ONLY_PUBLIC_KEY_SIZE = 32;
+exports.TWEAK_SIZE = 32;
+exports.HASH_SIZE = 32;
+exports.EXTRA_DATA_SIZE = 32;
+exports.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;
+}
+function isZero(x) {
+    return cmpBN32(x, BN32_ZERO) === 0;
+}
+exports.isZero = isZero;
+function isPrivate(x) {
+    return (isUint8Array(x) &&
+        x.length === exports.PRIVATE_KEY_SIZE &&
+        cmpBN32(x, BN32_ZERO) > 0 &&
+        cmpBN32(x, BN32_N) < 0);
+}
+exports.isPrivate = isPrivate;
+function isPoint(p) {
+    return (isUint8Array(p) &&
+        (p.length === exports.PUBLIC_KEY_COMPRESSED_SIZE ||
+            p.length === exports.PUBLIC_KEY_UNCOMPRESSED_SIZE ||
+            p.length === exports.X_ONLY_PUBLIC_KEY_SIZE));
+}
+exports.isPoint = isPoint;
+function isXOnlyPoint(p) {
+    return isUint8Array(p) && p.length === exports.X_ONLY_PUBLIC_KEY_SIZE;
+}
+exports.isXOnlyPoint = isXOnlyPoint;
+function isDERPoint(p) {
+    return (isUint8Array(p) &&
+        (p.length === exports.PUBLIC_KEY_COMPRESSED_SIZE ||
+            p.length === exports.PUBLIC_KEY_UNCOMPRESSED_SIZE));
+}
+exports.isDERPoint = isDERPoint;
+function isPointCompressed(p) {
+    return isUint8Array(p) && p.length === exports.PUBLIC_KEY_COMPRESSED_SIZE;
+}
+exports.isPointCompressed = isPointCompressed;
+function isTweak(tweak) {
+    return (isUint8Array(tweak) &&
+        tweak.length === exports.TWEAK_SIZE &&
+        cmpBN32(tweak, BN32_N) < 0);
+}
+function isHash(h) {
+    return isUint8Array(h) && h.length === exports.HASH_SIZE;
+}
+function isExtraData(e) {
+    return e === undefined || (isUint8Array(e) && e.length === exports.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);
+}
+function validateParity(p) {
+    if (p !== 0 && p !== 1)
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_PARITY);
+}
+exports.validateParity = validateParity;
+function validatePrivate(d) {
+    if (!isPrivate(d))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_PRIVATE);
+}
+exports.validatePrivate = validatePrivate;
+function validatePoint(p) {
+    if (!isPoint(p))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_POINT);
+}
+exports.validatePoint = validatePoint;
+function validateXOnlyPoint(p) {
+    if (!isXOnlyPoint(p))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_POINT);
+}
+exports.validateXOnlyPoint = validateXOnlyPoint;
+function validateTweak(tweak) {
+    if (!isTweak(tweak))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_TWEAK);
+}
+exports.validateTweak = validateTweak;
+function validateHash(h) {
+    if (!isHash(h))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_HASH);
+}
+exports.validateHash = validateHash;
+function validateExtraData(e) {
+    if (!isExtraData(e))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_EXTRA_DATA);
+}
+exports.validateExtraData = validateExtraData;
+function validateSignature(signature) {
+    if (!isSignature(signature))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_SIGNATURE);
+}
+exports.validateSignature = validateSignature;
+function validateSignatureCustom(validatorFn) {
+    if (!validatorFn())
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_SIGNATURE);
+}
+exports.validateSignatureCustom = validateSignatureCustom;
+function validateSignatureNonzeroRS(signature) {
+    if (isZero(signature.subarray(0, 32)))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_SIGNATURE);
+    if (isZero(signature.subarray(32, 64)))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_SIGNATURE);
+}
+exports.validateSignatureNonzeroRS = validateSignatureNonzeroRS;
+function validateSigrPMinusN(signature) {
+    if (!isSigrLessThanPMinusN(signature))
+        (0, validate_error_js_1.throwError)(validate_error_js_1.ERROR_BAD_RECOVERY_ID);
+}
+exports.validateSigrPMinusN = validateSigrPMinusN;

package/lib/cjs/validate_error.cjs

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

package/lib/cjs/wasm_loader.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Suppress TS2792: Cannot find module './secp256k1.asm.cjs'.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const wasm = require("./secp256k1.asm.cjs");
+exports.default = wasm;

package/lib/cjs/wasm_path_cjs.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.path = void 0;
+const nodePath = require("path");
+function path(wasmFilename) {
+    // Since we know this file will only be used by cjs
+    // and we know that wasm file will always be in the parent dir
+    // We can translate to the parent directory without problem
+    const pathname = nodePath.join(__dirname, "..", wasmFilename);
+    return pathname;
+}
+exports.path = path;

package/lib/index.d.ts

@@ -0,0 +1,33 @@
+export declare function __initializeContext(): void;
+export declare function isPoint(p: Uint8Array): boolean;
+export declare function isPointCompressed(p: Uint8Array): boolean;
+export declare function isXOnlyPoint(p: Uint8Array): boolean;
+export declare function isPrivate(d: Uint8Array): boolean;
+export declare function pointAdd(pA: Uint8Array, pB: Uint8Array, compressed?: boolean): Uint8Array | null;
+export declare function pointAddScalar(p: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array | null;
+export declare function pointCompress(p: Uint8Array, compressed?: boolean): Uint8Array;
+export declare function pointFromScalar(d: Uint8Array, compressed?: boolean): Uint8Array | null;
+export declare function xOnlyPointFromScalar(d: Uint8Array): Uint8Array;
+export declare function xOnlyPointFromPoint(p: Uint8Array): Uint8Array;
+export declare function pointMultiply(p: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array | null;
+export declare function privateAdd(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
+export declare function privateSub(d: Uint8Array, tweak: Uint8Array): Uint8Array | null;
+export declare function privateNegate(d: Uint8Array): Uint8Array;
+export interface XOnlyPointAddTweakResult {
+    parity: 1 | 0;
+    xOnlyPubkey: Uint8Array;
+}
+export declare function xOnlyPointAddTweak(p: Uint8Array, tweak: Uint8Array): XOnlyPointAddTweakResult | null;
+export declare type TweakParity = 1 | 0;
+export declare function xOnlyPointAddTweakCheck(point: Uint8Array, tweak: Uint8Array, resultToCheck: Uint8Array, tweakParity?: TweakParity): boolean;
+export declare function sign(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
+export interface RecoverableSignature {
+    signature: Uint8Array;
+    recoveryId: RecoveryIdType;
+}
+export declare function signRecoverable(h: Uint8Array, d: Uint8Array, e?: Uint8Array): RecoverableSignature;
+export declare function signSchnorr(h: Uint8Array, d: Uint8Array, e?: Uint8Array): Uint8Array;
+export declare function verify(h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean): boolean;
+export declare type RecoveryIdType = 0 | 1 | 2 | 3;
+export declare function recover(h: Uint8Array, signature: Uint8Array, recoveryId: RecoveryIdType, compressed?: boolean): Uint8Array | null;
+export declare function verifySchnorr(h: Uint8Array, Q: Uint8Array, signature: Uint8Array): boolean;

package/lib/index.js

@@ -0,0 +1,361 @@
+import { compare } from "uint8array-tools";
+import * as validate from "./validate.js";
+import wasm from "./wasm_loader.js";
+const WASM_BUFFER = new Uint8Array(wasm.memory.buffer);
+const WASM_PRIVATE_KEY_PTR = wasm.PRIVATE_INPUT.value;
+const WASM_PUBLIC_KEY_INPUT_PTR = wasm.PUBLIC_KEY_INPUT.value;
+const WASM_PUBLIC_KEY_INPUT_PTR2 = wasm.PUBLIC_KEY_INPUT2.value;
+const WASM_X_ONLY_PUBLIC_KEY_INPUT_PTR = wasm.X_ONLY_PUBLIC_KEY_INPUT.value;
+const WASM_X_ONLY_PUBLIC_KEY_INPUT2_PTR = wasm.X_ONLY_PUBLIC_KEY_INPUT2.value;
+const WASM_TWEAK_INPUT_PTR = wasm.TWEAK_INPUT.value;
+const WASM_HASH_INPUT_PTR = wasm.HASH_INPUT.value;
+const WASM_EXTRA_DATA_INPUT_PTR = wasm.EXTRA_DATA_INPUT.value;
+const WASM_SIGNATURE_INPUT_PTR = wasm.SIGNATURE_INPUT.value;
+const PRIVATE_KEY_INPUT = WASM_BUFFER.subarray(WASM_PRIVATE_KEY_PTR, WASM_PRIVATE_KEY_PTR + validate.PRIVATE_KEY_SIZE);
+const PUBLIC_KEY_INPUT = WASM_BUFFER.subarray(WASM_PUBLIC_KEY_INPUT_PTR, WASM_PUBLIC_KEY_INPUT_PTR + validate.PUBLIC_KEY_UNCOMPRESSED_SIZE);
+const PUBLIC_KEY_INPUT2 = WASM_BUFFER.subarray(WASM_PUBLIC_KEY_INPUT_PTR2, WASM_PUBLIC_KEY_INPUT_PTR2 + validate.PUBLIC_KEY_UNCOMPRESSED_SIZE);
+const X_ONLY_PUBLIC_KEY_INPUT = WASM_BUFFER.subarray(WASM_X_ONLY_PUBLIC_KEY_INPUT_PTR, WASM_X_ONLY_PUBLIC_KEY_INPUT_PTR + validate.X_ONLY_PUBLIC_KEY_SIZE);
+const X_ONLY_PUBLIC_KEY_INPUT2 = WASM_BUFFER.subarray(WASM_X_ONLY_PUBLIC_KEY_INPUT2_PTR, WASM_X_ONLY_PUBLIC_KEY_INPUT2_PTR + validate.X_ONLY_PUBLIC_KEY_SIZE);
+const TWEAK_INPUT = WASM_BUFFER.subarray(WASM_TWEAK_INPUT_PTR, WASM_TWEAK_INPUT_PTR + validate.TWEAK_SIZE);
+const HASH_INPUT = WASM_BUFFER.subarray(WASM_HASH_INPUT_PTR, WASM_HASH_INPUT_PTR + validate.HASH_SIZE);
+const EXTRA_DATA_INPUT = WASM_BUFFER.subarray(WASM_EXTRA_DATA_INPUT_PTR, WASM_EXTRA_DATA_INPUT_PTR + validate.EXTRA_DATA_SIZE);
+const SIGNATURE_INPUT = WASM_BUFFER.subarray(WASM_SIGNATURE_INPUT_PTR, WASM_SIGNATURE_INPUT_PTR + validate.SIGNATURE_SIZE);
+function assumeCompression(compressed, p) {
+    if (compressed === undefined) {
+        return p !== undefined ? p.length : validate.PUBLIC_KEY_COMPRESSED_SIZE;
+    }
+    return compressed
+        ? validate.PUBLIC_KEY_COMPRESSED_SIZE
+        : validate.PUBLIC_KEY_UNCOMPRESSED_SIZE;
+}
+function _isPoint(p) {
+    try {
+        PUBLIC_KEY_INPUT.set(p);
+        return wasm.isPoint(p.length) === 1;
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function __initializeContext() {
+    wasm.initializeContext();
+}
+export function isPoint(p) {
+    return validate.isDERPoint(p) && _isPoint(p);
+}
+export function isPointCompressed(p) {
+    return validate.isPointCompressed(p) && _isPoint(p);
+}
+export function isXOnlyPoint(p) {
+    return validate.isXOnlyPoint(p) && _isPoint(p);
+}
+export function isPrivate(d) {
+    return validate.isPrivate(d);
+}
+export function pointAdd(pA, pB, compressed) {
+    validate.validatePoint(pA);
+    validate.validatePoint(pB);
+    const outputlen = assumeCompression(compressed, pA);
+    try {
+        PUBLIC_KEY_INPUT.set(pA);
+        PUBLIC_KEY_INPUT2.set(pB);
+        return wasm.pointAdd(pA.length, pB.length, outputlen) === 1
+            ? PUBLIC_KEY_INPUT.slice(0, outputlen)
+            : null;
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+        PUBLIC_KEY_INPUT2.fill(0);
+    }
+}
+export function pointAddScalar(p, tweak, compressed) {
+    validate.validatePoint(p);
+    validate.validateTweak(tweak);
+    const outputlen = assumeCompression(compressed, p);
+    try {
+        PUBLIC_KEY_INPUT.set(p);
+        TWEAK_INPUT.set(tweak);
+        return wasm.pointAddScalar(p.length, outputlen) === 1
+            ? PUBLIC_KEY_INPUT.slice(0, outputlen)
+            : null;
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function pointCompress(p, compressed) {
+    validate.validatePoint(p);
+    const outputlen = assumeCompression(compressed, p);
+    try {
+        PUBLIC_KEY_INPUT.set(p);
+        wasm.pointCompress(p.length, outputlen);
+        return PUBLIC_KEY_INPUT.slice(0, outputlen);
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function pointFromScalar(d, compressed) {
+    validate.validatePrivate(d);
+    const outputlen = assumeCompression(compressed);
+    try {
+        PRIVATE_KEY_INPUT.set(d);
+        return wasm.pointFromScalar(outputlen) === 1
+            ? PUBLIC_KEY_INPUT.slice(0, outputlen)
+            : null;
+    }
+    finally {
+        PRIVATE_KEY_INPUT.fill(0);
+        PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function xOnlyPointFromScalar(d) {
+    validate.validatePrivate(d);
+    try {
+        PRIVATE_KEY_INPUT.set(d);
+        wasm.xOnlyPointFromScalar();
+        return X_ONLY_PUBLIC_KEY_INPUT.slice(0, validate.X_ONLY_PUBLIC_KEY_SIZE);
+    }
+    finally {
+        PRIVATE_KEY_INPUT.fill(0);
+        X_ONLY_PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function xOnlyPointFromPoint(p) {
+    validate.validatePoint(p);
+    try {
+        PUBLIC_KEY_INPUT.set(p);
+        wasm.xOnlyPointFromPoint(p.length);
+        return X_ONLY_PUBLIC_KEY_INPUT.slice(0, validate.X_ONLY_PUBLIC_KEY_SIZE);
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+        X_ONLY_PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function pointMultiply(p, tweak, compressed) {
+    validate.validatePoint(p);
+    validate.validateTweak(tweak);
+    const outputlen = assumeCompression(compressed, p);
+    try {
+        PUBLIC_KEY_INPUT.set(p);
+        TWEAK_INPUT.set(tweak);
+        return wasm.pointMultiply(p.length, outputlen) === 1
+            ? PUBLIC_KEY_INPUT.slice(0, outputlen)
+            : null;
+    }
+    finally {
+        PUBLIC_KEY_INPUT.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function privateAdd(d, tweak) {
+    validate.validatePrivate(d);
+    validate.validateTweak(tweak);
+    try {
+        PRIVATE_KEY_INPUT.set(d);
+        TWEAK_INPUT.set(tweak);
+        return wasm.privateAdd() === 1
+            ? PRIVATE_KEY_INPUT.slice(0, validate.PRIVATE_KEY_SIZE)
+            : null;
+    }
+    finally {
+        PRIVATE_KEY_INPUT.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function privateSub(d, tweak) {
+    validate.validatePrivate(d);
+    validate.validateTweak(tweak);
+    // We can not pass zero tweak to WASM, because WASM use `secp256k1_ec_seckey_negate` for tweak negate.
+    // (zero is not valid seckey)
+    if (validate.isZero(tweak)) {
+        return new Uint8Array(d);
+    }
+    try {
+        PRIVATE_KEY_INPUT.set(d);
+        TWEAK_INPUT.set(tweak);
+        return wasm.privateSub() === 1
+            ? PRIVATE_KEY_INPUT.slice(0, validate.PRIVATE_KEY_SIZE)
+            : null;
+    }
+    finally {
+        PRIVATE_KEY_INPUT.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function privateNegate(d) {
+    validate.validatePrivate(d);
+    try {
+        PRIVATE_KEY_INPUT.set(d);
+        wasm.privateNegate();
+        return PRIVATE_KEY_INPUT.slice(0, validate.PRIVATE_KEY_SIZE);
+    }
+    finally {
+        PRIVATE_KEY_INPUT.fill(0);
+    }
+}
+export function xOnlyPointAddTweak(p, tweak) {
+    validate.validateXOnlyPoint(p);
+    validate.validateTweak(tweak);
+    try {
+        X_ONLY_PUBLIC_KEY_INPUT.set(p);
+        TWEAK_INPUT.set(tweak);
+        const parity = wasm.xOnlyPointAddTweak();
+        return parity !== -1
+            ? {
+                parity,
+                xOnlyPubkey: X_ONLY_PUBLIC_KEY_INPUT.slice(0, validate.X_ONLY_PUBLIC_KEY_SIZE),
+            }
+            : null;
+    }
+    finally {
+        X_ONLY_PUBLIC_KEY_INPUT.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function xOnlyPointAddTweakCheck(point, tweak, resultToCheck, tweakParity) {
+    validate.validateXOnlyPoint(point);
+    validate.validateXOnlyPoint(resultToCheck);
+    validate.validateTweak(tweak);
+    const hasParity = tweakParity !== undefined;
+    if (hasParity)
+        validate.validateParity(tweakParity);
+    try {
+        X_ONLY_PUBLIC_KEY_INPUT.set(point);
+        X_ONLY_PUBLIC_KEY_INPUT2.set(resultToCheck);
+        TWEAK_INPUT.set(tweak);
+        if (hasParity) {
+            return wasm.xOnlyPointAddTweakCheck(tweakParity) === 1;
+        }
+        else {
+            wasm.xOnlyPointAddTweak();
+            const newKey = X_ONLY_PUBLIC_KEY_INPUT.slice(0, validate.X_ONLY_PUBLIC_KEY_SIZE);
+            return compare(newKey, resultToCheck) === 0;
+        }
+    }
+    finally {
+        X_ONLY_PUBLIC_KEY_INPUT.fill(0);
+        X_ONLY_PUBLIC_KEY_INPUT2.fill(0);
+        TWEAK_INPUT.fill(0);
+    }
+}
+export function sign(h, d, e) {
+    validate.validateHash(h);
+    validate.validatePrivate(d);
+    validate.validateExtraData(e);
+    try {
+        HASH_INPUT.set(h);
+        PRIVATE_KEY_INPUT.set(d);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.set(e);
+        wasm.sign(e === undefined ? 0 : 1);
+        return SIGNATURE_INPUT.slice(0, validate.SIGNATURE_SIZE);
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        PRIVATE_KEY_INPUT.fill(0);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+    }
+}
+export function signRecoverable(h, d, e) {
+    validate.validateHash(h);
+    validate.validatePrivate(d);
+    validate.validateExtraData(e);
+    try {
+        HASH_INPUT.set(h);
+        PRIVATE_KEY_INPUT.set(d);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.set(e);
+        const recoveryId = wasm.signRecoverable(e === undefined ? 0 : 1);
+        const signature = SIGNATURE_INPUT.slice(0, validate.SIGNATURE_SIZE);
+        return {
+            signature,
+            recoveryId,
+        };
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        PRIVATE_KEY_INPUT.fill(0);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+    }
+}
+export function signSchnorr(h, d, e) {
+    validate.validateHash(h);
+    validate.validatePrivate(d);
+    validate.validateExtraData(e);
+    try {
+        HASH_INPUT.set(h);
+        PRIVATE_KEY_INPUT.set(d);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.set(e);
+        wasm.signSchnorr(e === undefined ? 0 : 1);
+        return SIGNATURE_INPUT.slice(0, validate.SIGNATURE_SIZE);
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        PRIVATE_KEY_INPUT.fill(0);
+        if (e !== undefined)
+            EXTRA_DATA_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+    }
+}
+export function verify(h, Q, signature, strict = false) {
+    validate.validateHash(h);
+    validate.validatePoint(Q);
+    validate.validateSignature(signature);
+    try {
+        HASH_INPUT.set(h);
+        PUBLIC_KEY_INPUT.set(Q);
+        SIGNATURE_INPUT.set(signature);
+        return wasm.verify(Q.length, strict === true ? 1 : 0) === 1 ? true : false;
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        PUBLIC_KEY_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+    }
+}
+export function recover(h, signature, recoveryId, compressed = false) {
+    validate.validateHash(h);
+    validate.validateSignature(signature);
+    validate.validateSignatureNonzeroRS(signature);
+    if (recoveryId & 2) {
+        validate.validateSigrPMinusN(signature);
+    }
+    validate.validateSignatureCustom(() => isXOnlyPoint(signature.subarray(0, 32)));
+    const outputlen = assumeCompression(compressed);
+    try {
+        HASH_INPUT.set(h);
+        SIGNATURE_INPUT.set(signature);
+        return wasm.recover(outputlen, recoveryId) === 1
+            ? PUBLIC_KEY_INPUT.slice(0, outputlen)
+            : null;
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+        PUBLIC_KEY_INPUT.fill(0);
+    }
+}
+export function verifySchnorr(h, Q, signature) {
+    validate.validateHash(h);
+    validate.validateXOnlyPoint(Q);
+    validate.validateSignature(signature);
+    try {
+        HASH_INPUT.set(h);
+        X_ONLY_PUBLIC_KEY_INPUT.set(Q);
+        SIGNATURE_INPUT.set(signature);
+        return wasm.verifySchnorr() === 1 ? true : false;
+    }
+    finally {
+        HASH_INPUT.fill(0);
+        X_ONLY_PUBLIC_KEY_INPUT.fill(0);
+        SIGNATURE_INPUT.fill(0);
+    }
+}

package/lib/rand.browser.d.ts

@@ -0,0 +1 @@
+export declare function generateInt32(): number;

package/lib/rand.browser.js

@@ -0,0 +1,16 @@
+function get4RandomBytes() {
+    const bytes = new Uint8Array(4);
+    if (typeof crypto === "undefined") {
+        throw new Error("The crypto object is unavailable. This may occur if your environment does not support the Web Cryptography API.");
+    }
+    crypto.getRandomValues(bytes);
+    return bytes;
+}
+// Only to be used to initialize the context for rust-secp256k1
+export function generateInt32() {
+    const array = get4RandomBytes();
+    return ((array[0] << (3 * 8)) +
+        (array[1] << (2 * 8)) +
+        (array[2] << (1 * 8)) +
+        array[3]);
+}

package/lib/rand.d.ts

@@ -0,0 +1 @@
+export declare function generateInt32(): number;

package/lib/rand.js

@@ -0,0 +1,4 @@
+import { randomBytes } from "crypto";
+export function generateInt32() {
+    return randomBytes(4).readInt32BE(0);
+}