ethereum-cryptographyy 2.1.2

package/secp256k1-compat.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextRandomize = exports.ecdh = exports.signatureNormalize = exports.signatureImport = exports.signatureExport = exports.privateKeyTweakMul = exports.publicKeyTweakMul = exports.publicKeyTweakAdd = exports.publicKeyCombine = exports.publicKeyNegate = exports.privateKeyNegate = exports.privateKeyTweakAdd = exports.ecdsaVerify = exports.ecdsaRecover = exports.ecdsaSign = exports.publicKeyConvert = exports.publicKeyVerify = exports.publicKeyCreate = exports.privateKeyVerify = exports.createPrivateKey = exports.createPrivateKeySync = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+const modular_1 = require("@noble/curves/abstract/modular");
+const secp256k1_js_1 = require("./secp256k1.js");
+const utils_js_1 = require("./utils.js");
+// Use `secp256k1` module directly.
+// This is a legacy compatibility layer for the npm package `secp256k1` via noble-secp256k1
+const Point = secp256k1_js_1.secp256k1.ProjectivePoint;
+function hexToNumber(hex) {
+    if (typeof hex !== "string") {
+        throw new TypeError("hexToNumber: expected string, got " + typeof hex);
+    }
+    return BigInt(`0x${hex}`);
+}
+// Copy-paste from secp256k1, maybe export it?
+const bytesToNumber = (bytes) => hexToNumber((0, utils_js_1.toHex)(bytes));
+const numberToHex = (num) => num.toString(16).padStart(64, "0");
+const numberToBytes = (num) => (0, utils_js_1.hexToBytes)(numberToHex(num));
+const ORDER = secp256k1_js_1.secp256k1.CURVE.n;
+function output(out = (len) => new Uint8Array(len), length, value) {
+    if (typeof out === "function") {
+        out = out(length);
+    }
+    (0, utils_js_1.assertBytes)(out, length);
+    if (value) {
+        out.set(value);
+    }
+    return out;
+}
+function getSignature(signature) {
+    (0, utils_js_1.assertBytes)(signature, 64);
+    return secp256k1_js_1.secp256k1.Signature.fromCompact(signature);
+}
+function createPrivateKeySync() {
+    return secp256k1_js_1.secp256k1.utils.randomPrivateKey();
+}
+exports.createPrivateKeySync = createPrivateKeySync;
+async function createPrivateKey() {
+    return createPrivateKeySync();
+}
+exports.createPrivateKey = createPrivateKey;
+function privateKeyVerify(privateKey) {
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    return secp256k1_js_1.secp256k1.utils.isValidPrivateKey(privateKey);
+}
+exports.privateKeyVerify = privateKeyVerify;
+function publicKeyCreate(privateKey, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    (0, utils_js_1.assertBool)(compressed);
+    const res = secp256k1_js_1.secp256k1.getPublicKey(privateKey, compressed);
+    return output(out, compressed ? 33 : 65, res);
+}
+exports.publicKeyCreate = publicKeyCreate;
+function publicKeyVerify(publicKey) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    try {
+        Point.fromHex(publicKey);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.publicKeyVerify = publicKeyVerify;
+function publicKeyConvert(publicKey, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBool)(compressed);
+    const res = Point.fromHex(publicKey).toRawBytes(compressed);
+    return output(out, compressed ? 33 : 65, res);
+}
+exports.publicKeyConvert = publicKeyConvert;
+function ecdsaSign(msgHash, privateKey, options = { noncefn: undefined, data: undefined }, out) {
+    (0, utils_js_1.assertBytes)(msgHash, 32);
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("secp256k1.ecdsaSign: options should be object");
+    }
+    // noble-secp256k1 uses hmac instead of hmac-drbg here
+    if (options &&
+        (options.noncefn !== undefined || options.data !== undefined)) {
+        throw new Error("Secp256k1: noncefn && data is unsupported");
+    }
+    const sig = secp256k1_js_1.secp256k1.sign(msgHash, privateKey);
+    const recid = sig.recovery;
+    return { signature: output(out, 64, sig.toCompactRawBytes()), recid };
+}
+exports.ecdsaSign = ecdsaSign;
+function ecdsaRecover(signature, recid, msgHash, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(msgHash, 32);
+    (0, utils_js_1.assertBool)(compressed);
+    const sign = getSignature(signature);
+    const point = sign.addRecoveryBit(recid).recoverPublicKey(msgHash);
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+exports.ecdsaRecover = ecdsaRecover;
+function ecdsaVerify(signature, msgHash, publicKey) {
+    (0, utils_js_1.assertBytes)(signature, 64);
+    (0, utils_js_1.assertBytes)(msgHash, 32);
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBytes)(signature, 64);
+    const r = bytesToNumber(signature.slice(0, 32));
+    const s = bytesToNumber(signature.slice(32, 64));
+    if (r >= ORDER || s >= ORDER) {
+        throw new Error("Cannot parse signature");
+    }
+    const pub = Point.fromHex(publicKey); // can throw error
+    pub; // typescript
+    let sig;
+    try {
+        sig = getSignature(signature);
+    }
+    catch (error) {
+        return false;
+    }
+    return secp256k1_js_1.secp256k1.verify(sig, msgHash, publicKey);
+}
+exports.ecdsaVerify = ecdsaVerify;
+function privateKeyTweakAdd(privateKey, tweak) {
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    (0, utils_js_1.assertBytes)(tweak, 32);
+    let t = bytesToNumber(tweak);
+    if (t === 0n) {
+        throw new Error("Tweak must not be zero");
+    }
+    if (t >= ORDER) {
+        throw new Error("Tweak bigger than curve order");
+    }
+    t += bytesToNumber(privateKey);
+    if (t >= ORDER) {
+        t -= ORDER;
+    }
+    if (t === 0n) {
+        throw new Error("The tweak was out of range or the resulted private key is invalid");
+    }
+    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(t)));
+    return privateKey;
+}
+exports.privateKeyTweakAdd = privateKeyTweakAdd;
+function privateKeyNegate(privateKey) {
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    const bn = (0, modular_1.mod)(-bytesToNumber(privateKey), ORDER);
+    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(bn)));
+    return privateKey;
+}
+exports.privateKeyNegate = privateKeyNegate;
+function publicKeyNegate(publicKey, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBool)(compressed);
+    const point = Point.fromHex(publicKey).negate();
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+exports.publicKeyNegate = publicKeyNegate;
+function publicKeyCombine(publicKeys, compressed = true, out) {
+    if (!Array.isArray(publicKeys) || !publicKeys.length) {
+        throw new TypeError(`Expected array with one or more items, not ${publicKeys}`);
+    }
+    for (const publicKey of publicKeys) {
+        (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    }
+    (0, utils_js_1.assertBool)(compressed);
+    const combined = publicKeys
+        .map((pub) => Point.fromHex(pub))
+        .reduce((res, curr) => res.add(curr), Point.ZERO);
+    // Prohibit returning ZERO point
+    if (combined.equals(Point.ZERO)) {
+        throw new Error("Combined result must not be zero");
+    }
+    return output(out, compressed ? 33 : 65, combined.toRawBytes(compressed));
+}
+exports.publicKeyCombine = publicKeyCombine;
+function publicKeyTweakAdd(publicKey, tweak, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBytes)(tweak, 32);
+    (0, utils_js_1.assertBool)(compressed);
+    const p1 = Point.fromHex(publicKey);
+    const p2 = Point.fromPrivateKey(tweak);
+    const point = p1.add(p2);
+    if (p2.equals(Point.ZERO) || point.equals(Point.ZERO)) {
+        throw new Error("Tweak must not be zero");
+    }
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+exports.publicKeyTweakAdd = publicKeyTweakAdd;
+function publicKeyTweakMul(publicKey, tweak, compressed = true, out) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBytes)(tweak, 32);
+    (0, utils_js_1.assertBool)(compressed);
+    const bn = bytesToNumber(tweak);
+    if (bn === 0n) {
+        throw new Error("Tweak must not be zero");
+    }
+    if (bn <= 1 || bn >= ORDER) {
+        throw new Error("Tweak is zero or bigger than curve order");
+    }
+    const point = Point.fromHex(publicKey).multiply(bn);
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+exports.publicKeyTweakMul = publicKeyTweakMul;
+function privateKeyTweakMul(privateKey, tweak) {
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    (0, utils_js_1.assertBytes)(tweak, 32);
+    const bn = bytesToNumber(tweak);
+    if (bn <= 1 || bn >= ORDER) {
+        throw new Error("Tweak is zero or bigger than curve order");
+    }
+    const res = (0, modular_1.mod)(bn * bytesToNumber(privateKey), ORDER);
+    if (res === 0n) {
+        throw new Error("The tweak was out of range or the resulted private key is invalid");
+    }
+    privateKey.set((0, utils_js_1.hexToBytes)(numberToHex(res)));
+    return privateKey;
+}
+exports.privateKeyTweakMul = privateKeyTweakMul;
+// internal -> DER
+function signatureExport(signature, out) {
+    const res = getSignature(signature).toDERRawBytes();
+    return output(out, 72, res.slice()).slice(0, res.length);
+}
+exports.signatureExport = signatureExport;
+// DER -> internal
+function signatureImport(signature, out) {
+    (0, utils_js_1.assertBytes)(signature);
+    const sig = secp256k1_js_1.secp256k1.Signature.fromDER(signature);
+    return output(out, 64, (0, utils_js_1.hexToBytes)(sig.toCompactHex()));
+}
+exports.signatureImport = signatureImport;
+function signatureNormalize(signature) {
+    const res = getSignature(signature);
+    if (res.s > ORDER / 2n) {
+        signature.set(numberToBytes(ORDER - res.s), 32);
+    }
+    return signature;
+}
+exports.signatureNormalize = signatureNormalize;
+function ecdh(publicKey, privateKey, options = {}, out) {
+    (0, utils_js_1.assertBytes)(publicKey, 33, 65);
+    (0, utils_js_1.assertBytes)(privateKey, 32);
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("secp256k1.ecdh: options should be object");
+    }
+    if (options.data !== undefined) {
+        (0, utils_js_1.assertBytes)(options.data);
+    }
+    const point = Point.fromHex(secp256k1_js_1.secp256k1.getSharedSecret(privateKey, publicKey));
+    if (options.hashfn === undefined) {
+        return output(out, 32, (0, sha256_1.sha256)(point.toRawBytes(true)));
+    }
+    if (typeof options.hashfn !== "function") {
+        throw new TypeError("secp256k1.ecdh: options.hashfn should be function");
+    }
+    if (options.xbuf !== undefined) {
+        (0, utils_js_1.assertBytes)(options.xbuf, 32);
+    }
+    if (options.ybuf !== undefined) {
+        (0, utils_js_1.assertBytes)(options.ybuf, 32);
+    }
+    (0, utils_js_1.assertBytes)(out, 32);
+    const { x, y } = point.toAffine();
+    const xbuf = options.xbuf || new Uint8Array(32);
+    xbuf.set(numberToBytes(x));
+    const ybuf = options.ybuf || new Uint8Array(32);
+    ybuf.set(numberToBytes(y));
+    const hash = options.hashfn(xbuf, ybuf, options.data);
+    if (!(hash instanceof Uint8Array) || hash.length !== 32) {
+        throw new Error("secp256k1.ecdh: invalid options.hashfn output");
+    }
+    return output(out, 32, hash);
+}
+exports.ecdh = ecdh;
+function contextRandomize(seed) {
+    if (seed !== null) {
+        (0, utils_js_1.assertBytes)(seed, 32);
+    }
+    // There is no context to randomize
+}
+exports.contextRandomize = contextRandomize;

