ethereum-cryptographyy 2.1.2

package/bip39/wordlists/italian.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var italian_1 = require("@scure/bip39/wordlists/italian");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return italian_1.wordlist; } });

package/bip39/wordlists/japanese.d.ts

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/japanese";

package/bip39/wordlists/japanese.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var japanese_1 = require("@scure/bip39/wordlists/japanese");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return japanese_1.wordlist; } });

package/bip39/wordlists/korean.d.ts

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/korean";

package/bip39/wordlists/korean.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var korean_1 = require("@scure/bip39/wordlists/korean");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return korean_1.wordlist; } });

package/bip39/wordlists/simplified-chinese.d.ts

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/simplified-chinese";

package/bip39/wordlists/simplified-chinese.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var simplified_chinese_1 = require("@scure/bip39/wordlists/simplified-chinese");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return simplified_chinese_1.wordlist; } });

package/bip39/wordlists/spanish.d.ts

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/spanish";

package/bip39/wordlists/spanish.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var spanish_1 = require("@scure/bip39/wordlists/spanish");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return spanish_1.wordlist; } });

package/bip39/wordlists/traditional-chinese.d.ts

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/traditional-chinese";

package/bip39/wordlists/traditional-chinese.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordlist = void 0;
+var traditional_chinese_1 = require("@scure/bip39/wordlists/traditional-chinese");
+Object.defineProperty(exports, "wordlist", { enumerable: true, get: function () { return traditional_chinese_1.wordlist; } });

package/blake2b.d.ts

@@ -0,0 +1 @@
+export declare const blake2b: (msg: Uint8Array, outputLength?: number) => Uint8Array;

package/blake2b.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake2b = void 0;
+const blake2b_1 = require("@noble/hashes/blake2b");
+const utils_js_1 = require("./utils.js");
+const blake2b = (msg, outputLength = 64) => {
+    (0, utils_js_1.assertBytes)(msg);
+    if (outputLength <= 0 || outputLength > 64) {
+        throw Error("Invalid outputLength");
+    }
+    return (0, blake2b_1.blake2b)(msg, { dkLen: outputLength });
+};
+exports.blake2b = blake2b;

package/esm/aes.js

