@pezkuwi/util-crypto 14.0.1 → 14.0.3

package/{src/hmac/shaAsU8a.ts → hmac/shaAsU8a.js}

@@ -1,46 +1,34 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { hmac } from '@noble/hashes/hmac';
 import { sha256 } from '@noble/hashes/sha256';
 import { sha512 } from '@noble/hashes/sha512';
-
 import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
 import { hmacSha256, hmacSha512, isReady } from '@pezkuwi/wasm-crypto';
-
 const JS_HASH = {
-  256: sha256,
-  512: sha512
+    256: sha256,
+    512: sha512
 };
-
 const WA_MHAC = {
-  256: hmacSha256,
-  512: hmacSha512
+    256: hmacSha256,
+    512: hmacSha512
 };
-
-function createSha (bitLength: 256 | 512): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
-  return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
-    hmacShaAsU8a(key, data, bitLength, onlyJs);
+function createSha(bitLength) {
+    return (key, data, onlyJs) => hmacShaAsU8a(key, data, bitLength, onlyJs);
 }
-
 /**
  * @name hmacShaAsU8a
  * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
  */
-export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array {
-  const u8aKey = u8aToU8a(key);
-
-  return !hasBigInt || (!onlyJs && isReady())
-    ? WA_MHAC[bitLength](u8aKey, data)
-    : hmac(JS_HASH[bitLength], u8aKey, data);
+export function hmacShaAsU8a(key, data, bitLength = 256, onlyJs) {
+    const u8aKey = u8aToU8a(key);
+    return !hasBigInt || (!onlyJs && isReady())
+        ? WA_MHAC[bitLength](u8aKey, data)
+        : hmac(JS_HASH[bitLength], u8aKey, data);
 }
-
 /**
  * @name hmacSha256AsU8a
  * @description creates a Hmac Sha256 Uint8Array from the key & data
  */
 export const hmacSha256AsU8a = /*#__PURE__*/ createSha(256);
-
 /**
  * @name hmacSha512AsU8a
  * @description creates a Hmac Sha512 Uint8Array from the key & data

package/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/json/constants.d.ts

@@ -0,0 +1,6 @@
+import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.js';
+export declare const ENCODING: EncryptedJsonEncoding[];
+export declare const ENCODING_NONE: EncryptedJsonEncoding[];
+export declare const ENCODING_VERSION: EncryptedJsonVersion;
+export declare const NONCE_LENGTH = 24;
+export declare const SCRYPT_LENGTH: number;

package/json/constants.js

@@ -0,0 +1,5 @@
+export const ENCODING = ['scrypt', 'xsalsa20-poly1305'];
+export const ENCODING_NONE = ['none'];
+export const ENCODING_VERSION = '3';
+export const NONCE_LENGTH = 24;
+export const SCRYPT_LENGTH = 32 + (3 * 4);

package/json/decrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonDecrypt({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array;

package/json/decrypt.js

@@ -0,0 +1,13 @@
+import { hexToU8a, isHex } from '@pezkuwi/util';
+import { base64Decode } from '../base64/index.js';
+import { jsonDecryptData } from './decryptData.js';
+export function jsonDecrypt({ encoded, encoding }, passphrase) {
+    if (!encoded) {
+        throw new Error('No encrypted data available to decode');
+    }
+    return jsonDecryptData(isHex(encoded)
+        ? hexToU8a(encoded)
+        : base64Decode(encoded), passphrase, Array.isArray(encoding.type)
+        ? encoding.type
+        : [encoding.type]);
+}

package/json/decryptData.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJsonEncoding } from './types.js';
+export declare function jsonDecryptData(encrypted?: Uint8Array | null, passphrase?: string | null, encType?: EncryptedJsonEncoding[]): Uint8Array;

package/json/decryptData.js

@@ -0,0 +1,29 @@
+import { stringToU8a, u8aFixLength } from '@pezkuwi/util';
+import { naclDecrypt } from '../nacl/index.js';
+import { scryptEncode, scryptFromU8a } from '../scrypt/index.js';
+import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants.js';
+export function jsonDecryptData(encrypted, passphrase, encType = ENCODING) {
+    if (!encrypted) {
+        throw new Error('No encrypted data available to decode');
+    }
+    else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+        throw new Error('Password required to decode encrypted data');
+    }
+    let encoded = encrypted;
+    if (passphrase) {
+        let password;
+        if (encType.includes('scrypt')) {
+            const { params, salt } = scryptFromU8a(encrypted);
+            password = scryptEncode(passphrase, salt, params).password;
+            encrypted = encrypted.subarray(SCRYPT_LENGTH);
+        }
+        else {
+            password = stringToU8a(passphrase);
+        }
+        encoded = naclDecrypt(encrypted.subarray(NONCE_LENGTH), encrypted.subarray(0, NONCE_LENGTH), u8aFixLength(password, 256, true));
+    }
+    if (!encoded) {
+        throw new Error('Unable to decode using the supplied passphrase');
+    }
+    return encoded;
+}

package/json/encrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncrypt(data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson;

package/json/encrypt.js

@@ -0,0 +1,15 @@
+import { u8aConcat } from '@pezkuwi/util';
+import { naclEncrypt } from '../nacl/index.js';
+import { scryptEncode, scryptToU8a } from '../scrypt/index.js';
+import { jsonEncryptFormat } from './encryptFormat.js';
+export function jsonEncrypt(data, contentType, passphrase) {
+    let isEncrypted = false;
+    let encoded = data;
+    if (passphrase) {
+        const { params, password, salt } = scryptEncode(passphrase);
+        const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
+        isEncrypted = true;
+        encoded = u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
+    }
+    return jsonEncryptFormat(encoded, contentType, isEncrypted);
+}

package/json/encryptFormat.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncryptFormat(encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson;

package/json/encryptFormat.js

@@ -0,0 +1,14 @@
+import { base64Encode } from '../base64/index.js';
+import { ENCODING, ENCODING_NONE, ENCODING_VERSION } from './constants.js';
+export function jsonEncryptFormat(encoded, contentType, isEncrypted) {
+    return {
+        encoded: base64Encode(encoded),
+        encoding: {
+            content: contentType,
+            type: isEncrypted
+                ? ENCODING
+                : ENCODING_NONE,
+            version: ENCODING_VERSION
+        }
+    };
+}

package/json/index.d.ts

@@ -0,0 +1,4 @@
+export { jsonDecrypt } from './decrypt.js';
+export { jsonDecryptData } from './decryptData.js';
+export { jsonEncrypt } from './encrypt.js';
+export { jsonEncryptFormat } from './encryptFormat.js';

package/json/index.js

@@ -0,0 +1,4 @@
+export { jsonDecrypt } from './decrypt.js';
+export { jsonDecryptData } from './decryptData.js';
+export { jsonEncrypt } from './encrypt.js';
+export { jsonEncryptFormat } from './encryptFormat.js';

package/json/types.d.ts

@@ -0,0 +1,16 @@
+export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
+export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
+export interface EncryptedJsonDescriptor {
+    /** Descriptor for the content */
+    content: string[];
+    /** The encoding (in current/latest versions this is always an array) */
+    type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
+    /** The version of encoding applied */
+    version: EncryptedJsonVersion;
+}
+export interface EncryptedJson {
+    /** The encoded string */
+    encoded: string;
+    /** The encoding used */
+    encoding: EncryptedJsonDescriptor;
+}