package/secp256k1.d.ts

@@ -0,0 +1 @@
+export { secp256k1 } from "@jackshanyeshuzi/curvess/secp256k1";

package/secp256k1.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secp256k1 = void 0;
+var secp256k1_1 = require("@jackshanyeshuzi/curvess/secp256k1");
+Object.defineProperty(exports, "secp256k1", { enumerable: true, get: function () { return secp256k1_1.secp256k1; } });

package/sha256.d.ts

@@ -0,0 +1 @@
+export declare const sha256: (msg: Uint8Array) => Uint8Array;

package/sha256.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = void 0;
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_js_1 = require("./utils.js");
+exports.sha256 = (0, utils_js_1.wrapHash)(sha256_1.sha256);

package/sha512.d.ts

@@ -0,0 +1 @@
+export declare const sha512: (msg: Uint8Array) => Uint8Array;

package/sha512.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha512 = void 0;
+const sha512_1 = require("@noble/hashes/sha512");
+const utils_js_1 = require("./utils.js");
+exports.sha512 = (0, utils_js_1.wrapHash)(sha512_1.sha512);

package/utils.d.ts

@@ -0,0 +1,12 @@
+declare const assertBool: typeof import("@noble/hashes/_assert").bool;
+declare const assertBytes: typeof import("@noble/hashes/_assert").bytes;
+export { assertBool, assertBytes };
+export { bytesToHex, bytesToHex as toHex, concatBytes, createView, utf8ToBytes } from "@noble/hashes/utils";
+export declare function bytesToUtf8(data: Uint8Array): string;
+export declare function hexToBytes(data: string): Uint8Array;
+export declare function equalsBytes(a: Uint8Array, b: Uint8Array): boolean;
+export declare function wrapHash(hash: (msg: Uint8Array) => Uint8Array): (msg: Uint8Array) => Uint8Array;
+export declare const crypto: {
+    node?: any;
+    web?: any;
+};