@@ -0,0 +1,93 @@
+import { crypto as cr } from "@noble/hashes/crypto";
+import { concatBytes, equalsBytes } from "./utils.js";
+const crypto = { web: cr };
+function validateOpt(key, iv, mode) {
+    if (!mode.startsWith("aes-")) {
+        throw new Error(`AES submodule doesn't support mode ${mode}`);
+    }
+    if (iv.length !== 16) {
+        throw new Error("AES: wrong IV length");
+    }
+    if ((mode.startsWith("aes-128") && key.length !== 16) ||
+        (mode.startsWith("aes-256") && key.length !== 32)) {
+        throw new Error("AES: wrong key length");
+    }
+}
+async function getBrowserKey(mode, key, iv) {
+    if (!crypto.web) {
+        throw new Error("Browser crypto not available.");
+    }
+    let keyMode;
+    if (["aes-128-cbc", "aes-256-cbc"].includes(mode)) {
+        keyMode = "cbc";
+    }
+    if (["aes-128-ctr", "aes-256-ctr"].includes(mode)) {
+        keyMode = "ctr";
+    }
+    if (!keyMode) {
+        throw new Error("AES: unsupported mode");
+    }
+    const wKey = await crypto.web.subtle.importKey("raw", key, { name: `AES-${keyMode.toUpperCase()}`, length: key.length * 8 }, true, ["encrypt", "decrypt"]);
+    // node.js uses whole 128 bit as a counter, without nonce, instead of 64 bit
+    // recommended by NIST SP800-38A
+    return [wKey, { name: `aes-${keyMode}`, iv, counter: iv, length: 128 }];
+}
+export async function encrypt(msg, key, iv, mode = "aes-128-ctr", pkcs7PaddingEnabled = true) {
+    validateOpt(key, iv, mode);
+    if (crypto.web) {
+        const [wKey, wOpt] = await getBrowserKey(mode, key, iv);
+        const cipher = await crypto.web.subtle.encrypt(wOpt, wKey, msg);
+        // Remove PKCS7 padding on cbc mode by stripping end of message
+        let res = new Uint8Array(cipher);
+        if (!pkcs7PaddingEnabled && wOpt.name === "aes-cbc" && !(msg.length % 16)) {
+            res = res.slice(0, -16);
+        }
+        return res;
+    }
+    else if (crypto.node) {
+        const cipher = crypto.node.createCipheriv(mode, key, iv);
+        cipher.setAutoPadding(pkcs7PaddingEnabled);
+        return concatBytes(cipher.update(msg), cipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}
+async function getPadding(cypherText, key, iv, mode) {
+    const lastBlock = cypherText.slice(-16);
+    for (let i = 0; i < 16; i++) {
+        // Undo xor of iv and fill with lastBlock ^ padding (16)
+        lastBlock[i] ^= iv[i] ^ 16;
+    }
+    const res = await encrypt(lastBlock, key, iv, mode);
+    return res.slice(0, 16);
+}
+export async function decrypt(cypherText, key, iv, mode = "aes-128-ctr", pkcs7PaddingEnabled = true) {
+    validateOpt(key, iv, mode);
+    if (crypto.web) {
+        const [wKey, wOpt] = await getBrowserKey(mode, key, iv);
+        // Add empty padding so Chrome will correctly decrypt message
+        if (!pkcs7PaddingEnabled && wOpt.name === "aes-cbc") {
+            const padding = await getPadding(cypherText, key, iv, mode);
+            cypherText = concatBytes(cypherText, padding);
+        }
+        const msg = await crypto.web.subtle.decrypt(wOpt, wKey, cypherText);
+        const msgBytes = new Uint8Array(msg);
+        // Safari always ignores padding (if no padding -> broken message)
+        if (wOpt.name === "aes-cbc") {
+            const encrypted = await encrypt(msgBytes, key, iv, mode);
+            if (!equalsBytes(encrypted, cypherText)) {
+                throw new Error("AES: wrong padding");
+            }
+        }
+        return msgBytes;
+    }
+    else if (crypto.node) {
+        const decipher = crypto.node.createDecipheriv(mode, key, iv);
+        decipher.setAutoPadding(pkcs7PaddingEnabled);
+        return concatBytes(decipher.update(cypherText), decipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}

package/esm/bip39/index.js

@@ -0,0 +1 @@
+export { generateMnemonic, mnemonicToEntropy, entropyToMnemonic, validateMnemonic, mnemonicToSeed, mnemonicToSeedSync } from "@scure/bip39";

package/esm/bip39/wordlists/czech.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/czech";

package/esm/bip39/wordlists/english.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/english";

package/esm/bip39/wordlists/french.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/french";

package/esm/bip39/wordlists/italian.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/italian";

package/esm/bip39/wordlists/japanese.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/japanese";

package/esm/bip39/wordlists/korean.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/korean";

package/esm/bip39/wordlists/simplified-chinese.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/simplified-chinese";

package/esm/bip39/wordlists/spanish.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/spanish";

package/esm/bip39/wordlists/traditional-chinese.js

@@ -0,0 +1 @@
+export { wordlist } from "@scure/bip39/wordlists/traditional-chinese";

package/esm/blake2b.js

@@ -0,0 +1,9 @@
+import { blake2b as _blake2b } from "@noble/hashes/blake2b";
+import { assertBytes } from "./utils.js";
+export const blake2b = (msg, outputLength = 64) => {
+    assertBytes(msg);
+    if (outputLength <= 0 || outputLength > 64) {
+        throw Error("Invalid outputLength");
+    }
+    return _blake2b(msg, { dkLen: outputLength });
+};

package/esm/hdkey.js

@@ -0,0 +1 @@
+export { HARDENED_OFFSET, HDKey } from "@scure/bip32";

package/esm/index.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("This package has no entry-point. Please consult the README.md to learn how to use it.");

package/esm/keccak.js

@@ -0,0 +1,10 @@
+import { keccak_224, keccak_256, keccak_384, keccak_512 } from "@noble/hashes/sha3";
+import { wrapHash } from "./utils.js";
+export const keccak224 = wrapHash(keccak_224);
+export const keccak256 = (() => {
+    const k = wrapHash(keccak_256);
+    k.create = keccak_256.create;
+    return k;
+})();
+export const keccak384 = wrapHash(keccak_384);
+export const keccak512 = wrapHash(keccak_512);

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/pbkdf2.js

@@ -0,0 +1,26 @@
+import { pbkdf2 as _pbkdf2, pbkdf2Async as _pbkdf2Async } from "@noble/hashes/pbkdf2";
+import { sha256 } from "@noble/hashes/sha256";
+import { sha512 } from "@noble/hashes/sha512";
+import { assertBytes } from "./utils.js";
+export async function pbkdf2(password, salt, iterations, keylen, digest) {
+    if (!["sha256", "sha512"].includes(digest)) {
+        throw new Error("Only sha256 and sha512 are supported");
+    }
+    assertBytes(password);
+    assertBytes(salt);
+    return _pbkdf2Async(digest === "sha256" ? sha256 : sha512, password, salt, {
+        c: iterations,
+        dkLen: keylen
+    });
+}
+export function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+    if (!["sha256", "sha512"].includes(digest)) {
+        throw new Error("Only sha256 and sha512 are supported");
+    }
+    assertBytes(password);
+    assertBytes(salt);
+    return _pbkdf2(digest === "sha256" ? sha256 : sha512, password, salt, {
+        c: iterations,
+        dkLen: keylen
+    });
+}

package/esm/random.js

@@ -0,0 +1,7 @@
+import { randomBytes } from "@noble/hashes/utils";
+export function getRandomBytesSync(bytes) {
+    return randomBytes(bytes);
+}
+export async function getRandomBytes(bytes) {
+    return randomBytes(bytes);
+}

package/esm/ripemd160.js

@@ -0,0 +1,3 @@
+import { ripemd160 as _ripemd160 } from "@noble/hashes/ripemd160";
+import { wrapHash } from "./utils.js";
+export const ripemd160 = wrapHash(_ripemd160);

package/esm/scrypt.js

@@ -0,0 +1,12 @@
+import { scrypt as _sync, scryptAsync as _async } from "@noble/hashes/scrypt";
+import { assertBytes } from "./utils.js";
+export async function scrypt(password, salt, n, p, r, dkLen, onProgress) {
+    assertBytes(password);
+    assertBytes(salt);
+    return _async(password, salt, { N: n, r, p, dkLen, onProgress });
+}
+export function scryptSync(password, salt, n, p, r, dkLen, onProgress) {
+    assertBytes(password);
+    assertBytes(salt);
+    return _sync(password, salt, { N: n, r, p, dkLen, onProgress });
+}

package/esm/secp256k1-compat.js

@@ -0,0 +1,254 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { mod } from "@noble/curves/abstract/modular";
+import { secp256k1 } from "./secp256k1.js";
+import { assertBool, assertBytes, hexToBytes, toHex } from "./utils.js";
+// Use `secp256k1` module directly.
+// This is a legacy compatibility layer for the npm package `secp256k1` via noble-secp256k1
+const Point = 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(toHex(bytes));
+const numberToHex = (num) => num.toString(16).padStart(64, "0");
+const numberToBytes = (num) => hexToBytes(numberToHex(num));
+const ORDER = secp256k1.CURVE.n;
+function output(out = (len) => new Uint8Array(len), length, value) {
+    if (typeof out === "function") {
+        out = out(length);
+    }
+    assertBytes(out, length);
+    if (value) {
+        out.set(value);
+    }
+    return out;
+}
+function getSignature(signature) {
+    assertBytes(signature, 64);
+    return secp256k1.Signature.fromCompact(signature);
+}
+export function createPrivateKeySync() {
+    return secp256k1.utils.randomPrivateKey();
+}
+export async function createPrivateKey() {
+    return createPrivateKeySync();
+}
+export function privateKeyVerify(privateKey) {
+    assertBytes(privateKey, 32);
+    return secp256k1.utils.isValidPrivateKey(privateKey);
+}
+export function publicKeyCreate(privateKey, compressed = true, out) {
+    assertBytes(privateKey, 32);
+    assertBool(compressed);
+    const res = secp256k1.getPublicKey(privateKey, compressed);
+    return output(out, compressed ? 33 : 65, res);
+}
+export function publicKeyVerify(publicKey) {
+    assertBytes(publicKey, 33, 65);
+    try {
+        Point.fromHex(publicKey);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function publicKeyConvert(publicKey, compressed = true, out) {
+    assertBytes(publicKey, 33, 65);
+    assertBool(compressed);
+    const res = Point.fromHex(publicKey).toRawBytes(compressed);
+    return output(out, compressed ? 33 : 65, res);
+}
+export function ecdsaSign(msgHash, privateKey, options = { noncefn: undefined, data: undefined }, out) {
+    assertBytes(msgHash, 32);
+    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.sign(msgHash, privateKey);
+    const recid = sig.recovery;
+    return { signature: output(out, 64, sig.toCompactRawBytes()), recid };
+}
+export function ecdsaRecover(signature, recid, msgHash, compressed = true, out) {
+    assertBytes(msgHash, 32);
+    assertBool(compressed);
+    const sign = getSignature(signature);
+    const point = sign.addRecoveryBit(recid).recoverPublicKey(msgHash);
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+export function ecdsaVerify(signature, msgHash, publicKey) {
+    assertBytes(signature, 64);
+    assertBytes(msgHash, 32);
+    assertBytes(publicKey, 33, 65);
+    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.verify(sig, msgHash, publicKey);
+}
+export function privateKeyTweakAdd(privateKey, tweak) {
+    assertBytes(privateKey, 32);
+    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(hexToBytes(numberToHex(t)));
+    return privateKey;
+}
+export function privateKeyNegate(privateKey) {
+    assertBytes(privateKey, 32);
+    const bn = mod(-bytesToNumber(privateKey), ORDER);
+    privateKey.set(hexToBytes(numberToHex(bn)));
+    return privateKey;
+}
+export function publicKeyNegate(publicKey, compressed = true, out) {
+    assertBytes(publicKey, 33, 65);
+    assertBool(compressed);
+    const point = Point.fromHex(publicKey).negate();
+    return output(out, compressed ? 33 : 65, point.toRawBytes(compressed));
+}
+export 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) {
+        assertBytes(publicKey, 33, 65);
+    }
+    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));
+}
+export function publicKeyTweakAdd(publicKey, tweak, compressed = true, out) {
+    assertBytes(publicKey, 33, 65);
+    assertBytes(tweak, 32);
+    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));
+}
+export function publicKeyTweakMul(publicKey, tweak, compressed = true, out) {
+    assertBytes(publicKey, 33, 65);
+    assertBytes(tweak, 32);
+    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));
+}
+export function privateKeyTweakMul(privateKey, tweak) {
+    assertBytes(privateKey, 32);
+    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 = 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(hexToBytes(numberToHex(res)));
+    return privateKey;
+}
+// internal -> DER
+export function signatureExport(signature, out) {
+    const res = getSignature(signature).toDERRawBytes();
+    return output(out, 72, res.slice()).slice(0, res.length);
+}
+// DER -> internal
+export function signatureImport(signature, out) {
+    assertBytes(signature);
+    const sig = secp256k1.Signature.fromDER(signature);
+    return output(out, 64, hexToBytes(sig.toCompactHex()));
+}
+export function signatureNormalize(signature) {
+    const res = getSignature(signature);
+    if (res.s > ORDER / 2n) {
+        signature.set(numberToBytes(ORDER - res.s), 32);
+    }
+    return signature;
+}
+export function ecdh(publicKey, privateKey, options = {}, out) {
+    assertBytes(publicKey, 33, 65);
+    assertBytes(privateKey, 32);
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("secp256k1.ecdh: options should be object");
+    }
+    if (options.data !== undefined) {
+        assertBytes(options.data);
+    }
+    const point = Point.fromHex(secp256k1.getSharedSecret(privateKey, publicKey));
+    if (options.hashfn === undefined) {
+        return output(out, 32, sha256(point.toRawBytes(true)));
+    }
+    if (typeof options.hashfn !== "function") {
+        throw new TypeError("secp256k1.ecdh: options.hashfn should be function");
+    }
+    if (options.xbuf !== undefined) {
+        assertBytes(options.xbuf, 32);
+    }
+    if (options.ybuf !== undefined) {
+        assertBytes(options.ybuf, 32);
+    }
+    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);
+}
+export function contextRandomize(seed) {
+    if (seed !== null) {
+        assertBytes(seed, 32);
+    }
+    // There is no context to randomize
+}