package/json/types.js

@@ -0,0 +1 @@
+export {};

package/keccak/asU8a.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @name keccakAsU8a
+ * @summary Creates a keccak Uint8Array from the input.
+ * @description
+ * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { keccakAsU8a } from '@polkadot/util-crypto';
+ *
+ * keccakAsU8a('123'); // => Uint8Array
+ * ```
+ */
+export declare const keccakAsU8a: (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+export declare const keccak256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+export declare const keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+export declare const keccakAsHex: (value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@polkadot/util/types").HexString;

package/{src/keccak/asU8a.ts → keccak/asU8a.js}

@@ -1,12 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { keccak_256 as keccak256Js, keccak_512 as keccak512Js } from '@noble/hashes/sha3';
-
 import { keccak256, keccak512 } from '@pezkuwi/wasm-crypto';
-
 import { createAsHex, createBitHasher, createDualHasher } from '../helpers.js';
-
 /**
  * @name keccakAsU8a
  * @summary Creates a keccak Uint8Array from the input.
@@ -21,23 +15,17 @@ import { createAsHex, createBitHasher, createDualHasher } from '../helpers.js';
  * keccakAsU8a('123'); // => Uint8Array
  * ```
  */
-export const keccakAsU8a = /*#__PURE__*/ createDualHasher(
-  { 256: keccak256, 512: keccak512 },
-  { 256: keccak256Js, 512: keccak512Js }
-);
-
+export const keccakAsU8a = /*#__PURE__*/ createDualHasher({ 256: keccak256, 512: keccak512 }, { 256: keccak256Js, 512: keccak512Js });
 /**
  * @name keccak256AsU8a
  * @description Creates a keccak256 Uint8Array from the input.
  */
 export const keccak256AsU8a = /*#__PURE__*/ createBitHasher(256, keccakAsU8a);