package/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crypto = exports.wrapHash = exports.equalsBytes = exports.hexToBytes = exports.bytesToUtf8 = exports.utf8ToBytes = exports.createView = exports.concatBytes = exports.toHex = exports.bytesToHex = exports.assertBytes = exports.assertBool = void 0;
+const _assert_1 = __importDefault(require("@noble/hashes/_assert"));
+const utils_1 = require("@noble/hashes/utils");
+const assertBool = _assert_1.default.bool;
+exports.assertBool = assertBool;
+const assertBytes = _assert_1.default.bytes;
+exports.assertBytes = assertBytes;
+var utils_2 = require("@noble/hashes/utils");
+Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
+Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return utils_2.bytesToHex; } });
+Object.defineProperty(exports, "concatBytes", { enumerable: true, get: function () { return utils_2.concatBytes; } });
+Object.defineProperty(exports, "createView", { enumerable: true, get: function () { return utils_2.createView; } });
+Object.defineProperty(exports, "utf8ToBytes", { enumerable: true, get: function () { return utils_2.utf8ToBytes; } });
+// buf.toString('utf8') -> bytesToUtf8(buf)
+function bytesToUtf8(data) {
+    if (!(data instanceof Uint8Array)) {
+        throw new TypeError(`bytesToUtf8 expected Uint8Array, got ${typeof data}`);
+    }
+    return new TextDecoder().decode(data);
+}
+exports.bytesToUtf8 = bytesToUtf8;
+function hexToBytes(data) {
+    const sliced = data.startsWith("0x") ? data.substring(2) : data;
+    return (0, utils_1.hexToBytes)(sliced);
+}
+exports.hexToBytes = hexToBytes;
+// buf.equals(buf2) -> equalsBytes(buf, buf2)
+function equalsBytes(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalsBytes = equalsBytes;
+// Internal utils
+function wrapHash(hash) {
+    return (msg) => {
+        _assert_1.default.bytes(msg);
+        return hash(msg);
+    };
+}
+exports.wrapHash = wrapHash;
+// TODO(v3): switch away from node crypto, remove this unnecessary variable.
+exports.crypto = (() => {
+    const webCrypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : undefined;
+    const nodeRequire = typeof module !== "undefined" &&
+        typeof module.require === "function" &&
+        module.require.bind(module);
+    return {
+        node: nodeRequire && !webCrypto ? nodeRequire("crypto") : undefined,
+        web: webCrypto
+    };
+})();