package/esm/secp256k1.js

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

package/esm/sha256.js

@@ -0,0 +1,3 @@
+import { sha256 as _sha256 } from "@noble/hashes/sha256";
+import { wrapHash } from "./utils.js";
+export const sha256 = wrapHash(_sha256);

package/esm/sha512.js

@@ -0,0 +1,3 @@
+import { sha512 as _sha512 } from "@noble/hashes/sha512";
+import { wrapHash } from "./utils.js";
+export const sha512 = wrapHash(_sha512);

package/esm/utils.js

@@ -0,0 +1,47 @@
+import assert from "@noble/hashes/_assert";
+import { hexToBytes as _hexToBytes } from "@noble/hashes/utils";
+const assertBool = assert.bool;
+const assertBytes = assert.bytes;
+export { assertBool, assertBytes };
+export { bytesToHex, bytesToHex as toHex, concatBytes, createView, utf8ToBytes } from "@noble/hashes/utils";
+// buf.toString('utf8') -> bytesToUtf8(buf)
+export function bytesToUtf8(data) {
+    if (!(data instanceof Uint8Array)) {
+        throw new TypeError(`bytesToUtf8 expected Uint8Array, got ${typeof data}`);
+    }
+    return new TextDecoder().decode(data);
+}
+export function hexToBytes(data) {
+    const sliced = data.startsWith("0x") ? data.substring(2) : data;
+    return _hexToBytes(sliced);
+}
+// buf.equals(buf2) -> equalsBytes(buf, buf2)
+export 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;
+}
+// Internal utils
+export function wrapHash(hash) {
+    return (msg) => {
+        assert.bytes(msg);
+        return hash(msg);
+    };
+}
+// TODO(v3): switch away from node crypto, remove this unnecessary variable.
+export const 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
+    };
+})();