-
 /**
  * @name keccak512AsU8a
  * @description Creates a keccak512 Uint8Array from the input.
  */
 export const keccak512AsU8a = /*#__PURE__*/ createBitHasher(512, keccakAsU8a);
-
 /**
  * @name keccakAsHex
  * @description Creates a keccak hex string from the input.

package/keccak/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/keccak/index.js

@@ -0,0 +1,4 @@
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/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/key/DeriveJunction.js

@@ -0,0 +1,58 @@
+import { BN, bnToU8a, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+import { BN_LE_256_OPTS } from '../bn.js';
+const RE_NUMBER = /^\d+$/;
+const JUNCTION_ID_LEN = 32;
+export 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 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 (isNumber(value) || isBn(value) || isBigInt(value)) {
+            return this.soft(bnToU8a(value, BN_LE_256_OPTS));
+        }
+        else if (isHex(value)) {
+            return this.soft(hexToU8a(value));
+        }
+        else if (isString(value)) {
+            return this.soft(compactAddLength(stringToU8a(value)));
+        }
+        else if (value.length > JUNCTION_ID_LEN) {
+            return this.soft(blake2AsU8a(value));
+        }
+        this.#chainCode.fill(0);
+        this.#chainCode.set(value, 0);
+        return this;
+    }
+    soften() {
+        this.#isHard = false;
+        return this;
+    }
+}

package/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/key/extractPath.js

@@ -0,0 +1,23 @@
+import { DeriveJunction } from './DeriveJunction.js';
+const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+export 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.from(p.substring(1)));
+        }
+    }
+    if (constructed !== derivePath) {
+        throw new Error(`Re-constructed path "${constructed}" does not match input`);
+    }
+    return {
+        parts,
+        path
+    };
+}

package/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/key/extractSuri.js

@@ -0,0 +1,22 @@
+import { keyExtractPath } from './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).
+ */
+export 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 } = keyExtractPath(derivePath);
+    return {
+        derivePath,
+        password,
+        path,
+        phrase
+    };
+}

package/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/key/fromPath.js

