@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/cjs/keccak/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccakAsU8a = exports.keccakAsHex = exports.keccak512AsU8a = exports.keccak256AsU8a = void 0;
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+var asU8a_js_1 = require("./asU8a.js");
+Object.defineProperty(exports, "keccak256AsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccak256AsU8a; } });
+Object.defineProperty(exports, "keccak512AsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccak512AsU8a; } });
+Object.defineProperty(exports, "keccakAsHex", { enumerable: true, get: function () { return asU8a_js_1.keccakAsHex; } });
+Object.defineProperty(exports, "keccakAsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccakAsU8a; } });

package/cjs/key/DeriveJunction.d.ts

@@ -0,0 +1,12 @@
+import { BN } from '@polkadot/util';
+export declare class DeriveJunction {
+    #private;
+    static from(value: string): DeriveJunction;
+    get chainCode(): Uint8Array;
+    get isHard(): boolean;
+    get isSoft(): boolean;
+    hard(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    harden(): DeriveJunction;
+    soft(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    soften(): DeriveJunction;
+}

package/cjs/key/DeriveJunction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeriveJunction = void 0;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const bn_js_1 = require("../bn.js");
+const RE_NUMBER = /^\d+$/;
+const JUNCTION_ID_LEN = 32;
+class DeriveJunction {
+    #chainCode = new Uint8Array(32);
+    #isHard = false;
+    static from(value) {
+        const result = new DeriveJunction();
+        const [code, isHard] = value.startsWith('/')
+            ? [value.substring(1), true]
+            : [value, false];
+        result.soft(RE_NUMBER.test(code)
+            ? new util_1.BN(code, 10)
+            : code);
+        return isHard
+            ? result.harden()
+            : result;
+    }
+    get chainCode() {
+        return this.#chainCode;
+    }
+    get isHard() {
+        return this.#isHard;
+    }
+    get isSoft() {
+        return !this.#isHard;
+    }
+    hard(value) {
+        return this.soft(value).harden();
+    }
+    harden() {
+        this.#isHard = true;
+        return this;
+    }
+    soft(value) {
+        if ((0, util_1.isNumber)(value) || (0, util_1.isBn)(value) || (0, util_1.isBigInt)(value)) {
+            return this.soft((0, util_1.bnToU8a)(value, bn_js_1.BN_LE_256_OPTS));
+        }
+        else if ((0, util_1.isHex)(value)) {
+            return this.soft((0, util_1.hexToU8a)(value));
+        }
+        else if ((0, util_1.isString)(value)) {
+            return this.soft((0, util_1.compactAddLength)((0, util_1.stringToU8a)(value)));
+        }
+        else if (value.length > JUNCTION_ID_LEN) {
+            return this.soft((0, asU8a_js_1.blake2AsU8a)(value));
+        }
+        this.#chainCode.fill(0);
+        this.#chainCode.set(value, 0);
+        return this;
+    }
+    soften() {
+        this.#isHard = false;
+        return this;
+    }
+}
+exports.DeriveJunction = DeriveJunction;

package/cjs/key/extractPath.d.ts

@@ -0,0 +1,9 @@
+import { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    parts: string[] | null;
+    path: DeriveJunction[];
+}
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+export declare function keyExtractPath(derivePath: string): ExtractResult;

package/cjs/key/extractPath.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyExtractPath = keyExtractPath;
+const DeriveJunction_js_1 = require("./DeriveJunction.js");
+const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+function keyExtractPath(derivePath) {
+    const parts = derivePath.match(RE_JUNCTION);
+    const path = [];
+    let constructed = '';
+    if (parts) {
+        constructed = parts.join('');
+        for (const p of parts) {
+            path.push(DeriveJunction_js_1.DeriveJunction.from(p.substring(1)));
+        }
+    }
+    if (constructed !== derivePath) {
+        throw new Error(`Re-constructed path "${constructed}" does not match input`);
+    }
+    return {
+        parts,
+        path
+    };
+}

package/cjs/key/extractSuri.d.ts

@@ -0,0 +1,11 @@
+import type { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    derivePath: string;
+    password?: string;
+    path: DeriveJunction[];
+    phrase: string;
+}
+/**
+ * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
+ */
+export declare function keyExtractSuri(suri: string): ExtractResult;

package/cjs/key/extractSuri.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyExtractSuri = keyExtractSuri;
+const extractPath_js_1 = require("./extractPath.js");
+const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
+/**
+ * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
+ */
+function keyExtractSuri(suri) {
+    // Normalize Unicode to NFC to avoid accent-related mismatches
+    const normalizedSuri = suri.normalize('NFC');
+    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+    const matches = normalizedSuri.match(RE_CAPTURE);
+    if (matches === null) {
+        throw new Error('Unable to match provided value to a secret URI');
+    }
+    const [, phrase, , derivePath, , , password] = matches;
+    const { path } = (0, extractPath_js_1.keyExtractPath)(derivePath);
+    return {
+        derivePath,
+        password,
+        path,
+        phrase
+    };
+}

package/cjs/key/fromPath.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair, KeypairType } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyFromPath(pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair;

package/cjs/key/fromPath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyFromPath = keyFromPath;
+const hdkdEcdsa_js_1 = require("./hdkdEcdsa.js");
+const hdkdEd25519_js_1 = require("./hdkdEd25519.js");
+const hdkdSr25519_js_1 = require("./hdkdSr25519.js");
+const generators = {
+    ecdsa: hdkdEcdsa_js_1.keyHdkdEcdsa,
+    ed25519: hdkdEd25519_js_1.keyHdkdEd25519,
+    // FIXME This is Substrate-compatible, not Ethereum-compatible
+    ethereum: hdkdEcdsa_js_1.keyHdkdEcdsa,
+    sr25519: hdkdSr25519_js_1.keyHdkdSr25519
+};
+function keyFromPath(pair, path, type) {
+    const keyHdkd = generators[type];
+    let result = pair;
+    for (const junction of path) {
+        result = keyHdkd(result, junction);
+    }
+    return result;
+}

package/cjs/key/hdkdDerive.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function createSeedDeriveFn(fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair;

package/cjs/key/hdkdDerive.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSeedDeriveFn = createSeedDeriveFn;
+function createSeedDeriveFn(fromSeed, derive) {
+    return (keypair, { chainCode, isHard }) => {
+        if (!isHard) {
+            throw new Error('A soft key was found in the path and is not supported');
+        }
+        return fromSeed(derive(keypair.secretKey.subarray(0, 32), chainCode));
+    };
+}

package/cjs/key/hdkdEcdsa.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEcdsa: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/cjs/key/hdkdEcdsa.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdEcdsa = void 0;
+const deriveHard_js_1 = require("../secp256k1/deriveHard.js");
+const fromSeed_js_1 = require("../secp256k1/pair/fromSeed.js");
+const hdkdDerive_js_1 = require("./hdkdDerive.js");
+exports.keyHdkdEcdsa = (0, hdkdDerive_js_1.createSeedDeriveFn)(fromSeed_js_1.secp256k1PairFromSeed, deriveHard_js_1.secp256k1DeriveHard);

package/cjs/key/hdkdEd25519.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEd25519: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/cjs/key/hdkdEd25519.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdEd25519 = void 0;
+const index_js_1 = require("../ed25519/index.js");
+const hdkdDerive_js_1 = require("./hdkdDerive.js");
+exports.keyHdkdEd25519 = (0, hdkdDerive_js_1.createSeedDeriveFn)(index_js_1.ed25519PairFromSeed, index_js_1.ed25519DeriveHard);

package/cjs/key/hdkdSr25519.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyHdkdSr25519(keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair;

package/cjs/key/hdkdSr25519.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdSr25519 = keyHdkdSr25519;
+const deriveHard_js_1 = require("../sr25519/deriveHard.js");
+const deriveSoft_js_1 = require("../sr25519/deriveSoft.js");
+function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+    return isSoft
+        ? (0, deriveSoft_js_1.sr25519DeriveSoft)(keypair, chainCode)
+        : (0, deriveHard_js_1.sr25519DeriveHard)(keypair, chainCode);
+}

package/{src/key/index.ts → cjs/key/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create keys from paths, seeds and password
  */

package/cjs/key/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdSr25519 = exports.keyHdkdEd25519 = exports.keyHdkdEcdsa = exports.keyFromPath = exports.keyExtractSuri = exports.keyExtractPath = void 0;
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+var extractPath_js_1 = require("./extractPath.js");
+Object.defineProperty(exports, "keyExtractPath", { enumerable: true, get: function () { return extractPath_js_1.keyExtractPath; } });
+var extractSuri_js_1 = require("./extractSuri.js");
+Object.defineProperty(exports, "keyExtractSuri", { enumerable: true, get: function () { return extractSuri_js_1.keyExtractSuri; } });
+var fromPath_js_1 = require("./fromPath.js");
+Object.defineProperty(exports, "keyFromPath", { enumerable: true, get: function () { return fromPath_js_1.keyFromPath; } });
+var hdkdEcdsa_js_1 = require("./hdkdEcdsa.js");
+Object.defineProperty(exports, "keyHdkdEcdsa", { enumerable: true, get: function () { return hdkdEcdsa_js_1.keyHdkdEcdsa; } });
+var hdkdEd25519_js_1 = require("./hdkdEd25519.js");
+Object.defineProperty(exports, "keyHdkdEd25519", { enumerable: true, get: function () { return hdkdEd25519_js_1.keyHdkdEd25519; } });
+var hdkdSr25519_js_1 = require("./hdkdSr25519.js");
+Object.defineProperty(exports, "keyHdkdSr25519", { enumerable: true, get: function () { return hdkdSr25519_js_1.keyHdkdSr25519; } });

package/cjs/mnemonic/bip39.d.ts

@@ -0,0 +1,5 @@
+export declare function mnemonicToSeedSync(mnemonic: string, password?: string): Uint8Array;
+export declare function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): Uint8Array;
+export declare function entropyToMnemonic(entropy: Uint8Array, wordlist?: string[]): string;
+export declare function generateMnemonic(numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string;
+export declare function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;

package/cjs/mnemonic/bip39.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToSeedSync = mnemonicToSeedSync;
+exports.mnemonicToEntropy = mnemonicToEntropy;
+exports.entropyToMnemonic = entropyToMnemonic;
+exports.generateMnemonic = generateMnemonic;
+exports.validateMnemonic = validateMnemonic;
+const tslib_1 = require("tslib");
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../pbkdf2/index.js");
+const index_js_2 = require("../random/index.js");
+const index_js_3 = require("../sha/index.js");
+const en_js_1 = tslib_1.__importDefault(require("./wordlists/en.js"));
+const INVALID_MNEMONIC = 'Invalid mnemonic';
+const INVALID_ENTROPY = 'Invalid entropy';
+const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
+/** @internal */
+function normalize(str) {
+    return (str || '').normalize('NFKD');
+}
+/** @internal */
+function binaryToByte(bin) {
+    return parseInt(bin, 2);
+}
+/** @internal */
+function bytesToBinary(bytes) {
+    return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+}
+/** @internal */
+function deriveChecksumBits(entropyBuffer) {
+    return bytesToBinary(Array.from((0, index_js_3.sha256AsU8a)(entropyBuffer))).slice(0, (entropyBuffer.length * 8) / 32);
+}
+function mnemonicToSeedSync(mnemonic, password) {
+    return (0, index_js_1.pbkdf2Encode)((0, util_1.stringToU8a)(normalize(mnemonic)), (0, util_1.stringToU8a)(`mnemonic${normalize(password)}`)).password;
+}
+function mnemonicToEntropy(mnemonic, wordlist = en_js_1.default) {
+    const words = normalize(mnemonic).split(' ');
+    if (words.length % 3 !== 0) {
+        throw new Error(INVALID_MNEMONIC);
+    }
+    // convert word indices to 11 bit binary strings
+    const bits = words
+        .map((word) => {
+        const index = wordlist.indexOf(word);
+        if (index === -1) {
+            throw new Error(INVALID_MNEMONIC);
+        }
+        return index.toString(2).padStart(11, '0');
+    })
+        .join('');
+    // split the binary string into ENT/CS
+    const dividerIndex = Math.floor(bits.length / 33) * 32;
+    const entropyBits = bits.slice(0, dividerIndex);
+    const checksumBits = bits.slice(dividerIndex);
+    // calculate the checksum and compare
+    const matched = entropyBits.match(/(.{1,8})/g);
+    const entropyBytes = matched?.map(binaryToByte);
+    if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+        throw new Error(INVALID_ENTROPY);
+    }
+    const entropy = (0, util_1.u8aToU8a)(entropyBytes);
+    if (deriveChecksumBits(entropy) !== checksumBits) {
+        throw new Error(INVALID_CHECKSUM);
+    }
+    return entropy;
+}
+function entropyToMnemonic(entropy, wordlist = en_js_1.default) {
+    // 128 <= ENT <= 256
+    if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
+        throw new Error(INVALID_ENTROPY);
+    }
+    const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
+    const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
+    if (!mapped || (mapped.length < 12)) {
+        throw new Error('Unable to map entropy to mnemonic');
+    }
+    return mapped.join(' ');
+}
+function generateMnemonic(numWords, wordlist) {
+    return entropyToMnemonic((0, index_js_2.randomAsU8a)((numWords / 3) * 4), wordlist);
+}
+function validateMnemonic(mnemonic, wordlist) {
+    try {
+        mnemonicToEntropy(mnemonic, wordlist);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}

package/cjs/mnemonic/generate.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @name mnemonicGenerate
+ * @summary Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate } from '@polkadot/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * ```
+ */
+export declare function mnemonicGenerate(numWords?: 12 | 15 | 18 | 21 | 24, wordlist?: string[], onlyJs?: boolean): string;

package/cjs/mnemonic/generate.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicGenerate = mnemonicGenerate;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bip39_js_1 = require("./bip39.js");
+/**
+ * @name mnemonicGenerate
+ * @summary Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * ```
+ */
+function mnemonicGenerate(numWords = 12, wordlist, onlyJs) {
+    return !util_1.hasBigInt || (!wordlist && !onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.bip39Generate)(numWords)
+        : (0, bip39_js_1.generateMnemonic)(numWords, wordlist);
+}

package/{src/mnemonic/index.ts → cjs/mnemonic/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
  */

package/cjs/mnemonic/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicValidate = exports.mnemonicToMiniSecret = exports.mnemonicToLegacySeed = exports.mnemonicToEntropy = exports.mnemonicGenerate = void 0;
+/**
+ * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
+ */
+var generate_js_1 = require("./generate.js");
+Object.defineProperty(exports, "mnemonicGenerate", { enumerable: true, get: function () { return generate_js_1.mnemonicGenerate; } });
+var toEntropy_js_1 = require("./toEntropy.js");
+Object.defineProperty(exports, "mnemonicToEntropy", { enumerable: true, get: function () { return toEntropy_js_1.mnemonicToEntropy; } });
+var toLegacySeed_js_1 = require("./toLegacySeed.js");
+Object.defineProperty(exports, "mnemonicToLegacySeed", { enumerable: true, get: function () { return toLegacySeed_js_1.mnemonicToLegacySeed; } });
+var toMiniSecret_js_1 = require("./toMiniSecret.js");
+Object.defineProperty(exports, "mnemonicToMiniSecret", { enumerable: true, get: function () { return toMiniSecret_js_1.mnemonicToMiniSecret; } });
+var validate_js_1 = require("./validate.js");
+Object.defineProperty(exports, "mnemonicValidate", { enumerable: true, get: function () { return validate_js_1.mnemonicValidate; } });

package/cjs/mnemonic/toEntropy.d.ts

@@ -0,0 +1 @@
+export declare function mnemonicToEntropy(mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array;

package/cjs/mnemonic/toEntropy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToEntropy = mnemonicToEntropy;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bip39_js_1 = require("./bip39.js");
+function mnemonicToEntropy(mnemonic, wordlist, onlyJs) {
+    return !util_1.hasBigInt || (!wordlist && !onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.bip39ToEntropy)(mnemonic)
+        : (0, bip39_js_1.mnemonicToEntropy)(mnemonic, wordlist);
+}

package/cjs/mnemonic/toLegacySeed.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @name mnemonicToLegacySeed
+ * @summary Creates a valid Ethereum/Bitcoin-compatible seed from a mnemonic input
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicToLegacySeed, mnemonicValidate } from '@polkadot/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ *
+ * if (isValidMnemonic) {
+ *   console.log(`Seed generated from mnemonic: ${mnemonicToLegacySeed(mnemonic)}`); => u8a
+ * }
+ * ```
+ */
+export declare function mnemonicToLegacySeed(mnemonic: string, password?: string, onlyJs?: boolean, byteLength?: 32 | 64): Uint8Array;

package/cjs/mnemonic/toLegacySeed.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToLegacySeed = mnemonicToLegacySeed;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bip39_js_1 = require("./bip39.js");
+const validate_js_1 = require("./validate.js");
+/**
+ * @name mnemonicToLegacySeed
+ * @summary Creates a valid Ethereum/Bitcoin-compatible seed from a mnemonic input
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicToLegacySeed, mnemonicValidate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ *
+ * if (isValidMnemonic) {
+ *   console.log(`Seed generated from mnemonic: ${mnemonicToLegacySeed(mnemonic)}`); => u8a
+ * }
+ * ```
+ */
+function mnemonicToLegacySeed(mnemonic, password = '', onlyJs, byteLength = 32) {
+    if (!(0, validate_js_1.mnemonicValidate)(mnemonic)) {
+        throw new Error('Invalid bip39 mnemonic specified');
+    }
+    else if (![32, 64].includes(byteLength)) {
+        throw new Error(`Invalid seed length ${byteLength}, expected 32 or 64`);
+    }
+    return byteLength === 32
+        ? !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+            ? (0, wasm_crypto_1.bip39ToSeed)(mnemonic, password)
+            : (0, bip39_js_1.mnemonicToSeedSync)(mnemonic, password).subarray(0, 32)
+        : (0, bip39_js_1.mnemonicToSeedSync)(mnemonic, password);
+}

package/cjs/mnemonic/toMiniSecret.d.ts

@@ -0,0 +1 @@
+export declare function mnemonicToMiniSecret(mnemonic: string, password?: string, wordlist?: string[], onlyJs?: boolean): Uint8Array;

package/cjs/mnemonic/toMiniSecret.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToMiniSecret = mnemonicToMiniSecret;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const index_js_1 = require("../pbkdf2/index.js");
+const toEntropy_js_1 = require("./toEntropy.js");
+const validate_js_1 = require("./validate.js");
+function mnemonicToMiniSecret(mnemonic, password = '', wordlist, onlyJs) {
+    if (!(0, validate_js_1.mnemonicValidate)(mnemonic, wordlist, onlyJs)) {
+        throw new Error('Invalid bip39 mnemonic specified');
+    }
+    else if (!wordlist && !onlyJs && (0, wasm_crypto_1.isReady)()) {
+        return (0, wasm_crypto_1.bip39ToMiniSecret)(mnemonic, password);
+    }
+    const entropy = (0, toEntropy_js_1.mnemonicToEntropy)(mnemonic, wordlist);
+    const salt = (0, util_1.stringToU8a)(`mnemonic${password}`);
+    // return the first 32 bytes as the seed
+    return (0, index_js_1.pbkdf2Encode)(entropy, salt).password.slice(0, 32);
+}

package/cjs/mnemonic/validate.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @name mnemonicValidate
+ * @summary Validates a mnemonic input using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ * ```
+ */
+export declare function mnemonicValidate(mnemonic: string, wordlist?: string[], onlyJs?: boolean): boolean;

package/cjs/mnemonic/validate.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicValidate = mnemonicValidate;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const bip39_js_1 = require("./bip39.js");
+/**
+ * @name mnemonicValidate
+ * @summary Validates a mnemonic input using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicValidate } from '@pezkuwi/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ * ```
+ */
+function mnemonicValidate(mnemonic, wordlist, onlyJs) {
+    return !util_1.hasBigInt || (!wordlist && !onlyJs && (0, wasm_crypto_1.isReady)())
+        ? (0, wasm_crypto_1.bip39Validate)(mnemonic)
+        : (0, bip39_js_1.validateMnemonic)(mnemonic, wordlist);
+}

package/cjs/mnemonic/wordlists/en.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/cjs/mnemonic/wordlists/en.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = 'abandon|ability|able|about|above|absent|absorb|abstract|absurd|abuse|access|accident|account|accuse|achieve|acid|acoustic|acquire|across|act|action|actor|actress|actual|adapt|add|addict|address|adjust|admit|adult|advance|advice|aerobic|affair|afford|afraid|again|age|agent|agree|ahead|aim|air|airport|aisle|alarm|album|alcohol|alert|alien|all|alley|allow|almost|alone|alpha|already|also|alter|always|amateur|amazing|among|amount|amused|analyst|anchor|ancient|anger|angle|angry|animal|ankle|announce|annual|another|answer|antenna|antique|anxiety|any|apart|apology|appear|apple|approve|april|arch|arctic|area|arena|argue|arm|armed|armor|army|around|arrange|arrest|arrive|arrow|art|artefact|artist|artwork|ask|aspect|assault|asset|assist|assume|asthma|athlete|atom|attack|attend|attitude|attract|auction|audit|august|aunt|author|auto|autumn|average|avocado|avoid|awake|aware|away|awesome|awful|awkward|axis|baby|bachelor|bacon|badge|bag|balance|balcony|ball|bamboo|banana|banner|bar|barely|bargain|barrel|base|basic|basket|battle|beach|bean|beauty|because|become|beef|before|begin|behave|behind|believe|below|belt|bench|benefit|best|betray|better|between|beyond|bicycle|bid|bike|bind|biology|bird|birth|bitter|black|blade|blame|blanket|blast|bleak|bless|blind|blood|blossom|blouse|blue|blur|blush|board|boat|body|boil|bomb|bone|bonus|book|boost|border|boring|borrow|boss|bottom|bounce|box|boy|bracket|brain|brand|brass|brave|bread|breeze|brick|bridge|brief|bright|bring|brisk|broccoli|broken|bronze|broom|brother|brown|brush|bubble|buddy|budget|buffalo|build|bulb|bulk|bullet|bundle|bunker|burden|burger|burst|bus|business|busy|butter|buyer|buzz|cabbage|cabin|cable|cactus|cage|cake|call|calm|camera|camp|can|canal|cancel|candy|cannon|canoe|canvas|canyon|capable|capital|captain|car|carbon|card|cargo|carpet|carry|cart|case|cash|casino|castle|casual|cat|catalog|catch|category|cattle|caught|cause|caution|cave|ceiling|celery|cement|census|century|cereal|certain|chair|chalk|champion|change|chaos|chapter|charge|chase|chat|cheap|check|cheese|chef|cherry|chest|chicken|chief|child|chimney|choice|choose|chronic|chuckle|chunk|churn|cigar|cinnamon|circle|citizen|city|civil|claim|clap|clarify|claw|clay|clean|clerk|clever|click|client|cliff|climb|clinic|clip|clock|clog|close|cloth|cloud|clown|club|clump|cluster|clutch|coach|coast|coconut|code|coffee|coil|coin|collect|color|column|combine|come|comfort|comic|common|company|concert|conduct|confirm|congress|connect|consider|control|convince|cook|cool|copper|copy|coral|core|corn|correct|cost|cotton|couch|country|couple|course|cousin|cover|coyote|crack|cradle|craft|cram|crane|crash|crater|crawl|crazy|cream|credit|creek|crew|cricket|crime|crisp|critic|crop|cross|crouch|crowd|crucial|cruel|cruise|crumble|crunch|crush|cry|crystal|cube|culture|cup|cupboard|curious|current|curtain|curve|cushion|custom|cute|cycle|dad|damage|damp|dance|danger|daring|dash|daughter|dawn|day|deal|debate|debris|decade|december|decide|decline|decorate|decrease|deer|defense|define|defy|degree|delay|deliver|demand|demise|denial|dentist|deny|depart|depend|deposit|depth|deputy|derive|describe|desert|design|desk|despair|destroy|detail|detect|develop|device|devote|diagram|dial|diamond|diary|dice|diesel|diet|differ|digital|dignity|dilemma|dinner|dinosaur|direct|dirt|disagree|discover|disease|dish|dismiss|disorder|display|distance|divert|divide|divorce|dizzy|doctor|document|dog|doll|dolphin|domain|donate|donkey|donor|door|dose|double|dove|draft|dragon|drama|drastic|draw|dream|dress|drift|drill|drink|drip|drive|drop|drum|dry|duck|dumb|dune|during|dust|dutch|duty|dwarf|dynamic|eager|eagle|early|earn|earth|easily|east|easy|echo|ecology|economy|edge|edit|educate|effort|egg|eight|either|elbow|elder|electric|elegant|element|elephant|elevator|elite|else|embark|embody|embrace|emerge|emotion|employ|empower|empty|enable|enact|end|endless|endorse|enemy|energy|enforce|engage|engine|enhance|enjoy|enlist|enough|enrich|enroll|ensure|enter|entire|entry|envelope|episode|equal|equip|era|erase|erode|erosion|error|erupt|escape|essay|essence|estate|eternal|ethics|evidence|evil|evoke|evolve|exact|example|excess|exchange|excite|exclude|excuse|execute|exercise|exhaust|exhibit|exile|exist|exit|exotic|expand|expect|expire|explain|expose|express|extend|extra|eye|eyebrow|fabric|face|faculty|fade|faint|faith|fall|false|fame|family|famous|fan|fancy|fantasy|farm|fashion|fat|fatal|father|fatigue|fault|favorite|feature|february|federal|fee|feed|feel|female|fence|festival|fetch|fever|few|fiber|fiction|field|figure|file|film|filter|final|find|fine|finger|finish|fire|firm|first|fiscal|fish|fit|fitness|fix|flag|flame|flash|flat|flavor|flee|flight|flip|float|flock|floor|flower|fluid|flush|fly|foam|focus|fog|foil|fold|follow|food|foot|force|forest|forget|fork|fortune|forum|forward|fossil|foster|found|fox|fragile|frame|frequent|fresh|friend|fringe|frog|front|frost|frown|frozen|fruit|fuel|fun|funny|furnace|fury|future|gadget|gain|galaxy|gallery|game|gap|garage|garbage|garden|garlic|garment|gas|gasp|gate|gather|gauge|gaze|general|genius|genre|gentle|genuine|gesture|ghost|giant|gift|giggle|ginger|giraffe|girl|give|glad|glance|glare|glass|glide|glimpse|globe|gloom|glory|glove|glow|glue|goat|goddess|gold|good|goose|gorilla|gospel|gossip|govern|gown|grab|grace|grain|grant|grape|grass|gravity|great|green|grid|grief|grit|grocery|group|grow|grunt|guard|guess|guide|guilt|guitar|gun|gym|habit|hair|half|hammer|hamster|hand|happy|harbor|hard|harsh|harvest|hat|have|hawk|hazard|head|health|heart|heavy|hedgehog|height|hello|helmet|help|hen|hero|hidden|high|hill|hint|hip|hire|history|hobby|hockey|hold|hole|holiday|hollow|home|honey|hood|hope|horn|horror|horse|hospital|host|hotel|hour|hover|hub|huge|human|humble|humor|hundred|hungry|hunt|hurdle|hurry|hurt|husband|hybrid|ice|icon|idea|identify|idle|ignore|ill|illegal|illness|image|imitate|immense|immune|impact|impose|improve|impulse|inch|include|income|increase|index|indicate|indoor|industry|infant|inflict|inform|inhale|inherit|initial|inject|injury|inmate|inner|innocent|input|inquiry|insane|insect|inside|inspire|install|intact|interest|into|invest|invite|involve|iron|island|isolate|issue|item|ivory|jacket|jaguar|jar|jazz|jealous|jeans|jelly|jewel|job|join|joke|journey|joy|judge|juice|jump|jungle|junior|junk|just|kangaroo|keen|keep|ketchup|key|kick|kid|kidney|kind|kingdom|kiss|kit|kitchen|kite|kitten|kiwi|knee|knife|knock|know|lab|label|labor|ladder|lady|lake|lamp|language|laptop|large|later|latin|laugh|laundry|lava|law|lawn|lawsuit|layer|lazy|leader|leaf|learn|leave|lecture|left|leg|legal|legend|leisure|lemon|lend|length|lens|leopard|lesson|letter|level|liar|liberty|library|license|life|lift|light|like|limb|limit|link|lion|liquid|list|little|live|lizard|load|loan|lobster|local|lock|logic|lonely|long|loop|lottery|loud|lounge|love|loyal|lucky|luggage|lumber|lunar|lunch|luxury|lyrics|machine|mad|magic|magnet|maid|mail|main|major|make|mammal|man|manage|mandate|mango|mansion|manual|maple|marble|march|margin|marine|market|marriage|mask|mass|master|match|material|math|matrix|matter|maximum|maze|meadow|mean|measure|meat|mechanic|medal|media|melody|melt|member|memory|mention|menu|mercy|merge|merit|merry|mesh|message|metal|method|middle|midnight|milk|million|mimic|mind|minimum|minor|minute|miracle|mirror|misery|miss|mistake|mix|mixed|mixture|mobile|model|modify|mom|moment|monitor|monkey|monster|month|moon|moral|more|morning|mosquito|mother|motion|motor|mountain|mouse|move|movie|much|muffin|mule|multiply|muscle|museum|mushroom|music|must|mutual|myself|mystery|myth|naive|name|napkin|narrow|nasty|nation|nature|near|neck|need|negative|neglect|neither|nephew|nerve|nest|net|network|neutral|never|news|next|nice|night|noble|noise|nominee|noodle|normal|north|nose|notable|note|nothing|notice|novel|now|nuclear|number|nurse|nut|oak|obey|object|oblige|obscure|observe|obtain|obvious|occur|ocean|october|odor|off|offer|office|often|oil|okay|old|olive|olympic|omit|once|one|onion|online|only|open|opera|opinion|oppose|option|orange|orbit|orchard|order|ordinary|organ|orient|original|orphan|ostrich|other|outdoor|outer|output|outside|oval|oven|over|own|owner|oxygen|oyster|ozone|pact|paddle|page|pair|palace|palm|panda|panel|panic|panther|paper|parade|parent|park|parrot|party|pass|patch|path|patient|patrol|pattern|pause|pave|payment|peace|peanut|pear|peasant|pelican|pen|penalty|pencil|people|pepper|perfect|permit|person|pet|phone|photo|phrase|physical|piano|picnic|picture|piece|pig|pigeon|pill|pilot|pink|pioneer|pipe|pistol|pitch|pizza|place|planet|plastic|plate|play|please|pledge|pluck|plug|plunge|poem|poet|point|polar|pole|police|pond|pony|pool|popular|portion|position|possible|post|potato|pottery|poverty|powder|power|practice|praise|predict|prefer|prepare|present|pretty|prevent|price|pride|primary|print|priority|prison|private|prize|problem|process|produce|profit|program|project|promote|proof|property|prosper|protect|proud|provide|public|pudding|pull|pulp|pulse|pumpkin|punch|pupil|puppy|purchase|purity|purpose|purse|push|put|puzzle|pyramid|quality|quantum|quarter|question|quick|quit|quiz|quote|rabbit|raccoon|race|rack|radar|radio|rail|rain|raise|rally|ramp|ranch|random|range|rapid|rare|rate|rather|raven|raw|razor|ready|real|reason|rebel|rebuild|recall|receive|recipe|record|recycle|reduce|reflect|reform|refuse|region|regret|regular|reject|relax|release|relief|rely|remain|remember|remind|remove|render|renew|rent|reopen|repair|repeat|replace|report|require|rescue|resemble|resist|resource|response|result|retire|retreat|return|reunion|reveal|review|reward|rhythm|rib|ribbon|rice|rich|ride|ridge|rifle|right|rigid|ring|riot|ripple|risk|ritual|rival|river|road|roast|robot|robust|rocket|romance|roof|rookie|room|rose|rotate|rough|round|route|royal|rubber|rude|rug|rule|run|runway|rural|sad|saddle|sadness|safe|sail|salad|salmon|salon|salt|salute|same|sample|sand|satisfy|satoshi|sauce|sausage|save|say|scale|scan|scare|scatter|scene|scheme|school|science|scissors|scorpion|scout|scrap|screen|script|scrub|sea|search|season|seat|second|secret|section|security|seed|seek|segment|select|sell|seminar|senior|sense|sentence|series|service|session|settle|setup|seven|shadow|shaft|shallow|share|shed|shell|sheriff|shield|shift|shine|ship|shiver|shock|shoe|shoot|shop|short|shoulder|shove|shrimp|shrug|shuffle|shy|sibling|sick|side|siege|sight|sign|silent|silk|silly|silver|similar|simple|since|sing|siren|sister|situate|six|size|skate|sketch|ski|skill|skin|skirt|skull|slab|slam|sleep|slender|slice|slide|slight|slim|slogan|slot|slow|slush|small|smart|smile|smoke|smooth|snack|snake|snap|sniff|snow|soap|soccer|social|sock|soda|soft|solar|soldier|solid|solution|solve|someone|song|soon|sorry|sort|soul|sound|soup|source|south|space|spare|spatial|spawn|speak|special|speed|spell|spend|sphere|spice|spider|spike|spin|spirit|split|spoil|sponsor|spoon|sport|spot|spray|spread|spring|spy|square|squeeze|squirrel|stable|stadium|staff|stage|stairs|stamp|stand|start|state|stay|steak|steel|stem|step|stereo|stick|still|sting|stock|stomach|stone|stool|story|stove|strategy|street|strike|strong|struggle|student|stuff|stumble|style|subject|submit|subway|success|such|sudden|suffer|sugar|suggest|suit|summer|sun|sunny|sunset|super|supply|supreme|sure|surface|surge|surprise|surround|survey|suspect|sustain|swallow|swamp|swap|swarm|swear|sweet|swift|swim|swing|switch|sword|symbol|symptom|syrup|system|table|tackle|tag|tail|talent|talk|tank|tape|target|task|taste|tattoo|taxi|teach|team|tell|ten|tenant|tennis|tent|term|test|text|thank|that|theme|then|theory|there|they|thing|this|thought|three|thrive|throw|thumb|thunder|ticket|tide|tiger|tilt|timber|time|tiny|tip|tired|tissue|title|toast|tobacco|today|toddler|toe|together|toilet|token|tomato|tomorrow|tone|tongue|tonight|tool|tooth|top|topic|topple|torch|tornado|tortoise|toss|total|tourist|toward|tower|town|toy|track|trade|traffic|tragic|train|transfer|trap|trash|travel|tray|treat|tree|trend|trial|tribe|trick|trigger|trim|trip|trophy|trouble|truck|true|truly|trumpet|trust|truth|try|tube|tuition|tumble|tuna|tunnel|turkey|turn|turtle|twelve|twenty|twice|twin|twist|two|type|typical|ugly|umbrella|unable|unaware|uncle|uncover|under|undo|unfair|unfold|unhappy|uniform|unique|unit|universe|unknown|unlock|until|unusual|unveil|update|upgrade|uphold|upon|upper|upset|urban|urge|usage|use|used|useful|useless|usual|utility|vacant|vacuum|vague|valid|valley|valve|van|vanish|vapor|various|vast|vault|vehicle|velvet|vendor|venture|venue|verb|verify|version|very|vessel|veteran|viable|vibrant|vicious|victory|video|view|village|vintage|violin|virtual|virus|visa|visit|visual|vital|vivid|vocal|voice|void|volcano|volume|vote|voyage|wage|wagon|wait|walk|wall|walnut|want|warfare|warm|warrior|wash|wasp|waste|water|wave|way|wealth|weapon|wear|weasel|weather|web|wedding|weekend|weird|welcome|west|wet|whale|what|wheat|wheel|when|where|whip|whisper|wide|width|wife|wild|will|win|window|wine|wing|wink|winner|winter|wire|wisdom|wise|wish|witness|wolf|woman|wonder|wood|wool|word|work|world|worry|worth|wrap|wreck|wrestle|wrist|write|wrong|yard|year|yellow|you|young|youth|zebra|zero|zone|zoo'.split('|');

package/cjs/mnemonic/wordlists/es.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;