@theqrl/qrl-cryptography 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Patricio Palladino, Paul Miller, ethereum-cryptography contributors
+Copyright (c) 2024 The QRL Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+# @theqrl/qrl-cryptography
+
+All pure-js cryptographic primitives normally used when
+developing Javascript / TypeScript applications and tools for QRL.
+
+The cryptographic primitives included are:
+
+* [Hashes: keccak-256](#hasheskeccak-256)
+* [KDFs: Argon2id](#kdfs-argon2id)
+* [CSPRNG (Cryptographically strong pseudorandom number generator)](#csprng-cryptographically-strong-pseudorandom-number-generator)
+* [AES Encryption](#aes-encryption)
+* [ML-DSA-87](#ml-dsa-87)
+
+## Usage
+
+Use NPM / Yarn in node.js / browser:
+
+```bash
+# NPM
+npm install @theqrl/qrl-cryptography
+
+# Yarn
+yarn add @theqrl/qrl-cryptography
+```
+
+See [browser usage](#browser-usage) for information on using the package with major Javascript bundlers. It is
+tested with **Webpack, Rollup and Parcel**.
+
+This package has no single entry-point, but submodule for each cryptographic
+primitive. Read each primitive's section of this document to learn how to use
+them.
+
+The reason for this is that importing everything from a single file will lead to
+huge bundles when using this package for the web. This could be avoided through
+tree-shaking, but the possibility of it not working properly on one of
+[the supported bundlers](#browser-usage) is too high.
+
+```js
+// Hashes
+const { keccak256 } = require("@theqrl/qrl-cryptography/keccak");
+
+// KDFs
+const { argon2idSync } = require("@theqrl/qrl-cryptography/argon2id");
+
+// Random
+const { getRandomBytesSync } = require("@theqrl/qrl-cryptography/random");
+
+// AES encryption
+const { encrypt } = require("@theqrl/qrl-cryptography/aes");
+
+// ML-DSA-87
+const { ml_dsa87 } = require("@theqrl/qrl-cryptography/ml_dsa87");
+
+// utilities
+const { hexToBytes, toHex, utf8ToBytes } = require("@theqrl/qrl-cryptography/utils");
+```
+
+## Hashes: keccak-256
+```typescript
+function keccak256(msg: Uint8Array): Uint8Array;
+```
+
+Exposes following cryptographic hash functions:
+
+- keccak-256 variant of SHA3 (also `keccak224`, `keccak384`,
+and `keccak512`)
+
+```js
+const { keccak256, keccak224, keccak384, keccak512 } = require("@theqrl/qrl-cryptography/keccak");
+
+keccak256(Uint8Array.from([1, 2, 3]))
+
+// Can be used with strings
+const { utf8ToBytes } = require("@theqrl/qrl-cryptography/utils");
+keccak256(utf8ToBytes("abc"))
+
+// If you need hex
+const { bytesToHex as toHex } = require("@theqrl/qrl-cryptography/utils");
+toHex(keccak256(utf8ToBytes("abc")))
+```
+
+## KDFs: Argon2id
+
+```ts
+function argon2id(password: Uint8Array, salt: Uint8Array, t: number, m: number, p: number, dkLen: number, onProgress?: (progress: number) => void): Promise<Uint8Array>;
+function argon2idSync(password: Uint8Array, salt: Uint8Array, t: number, m: number, p: number, dkLen: number, onProgress?: (progress: number) => void): Uint8Array;
+```
+
+The `argon2id` submodule has two functions implementing the Argon2id key
+derivation algorithm in synchronous and asynchronous ways. This algorithm is
+very slow, and using the synchronous version in the browser is not recommended,
+as it will block its main thread and hang your UI.
+
+```js
+const { argon2id } = require("@theqrl/qrl-cryptography/argon2id");
+const { utf8ToBytes } = require("@theqrl/qrl-cryptography/utils");
+console.log(await argon2id(utf8ToBytes("password"), utf8ToBytes("salt"), 8, 262144, 1, 32));
+```
+
+## CSPRNG (Cryptographically strong pseudorandom number generator)
+
+```ts
+function getRandomBytes(bytes: number): Promise<Uint8Array>;
+function getRandomBytesSync(bytes: number): Uint8Array;
+```
+
+The `random` submodule has functions to generate cryptographically strong
+pseudo-random data in synchronous and asynchronous ways.
+
+Backed by [`crypto.getRandomValues`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) in browser and by [`crypto.randomBytes`](https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback) in node.js. If backends are somehow not available, the module would throw an error and won't work, as keeping them working would be insecure.
+
+```js
+const { getRandomBytesSync } = require("@theqrl/qrl-cryptography/random");
+console.log(getRandomBytesSync(32));
+```
+
+## AES Encryption
+
+```ts
+function encrypt(msg: Uint8Array, key: Uint8Array, iv: Uint8Array, mode = "aes-256-gcm", pkcs7PaddingEnabled = true): Promise<Uint8Array>;
+function decrypt(cypherText: Uint8Array, key: Uint8Array, iv: Uint8Array, mode = "aes-256-gcm", pkcs7PaddingEnabled = true): Promise<Uint8Array>;
+```
+
+The `aes` submodule contains encryption and decryption functions implementing
+the [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
+algorithm.
+
+### Encrypting with passwords
+
+AES is not supposed to be used directly with a password. Doing that will
+compromise your users' security.
+
+The `key` parameters in this submodule are meant to be strong cryptographic
+keys. If you want to obtain such a key from a password, please use a
+[key derivation function](https://en.wikipedia.org/wiki/Key_derivation_function)
+like [argon2id](#kdfs-argon2id).
+
+### Operation modes
+
+This submodule works with different [block cipher modes of operation](https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation). If you are using this module in a new
+application, we recommend using the default.
+
+While this module may work with any mode supported by OpenSSL, we only test it
+with `aes-256-gcm`. If you use another module a warning will be printed in the
+ console.
+
+We only recommend using `aes-256-gcm` to decrypt already encrypted data.
+
+### Padding plaintext messages
+
+Some operation modes require the plaintext message to be a multiple of `16`. If
+that isn't the case, your message has to be padded.
+
+By default, this module automatically pads your messages according to [PKCS#7](https://tools.ietf.org/html/rfc2315).
+Note that this padding scheme always adds at least 1 byte of padding. If you
+are unsure what anything of this means, we **strongly** recommend you to use
+the defaults.
+
+If you need to encrypt without padding or want to use another padding scheme,
+you can disable PKCS#7 padding by passing `false` as the last argument and
+handling padding yourself. Note that if you do this and your operation mode
+requires padding, `encrypt` will throw if your plaintext message isn't a
+multiple of `16`.
+
+This option is only present to enable the decryption of already encrypted data.
+To encrypt new data, we recommend using the default.
+
+### How to use the IV parameter
+
+The `iv` parameter of the `encrypt` function must be unique, or the security
+of the encryption algorithm can be compromised.
+
+You can generate a new `iv` using the `random` module.
+
+Note that to decrypt a value, you have to provide the same `iv` used to encrypt
+it.
+
+### How to handle errors with this module
+
+Sensitive information can be leaked via error messages when using this module.
+To avoid this, you should make sure that the errors you return don't
+contain the exact reason for the error. Instead, errors must report general
+encryption/decryption failures.
+
+Note that implementing this can mean catching all errors that can be thrown
+when calling on of this module's functions, and just throwing a new generic
+exception.
+
+### Example usage
+
+```js
+const { encrypt } = require("@theqrl/qrl-cryptography/aes");
+const { hexToBytes, utf8ToBytes } = require("@theqrl/qrl-cryptography/utils");
+
+console.log(
+  encrypt(
+    utf8ToBytes("message"),
+    hexToBytes("2b7e151628aed2a6abf7158809cf4f3c"),
+    hexToBytes("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff")
+  )
+);
+```
+
+## ML-DSA-87
+
+```ts
+function keygen(seed: Uint8Array): { publicKey: Uint8Array; secretKey: Uint8Array };
+function sign(secretKey: Uint8Array, message: Uint8Array, ctx: Uint8Array): Uint8Array;
+function verify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array, ctx: Uint8Array): boolean;
+```
+
+The `ml_dsa87` submodule provides the ML-DSA-87 (FIPS 204) post-quantum digital signature scheme, powered by [`@theqrl/mldsa87`](https://www.npmjs.com/package/@theqrl/mldsa87).
+
+```js
+const { ml_dsa87 } = require("@theqrl/qrl-cryptography/ml_dsa87");
+const { utf8ToBytes } = require("@theqrl/qrl-cryptography/utils");
+
+// Generate a key pair
+const { publicKey, secretKey } = ml_dsa87.keygen(seed);
+
+// Sign a message
+const ctx = utf8ToBytes("context");
+const msg = utf8ToBytes("hello");
+const signature = ml_dsa87.sign(secretKey, msg, ctx);
+
+// Verify a signature
+const isValid = ml_dsa87.verify(publicKey, msg, signature, ctx);
+```
+
+## Browser usage
+
+### Rollup setup
+
+Using this library with Rollup requires the following plugins:
+
+* [`@rollup/plugin-commonjs`](https://www.npmjs.com/package/@rollup/plugin-commonjs)
+* [`@rollup/plugin-node-resolve`](https://www.npmjs.com/package/@rollup/plugin-node-resolve)
+
+These can be used by setting your `plugins` array like this:
+
+```js
+  plugins: [
+    commonjs(),
+    resolve({
+      browser: true,
+      preferBuiltins: false,
+    }),
+  ]
+```
+
+## License
+
+`qrl-cryptography` is released under The MIT License (MIT)
+
+Copyright (c) 2021 Patricio Palladino, Paul Miller, ethereum-cryptography contributors
+Copyright (c) 2024 The QRL Contributors
+
+See [LICENSE](./LICENSE) file.

package/aes.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(msg: Uint8Array, key: Uint8Array, iv: Uint8Array, mode?: string, pkcs7PaddingEnabled?: boolean): Promise<Uint8Array>;
+export declare function decrypt(cypherText: Uint8Array, key: Uint8Array, iv: Uint8Array, mode?: string, pkcs7PaddingEnabled?: boolean): Promise<Uint8Array>;

package/aes.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const crypto_1 = require("@noble/hashes/crypto");
+const utils_1 = require("./utils");
+const crypto = { web: crypto_1.crypto };
+function validateOpt(key, iv, mode) {
+    if (!mode.startsWith("aes-")) {
+        throw new Error(`AES submodule doesn't support mode ${mode}`);
+    }
+    if (iv.length !== 12) {
+        throw new Error("AES: wrong IV length");
+    }
+    if (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-256-gcm"].includes(mode)) {
+        keyMode = "gcm";
+    }
+    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"]);
+    // TODO(rgeraldes24): missing fields
+    // 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 }];
+}
+async function encrypt(msg, key, iv, mode = "aes-256-gcm", 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);
+        let res = new Uint8Array(cipher);
+        return res;
+    }
+    else if (crypto.node) {
+        const cipher = crypto.node.createCipheriv(mode, key, iv);
+        cipher.setAutoPadding(pkcs7PaddingEnabled);
+        return (0, utils_1.concatBytes)(cipher.update(msg), cipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}
+exports.encrypt = encrypt;
+async function decrypt(cypherText, key, iv, mode = "aes-256-gcm", pkcs7PaddingEnabled = true) {
+    validateOpt(key, iv, mode);
+    if (crypto.web) {
+        const [wKey, wOpt] = await getBrowserKey(mode, key, iv);
+        const msg = await crypto.web.subtle.decrypt(wOpt, wKey, cypherText);
+        const msgBytes = new Uint8Array(msg);
+        return msgBytes;
+    }
+    else if (crypto.node) {
+        const decipher = crypto.node.createDecipheriv(mode, key, iv);
+        decipher.setAutoPadding(pkcs7PaddingEnabled);
+        return (0, utils_1.concatBytes)(decipher.update(cypherText), decipher.final());
+    }
+    else {
+        throw new Error("The environment doesn't have AES module");
+    }
+}
+exports.decrypt = decrypt;

package/argon2id.d.ts

@@ -0,0 +1,4 @@
+type OnProgressCallback = (progress: number) => void;
+export declare function argon2id(password: Uint8Array, salt: Uint8Array, t: number, m: number, p: number, dkLen: number, onProgress?: OnProgressCallback): Promise<Uint8Array>;
+export declare function argon2idSync(password: Uint8Array, salt: Uint8Array, t: number, m: number, p: number, dkLen: number, onProgress?: OnProgressCallback): Uint8Array;
+export {};

package/argon2id.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argon2idSync = exports.argon2id = void 0;
+const argon2_1 = require("@noble/hashes/argon2");
+const utils_1 = require("./utils");
+async function argon2id(password, salt, t, m, p, dkLen, onProgress) {
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, argon2_1.argon2idAsync)(password, salt, { t, m, p, dkLen, onProgress });
+}
+exports.argon2id = argon2id;
+function argon2idSync(password, salt, t, m, p, dkLen, onProgress) {
+    (0, utils_1.assertBytes)(password);
+    (0, utils_1.assertBytes)(salt);
+    return (0, argon2_1.argon2id)(password, salt, { t, m, p, dkLen, onProgress });
+}
+exports.argon2idSync = argon2idSync;

package/eslint.config.js

@@ -0,0 +1,25 @@
+const tseslint = require("@typescript-eslint/eslint-plugin");
+const tsparser = require("@typescript-eslint/parser");
+const prettier = require("eslint-plugin-prettier");
+
+module.exports = [
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      parser: tsparser,
+    },
+    plugins: {
+      "@typescript-eslint": tseslint,
+      prettier: prettier,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-unused-vars": "warn",
+      "prettier/prettier": "error",
+    },
+  },
+  {
+    ignores: ["node_modules", "test-builds", "*.js", "*.d.ts"],
+  },
+];

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_1 = require("./utils");
+exports.keccak224 = (0, utils_1.wrapHash)(sha3_1.keccak_224);
+exports.keccak256 = (() => {
+    const k = (0, utils_1.wrapHash)(sha3_1.keccak_256);
+    k.create = sha3_1.keccak_256.create;
+    return k;
+})();
+exports.keccak384 = (0, utils_1.wrapHash)(sha3_1.keccak_384);
+exports.keccak512 = (0, utils_1.wrapHash)(sha3_1.keccak_512);

package/ml_dsa87.d.ts

@@ -0,0 +1,8 @@
+export declare const ml_dsa87: {
+    keygen(seed: Uint8Array): {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    sign(secretKey: Uint8Array, message: Uint8Array, ctx: Uint8Array): Uint8Array;
+    verify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array, ctx: Uint8Array): boolean;
+};

package/ml_dsa87.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ml_dsa87 = void 0;
+const mldsa87_1 = require("@theqrl/mldsa87");
+exports.ml_dsa87 = {
+    keygen(seed) {
+        const pk = new Uint8Array(mldsa87_1.CryptoPublicKeyBytes);
+        const sk = new Uint8Array(mldsa87_1.CryptoSecretKeyBytes);
+        (0, mldsa87_1.cryptoSignKeypair)(seed, pk, sk);
+        return { publicKey: pk, secretKey: sk };
+    },
+    sign(secretKey, message, ctx) {
+        const sig = new Uint8Array(mldsa87_1.CryptoBytes);
+        (0, mldsa87_1.cryptoSignSignature)(sig, message, secretKey, false, ctx);
+        return sig;
+    },
+    verify(publicKey, message, signature, ctx) {
+        return (0, mldsa87_1.cryptoSignVerify)(signature, message, publicKey, ctx);
+    },
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@theqrl/qrl-cryptography",
+  "version": "0.1.0",
+  "description": "All the cryptographic primitives used in QRL",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theQRL/js-qrl-cryptography.git"
+  },
+  "license": "MIT",
+  "main": "./index.js",
+  "files": [
+    "*.js",
+    "*.d.ts"
+  ],
+  "dependencies": {
+    "@noble/curves": "1.0.0",
+    "@noble/hashes": "1.6.1",
+    "@theqrl/mldsa87": "2.0.1"
+  },
+  "browser": {
+    "crypto": false
+  },
+  "sideEffects": false,
+  "scripts": {
+    "prepare": "npm run build",
+    "build": "npm-run-all build:tsc",
+    "build:tsc": "tsc --project tsconfig.prod.json",
+    "test": "npm-run-all test:node",
+    "test:node": "mocha",
+    "clean": "rimraf test-builds '*.js' '*.js.map' '*.d.ts' '*.d.ts.map' 'src/**/*.js'",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "browser-tests": "npm-run-all browser-tests:build browser-tests:test",
+    "browser-tests:build": "bash -x ./scripts/build-browser-tests.sh",
+    "browser-tests:test": "npm-run-all browser-tests:test-parcel browser-tests:test-webpack browser-tests:test-rollup",
+    "browser-tests:test-parcel": "karma start --single-run --browsers ChromeHeadless test/karma.parcel.conf.js",
+    "browser-tests:test-webpack": "karma start --single-run --browsers ChromeHeadless test/karma.webpack.conf.js",
+    "browser-tests:test-rollup": "karma start --single-run --browsers ChromeHeadless test/karma.rollup.conf.js"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "29.0.2",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@types/estree": "1.0.8",
+    "@types/mocha": "9.1.1",
+    "@types/node": "18.15.11",
+    "@typescript-eslint/eslint-plugin": "8.58.0",
+    "@typescript-eslint/parser": "8.58.0",
+    "eslint": "9.26.0",
+    "eslint-plugin-prettier": "5.5.5",
+    "karma": "6.4.0",
+    "karma-chrome-launcher": "3.1.1",
+    "karma-mocha": "2.0.1",
+    "karma-mocha-reporter": "2.2.5",
+    "mocha": "10.0.0",
+    "npm-run-all": "4.1.5",
+    "parcel": "2.6.2",
+    "prettier": "3.8.1",
+    "rimraf": "~3.0.2",
+    "rollup": "4.59.0",
+    "ts-node": "10.9.1",
+    "typescript": "5.0.2",
+    "webpack": "5.104.1",
+    "webpack-cli": "4.10"
+  },
+  "keywords": [
+    "qrl",
+    "cryptography",
+    "digital signature",
+    "hash",
+    "encryption",
+    "prng",
+    "keccak",
+    "argon2id",
+    "aes",
+    "advanced encryption standar"
+  ],
+  "targets": {
+    "parcel_tests": {
+      "context": "browser"
+    }
+  }
+}

package/random.d.ts

@@ -0,0 +1,2 @@
+export declare function getRandomBytesSync(bytes: number): Uint8Array;
+export declare function getRandomBytes(bytes: number): Promise<Uint8Array>;

package/random.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomBytes = exports.getRandomBytesSync = void 0;
+const utils_1 = require("@noble/hashes/utils");
+function getRandomBytesSync(bytes) {
+    return (0, utils_1.randomBytes)(bytes);
+}
+exports.getRandomBytesSync = getRandomBytesSync;
+async function getRandomBytes(bytes) {
+    return (0, utils_1.randomBytes)(bytes);
+}
+exports.getRandomBytes = getRandomBytes;

package/utils.d.ts

@@ -0,0 +1,11 @@
+declare const assertBytes: typeof import("@noble/hashes/_assert").abytes;
+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?: Crypto;
+};

package/utils.js

@@ -0,0 +1,62 @@
+"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 = void 0;
+// buf.toString('hex') -> toHex(buf)
+const _assert_1 = __importDefault(require("@noble/hashes/_assert"));
+const utils_1 = require("@noble/hashes/utils");
+// const assertBool = assert.bool;
+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;
+exports.crypto = (() => {
+    const webCrypto = typeof self === "object" && "crypto" in self ? self.crypto : undefined;
+    const nodeRequire = typeof module !== "undefined" &&
+        typeof module.require === "function" &&
+        module.require.bind(module);
+    return {
+        node: nodeRequire && !webCrypto ? nodeRequire("crypto") : undefined,
+        web: webCrypto,
+    };
+})();