@@ -0,0 +1,18 @@
+import { keyHdkdEcdsa } from './hdkdEcdsa.js';
+import { keyHdkdEd25519 } from './hdkdEd25519.js';
+import { keyHdkdSr25519 } from './hdkdSr25519.js';
+const generators = {
+    ecdsa: keyHdkdEcdsa,
+    ed25519: keyHdkdEd25519,
+    // FIXME This is Substrate-compatible, not Ethereum-compatible
+    ethereum: keyHdkdEcdsa,
+    sr25519: keyHdkdSr25519
+};
+export function keyFromPath(pair, path, type) {
+    const keyHdkd = generators[type];
+    let result = pair;
+    for (const junction of path) {
+        result = keyHdkd(result, junction);
+    }
+    return result;
+}

package/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/key/hdkdDerive.js

@@ -0,0 +1,8 @@
+export 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/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/{src/key/hdkdEcdsa.ts → key/hdkdEcdsa.js}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { secp256k1DeriveHard } from '../secp256k1/deriveHard.js';
 import { secp256k1PairFromSeed } from '../secp256k1/pair/fromSeed.js';
 import { createSeedDeriveFn } from './hdkdDerive.js';
-
 export const keyHdkdEcdsa = /*#__PURE__*/ createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);

package/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/{src/key/hdkdEd25519.ts → key/hdkdEd25519.js}

@@ -1,7 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 import { ed25519DeriveHard, ed25519PairFromSeed } from '../ed25519/index.js';
 import { createSeedDeriveFn } from './hdkdDerive.js';
-
 export const keyHdkdEd25519 = /*#__PURE__*/ createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);

package/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/key/hdkdSr25519.js

@@ -0,0 +1,7 @@
+import { sr25519DeriveHard } from '../sr25519/deriveHard.js';
+import { sr25519DeriveSoft } from '../sr25519/deriveSoft.js';
+export function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+    return isSoft
+        ? sr25519DeriveSoft(keypair, chainCode)
+        : sr25519DeriveHard(keypair, chainCode);
+}

package/key/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+export { keyExtractPath } from './extractPath.js';
+export { keyExtractSuri } from './extractSuri.js';
+export { keyFromPath } from './fromPath.js';
+export { keyHdkdEcdsa } from './hdkdEcdsa.js';
+export { keyHdkdEd25519 } from './hdkdEd25519.js';
+export { keyHdkdSr25519 } from './hdkdSr25519.js';

package/key/index.js

@@ -0,0 +1,9 @@
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+export { keyExtractPath } from './extractPath.js';
+export { keyExtractSuri } from './extractSuri.js';
+export { keyFromPath } from './fromPath.js';
+export { keyHdkdEcdsa } from './hdkdEcdsa.js';
+export { keyHdkdEd25519 } from './hdkdEd25519.js';
+export { keyHdkdSr25519 } from './hdkdSr25519.js';

package/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/mnemonic/bip39.js

@@ -0,0 +1,82 @@
+import { stringToU8a, u8aToU8a } from '@pezkuwi/util';
+import { pbkdf2Encode } from '../pbkdf2/index.js';
+import { randomAsU8a } from '../random/index.js';
+import { sha256AsU8a } from '../sha/index.js';
+import DEFAULT_WORDLIST from './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(sha256AsU8a(entropyBuffer))).slice(0, (entropyBuffer.length * 8) / 32);
+}
+export function mnemonicToSeedSync(mnemonic, password) {
+    return pbkdf2Encode(stringToU8a(normalize(mnemonic)), stringToU8a(`mnemonic${normalize(password)}`)).password;
+}
+export function mnemonicToEntropy(mnemonic, wordlist = DEFAULT_WORDLIST) {
+    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 = u8aToU8a(entropyBytes);
+    if (deriveChecksumBits(entropy) !== checksumBits) {
+        throw new Error(INVALID_CHECKSUM);
+    }
+    return entropy;
+}
+export function entropyToMnemonic(entropy, wordlist = DEFAULT_WORDLIST) {
+    // 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(' ');
+}
+export function generateMnemonic(numWords, wordlist) {
+    return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
+}
+export function validateMnemonic(mnemonic, wordlist) {
+    try {
+        mnemonicToEntropy(mnemonic, wordlist);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}

package/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;