package/hdkey.d.ts

@@ -0,0 +1 @@
+export { HARDENED_OFFSET, HDKey } from "@scure/bip32";

package/hdkey.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HDKey = exports.HARDENED_OFFSET = void 0;
+var bip32_1 = require("@scure/bip32");
+Object.defineProperty(exports, "HARDENED_OFFSET", { enumerable: true, get: function () { return bip32_1.HARDENED_OFFSET; } });
+Object.defineProperty(exports, "HDKey", { enumerable: true, get: function () { return bip32_1.HDKey; } });

package/index.js

@@ -0,0 +1,2 @@
+"use strict";
+throw new Error("This package has no entry-point. Please consult the README.md to learn how to use it.");

package/keccak.d.ts

@@ -0,0 +1,11 @@
+import { Keccak } from "@noble/hashes/sha3";
+import { Hash } from "@noble/hashes/utils";
+interface K256 {
+    (data: Uint8Array): Uint8Array;
+    create(): Hash<Keccak>;
+}
+export declare const keccak224: (msg: Uint8Array) => Uint8Array;
+export declare const keccak256: K256;
+export declare const keccak384: (msg: Uint8Array) => Uint8Array;
+export declare const keccak512: (msg: Uint8Array) => Uint8Array;
+export {};

package/keccak.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak512 = exports.keccak384 = exports.keccak256 = exports.keccak224 = void 0;
+const sha3_1 = require("@noble/hashes/sha3");
+const utils_js_1 = require("./utils.js");
+exports.keccak224 = (0, utils_js_1.wrapHash)(sha3_1.keccak_224);
+exports.keccak256 = (() => {
+    const k = (0, utils_js_1.wrapHash)(sha3_1.keccak_256);
+    k.create = sha3_1.keccak_256.create;
+    return k;
+})();
+exports.keccak384 = (0, utils_js_1.wrapHash)(sha3_1.keccak_384);
+exports.keccak512 = (0, utils_js_1.wrapHash)(sha3_1.keccak_512);