@pezkuwi/util-crypto 14.0.22 → 14.0.23

package/src/mnemonic/bip39.ts

@@ -0,0 +1,127 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapted from the bitcoinjs/bip39 source
+// https://github.com/bitcoinjs/bip39/blob/1d063b6a6aee4145b34d701037cd3e67f5446ff9/ts_src/index.ts
+// Copyright (c) 2014, Wei Lu <luwei.here@gmail.com> and Daniel Cousens <email@dcousens.com>
+// ISC Licence
+//
+// Change made in this version -
+//   - Adjust formatting (just eslint differences)
+//   - Only English wordlist (this aligns with the wasm-crypto implementation)
+//   - Use util-crypto randomAsU8a (instead of randombytes)
+//   - Remove setting of wordlist passing of wordlist in functions
+//   - Remove mnemonicToSeed (we only use the sync variant)
+//   - generateMnemonic takes number of words (instead of strength)
+
+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?: string): string {
+  return (str || '').normalize('NFKD');
+}
+
+/** @internal */
+function binaryToByte (bin: string): number {
+  return parseInt(bin, 2);
+}
+
+/** @internal */
+function bytesToBinary (bytes: number[]): string {
+  return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+}
+
+/** @internal */
+function deriveChecksumBits (entropyBuffer: Uint8Array): string {
+  return bytesToBinary(
+    Array.from(sha256AsU8a(entropyBuffer))
+  ).slice(0, (entropyBuffer.length * 8) / 32);
+}
+
+export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8Array {
+  return pbkdf2Encode(
+    stringToU8a(normalize(mnemonic)),
+    stringToU8a(`mnemonic${normalize(password)}`)
+  ).password;
+}
+
+export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAULT_WORDLIST): Uint8Array {
+  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): string => {
+      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: Uint8Array, wordlist: string[] = DEFAULT_WORDLIST): string {
+  // 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: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string {
+  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
+}
+
+export function validateMnemonic (mnemonic: string, wordlist?: string[]): boolean {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist);
+  } catch {
+    return false;
+  }
+
+  return true;
+}

package/src/mnemonic/generate.spec.ts

@@ -0,0 +1,58 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { cryptoWaitReady } from '../index.js';
+import { french as frenchWords } from './wordlists/index.js';
+import { mnemonicGenerate } from './generate.js';
+import { mnemonicValidate } from './validate.js';
+
+await cryptoWaitReady();
+
+describe('mnemonicGenerate', (): void => {
+  it('generates a valid mnemonic (default strength)', (): void => {
+    expect(
+      mnemonicValidate(mnemonicGenerate())
+    ).toEqual(true);
+  });
+
+  it('generates a french mnemonic', (): void => {
+    const mnemonic = mnemonicGenerate(24, frenchWords);
+    const words = mnemonic.split(' ');
+
+    expect(words).toHaveLength(24);
+    expect(
+      mnemonicValidate(mnemonic, frenchWords)
+    ).toEqual(true);
+    expect(
+      mnemonicValidate(mnemonic)
+    ).toEqual(false);
+    expect(
+      words.every((w) => frenchWords.includes(w))
+    ).toEqual(true);
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      for (const num of [12, 15, 18, 21, 24] as const) {
+        it(`generates a valid mnemonic (${num} words)`, (): void => {
+          const mnemonic = mnemonicGenerate(num, undefined, onlyJs);
+          const isValid = mnemonicValidate(mnemonic);
+
+          expect(mnemonic.split(' ')).toHaveLength(num);
+          expect(isValid).toEqual(true);
+        });
+      }
+
+      it('generates non-deterministic', (): void => {
+        const m1 = mnemonicGenerate(24, undefined, onlyJs);
+        const m2 = mnemonicGenerate(24, undefined, onlyJs);
+
+        expect(m1 === m2).toEqual(false);
+        expect(mnemonicValidate(m1)).toEqual(true);
+        expect(mnemonicValidate(m2)).toEqual(true);
+      });
+    });
+  }
+});

package/src/mnemonic/generate.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hasBigInt } from '@pezkuwi/util';
+import { bip39Generate, isReady } from '@pezkuwi/wasm-crypto';
+
+import { generateMnemonic } from './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
+ * ```
+ */
+export function mnemonicGenerate (numWords: 12 | 15 | 18 | 21 | 24 = 12, wordlist?: string[], onlyJs?: boolean): string {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
+    ? bip39Generate(numWords)
+    : generateMnemonic(numWords, wordlist);
+}

package/src/mnemonic/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/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
+ */
+export { mnemonicGenerate } from './generate.js';
+export { mnemonicToEntropy } from './toEntropy.js';
+export { mnemonicToLegacySeed } from './toLegacySeed.js';
+export { mnemonicToMiniSecret } from './toMiniSecret.js';
+export { mnemonicValidate } from './validate.js';

package/src/mnemonic/toEntropy.spec.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u8aToHex } from '@pezkuwi/util';
+
+import { cryptoWaitReady } from '../index.js';
+import tests from '../sr25519/pair/testing.spec.js';
+import { french as frenchWords } from './wordlists/index.js';
+import { mnemonicToEntropy } from './toEntropy.js';
+
+await cryptoWaitReady();
+
+describe('mnemonicToEntropy', (): void => {
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      tests.forEach(([mnemonic, entropy], index): void => {
+        it(`Created correct entropy for ${index}`, (): void => {
+          expect(u8aToHex(mnemonicToEntropy(mnemonic, undefined, onlyJs))).toEqual(entropy);
+        });
+      });
+    });
+  }
+
+  it('has the correct entropy for non-Englist mnemonics', (): void => {
+    const mnemonic = 'pompier circuler pulpe injure aspect abyssal nuque boueux équerre balisage pieuvre médecin petit suffixe soleil cumuler monstre arlequin liasse pixel garrigue noble buisson scandale';
+
+    expect(
+      () => mnemonicToEntropy(mnemonic)
+    ).toThrow();
+    expect(
+      mnemonicToEntropy(mnemonic, frenchWords)
+    ).toEqual(new Uint8Array([189, 230, 55, 17, 65, 33, 40, 4, 106, 9, 11, 88, 227, 26, 229, 76, 59, 123, 200, 55, 177, 232, 158, 66, 34, 54, 93, 54, 255, 74, 137, 70]));
+  });
+});

package/src/mnemonic/toEntropy.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hasBigInt } from '@pezkuwi/util';
+import { bip39ToEntropy, isReady } from '@pezkuwi/wasm-crypto';
+
+import { mnemonicToEntropy as jsToEntropy } from './bip39.js';
+
+export function mnemonicToEntropy (mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
+    ? bip39ToEntropy(mnemonic)
+    : jsToEntropy(mnemonic, wordlist);
+}

package/src/mnemonic/toLegacySeed.spec.ts

@@ -0,0 +1,52 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u8aEq, u8aToHex } from '@pezkuwi/util';
+import { waitReady } from '@pezkuwi/wasm-crypto';
+
+import { mnemonicToLegacySeed } from './index.js';
+
+const MNEMONIC = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+const SEED_32 = '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027';
+const SEED_64 = '0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a0275693dd5bd9d4cc9e648475eba9613ed4678f4d62560a9c42f75bac04022ded25';
+
+describe('mnemonicToLegacySeed', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  for (const password of [undefined, 'foo', 'bar']) {
+    it(`generates Wasm & Js equivalents for password=${password || 'undefined'}`, (): void => {
+      expect(
+        u8aEq(
+          mnemonicToLegacySeed(MNEMONIC, password, true),
+          mnemonicToLegacySeed(MNEMONIC, password, false)
+        )
+      ).toEqual(true);
+    });
+  }
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('generates a valid 64bytes seed', (): void => {
+        expect(
+          u8aToHex(mnemonicToLegacySeed(MNEMONIC, undefined, onlyJs, 64))
+        ).toEqual(SEED_64);
+      });
+
+      it('generates a valid 32bytes seed', (): void => {
+        expect(
+          u8aToHex(mnemonicToLegacySeed(MNEMONIC, undefined, onlyJs))
+        ).toEqual(SEED_32);
+      });
+
+      it('fails with non-mnemonics', (): void => {
+        expect(
+          () => mnemonicToLegacySeed('foo bar baz', undefined, onlyJs)
+        ).toThrow(/mnemonic specified/);
+      });
+    });
+  }
+});

package/src/mnemonic/toLegacySeed.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hasBigInt } from '@pezkuwi/util';
+import { bip39ToSeed, isReady } from '@pezkuwi/wasm-crypto';
+
+import { mnemonicToSeedSync } from './bip39.js';
+import { mnemonicValidate } from './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
+ * }
+ * ```
+ */
+export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs?: boolean, byteLength: 32 | 64 = 32): Uint8Array {
+  if (!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
+    ? !hasBigInt || (!onlyJs && isReady())
+      ? bip39ToSeed(mnemonic, password)
+      : mnemonicToSeedSync(mnemonic, password).subarray(0, 32)
+    : mnemonicToSeedSync(mnemonic, password);
+}

package/src/mnemonic/toMiniSecret.spec.ts

@@ -0,0 +1,67 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { u8aEq, u8aToHex } from '@pezkuwi/util';
+
+import { cryptoWaitReady } from '../index.js';
+import tests from '../sr25519/pair/testing.spec.js';
+import { korean as koreanWords } from './wordlists/index.js';
+import { mnemonicToMiniSecret } from './toMiniSecret.js';
+
+const MNEMONIC = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+const SEED = '0x4d1ab2a57929edfd018aaa974e62ed557e3f54b4104acabedf73c8f5a1dbb029';
+
+await cryptoWaitReady();
+
+describe('mnemonicToMiniSecret', (): void => {
+  for (const password of [undefined, 'foo', 'bar']) {
+    it(`generates Wasm & Js equivalents for password=${password || 'undefined'}`, (): void => {
+      expect(
+        u8aEq(
+          mnemonicToMiniSecret(MNEMONIC, password, undefined, true),
+          mnemonicToMiniSecret(MNEMONIC, password, undefined, false)
+        )
+      ).toEqual(true);
+    });
+  }
+
+  it('creates a known minisecret from a non-english mnemonic', (): void => {
+    const mnemonic = '엉덩이 능동적 숫자 팩시밀리 비난 서적 파출소 도움 독창적 인생 상류 먼지 답변 음반 수박 사업 노란색 공사 우체국 특급 도대체 금지 굉장히 고무신';
+
+    expect(
+      () => mnemonicToMiniSecret(mnemonic, 'testing')
+    ).toThrow();
+    expect(
+      u8aToHex(mnemonicToMiniSecret(mnemonic, 'testing', koreanWords))
+    ).toEqual('0xefa278a62535581767a2f49cb542ed91b65fb911e1b05e7a09c702b257f10c13');
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('generates a valid seed', (): void => {
+        expect(
+          u8aToHex(mnemonicToMiniSecret(MNEMONIC, undefined, undefined, onlyJs))
+        ).toEqual(SEED);
+      });
+
+      it('fails with non-mnemonics', (): void => {
+        expect(
+          () => mnemonicToMiniSecret('foo bar baz', undefined, undefined, onlyJs)
+        ).toThrow(/mnemonic specified/);
+      });
+
+      tests.forEach(([mnemonic, , seed], index): void => {
+        it(`Created correct seed for ${index}`, (): void => {
+          expect(
+            u8aToHex(mnemonicToMiniSecret(mnemonic, 'Substrate', undefined, onlyJs))
+          ).toEqual(
+            // mini returned here, only check first 32-bytes (64 hex + 2 prefix)
+            seed.substring(0, 66)
+          );
+        });
+      });
+    });
+  }
+});

package/src/mnemonic/toMiniSecret.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { stringToU8a } from '@pezkuwi/util';
+import { bip39ToMiniSecret, isReady } from '@pezkuwi/wasm-crypto';
+
+import { pbkdf2Encode } from '../pbkdf2/index.js';
+import { mnemonicToEntropy } from './toEntropy.js';
+import { mnemonicValidate } from './validate.js';
+
+export function mnemonicToMiniSecret (mnemonic: string, password = '', wordlist?: string[], onlyJs?: boolean): Uint8Array {
+  if (!mnemonicValidate(mnemonic, wordlist, onlyJs)) {
+    throw new Error('Invalid bip39 mnemonic specified');
+  } else if (!wordlist && !onlyJs && isReady()) {
+    return bip39ToMiniSecret(mnemonic, password);
+  }
+
+  const entropy = mnemonicToEntropy(mnemonic, wordlist);
+  const salt = stringToU8a(`mnemonic${password}`);
+
+  // return the first 32 bytes as the seed
+  return pbkdf2Encode(entropy, salt).password.slice(0, 32);
+}

package/src/mnemonic/toMiniSecretCmp.spec.ts

@@ -0,0 +1,64 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { arrayRange, u8aEq } from '@pezkuwi/util';
+
+import { cryptoWaitReady, ed25519PairFromSeed, mnemonicGenerate, mnemonicToMiniSecret, sr25519PairFromSeed } from '../index.js';
+
+// NOTE: This basically controls how long stuff runs for, YMMV
+//
+// - 100 runs with 5 checks, takes 2mins on _my_ machine
+// - 10_000 runs with 5 checks should be ~3hrs
+const NUM_RUNS = 100;
+const NUM_CHECKS = 5;
+
+await cryptoWaitReady();
+
+// generate either a JS or WASM mnemonic
+for (const onlyJsMnemonic of [false, true]) {
+  describe(`mnemonicToMiniSecret (conpare), onlyJs${(onlyJsMnemonic && 'true') || 'false'}`, (): void => {
+    for (const i of arrayRange(NUM_RUNS)) {
+      // loop through lots of mnemonics
+      describe(`run=${i + 1}`, (): void => {
+        // compare both JS and WASM outputs against original
+        for (const onlyJsMini of [false, true]) {
+          describe(`onlyJsMini=${(onlyJsMini && 'true') || 'false'}`, (): void => {
+            // NOTE we cannot actually use the onlyJsMnemonic flag here
+            const mnemonic = mnemonicGenerate(12);
+
+            describe(`${mnemonic}`, (): void => {
+              // do iterations to check and re-check that all matches
+              for (const count of arrayRange(NUM_CHECKS)) {
+                it(`check=${count + 1}`, (): void => {
+                  const minisecret = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', undefined, onlyJsMnemonic);
+                  const edpub = ed25519PairFromSeed(minisecret).publicKey;
+                  const srpub = sr25519PairFromSeed(minisecret).publicKey;
+                  const testmini = mnemonicToMiniSecret(mnemonic, count ? `${count}` : '', undefined, onlyJsMini);
+
+                  // explicit minisecret compare
+                  expect(
+                    u8aEq(minisecret, testmini)
+                  ).toEqual(true);
+
+                  // compare the sr25519 keypair generated
+                  expect(
+                    u8aEq(srpub, sr25519PairFromSeed(testmini).publicKey)
+                  ).toEqual(true);
+
+                  // compare ed both in WASM and JS
+                  [true, false].forEach((onlyJsEd): void => {
+                    expect(
+                      u8aEq(edpub, ed25519PairFromSeed(testmini, onlyJsEd).publicKey)
+                    ).toEqual(true);
+                  });
+                });
+              }
+            });
+          });
+        }
+      });
+    }
+  });
+}

package/src/mnemonic/validate.spec.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { cryptoWaitReady } from '../index.js';
+import { french as frenchWords } from './wordlists/index.js';
+import { mnemonicValidate } from './validate.js';
+
+await cryptoWaitReady();
+
+describe('mnemonicValidate', (): void => {
+  for (const onlyJs of [undefined, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('returns true on valid', (): void => {
+        expect(
+          mnemonicValidate('seed sock milk update focus rotate barely fade car face mechanic mercy', undefined, onlyJs)
+        ).toEqual(true);
+      });
+
+      it('returns false on invalid', (): void => {
+        expect(
+          mnemonicValidate('wine photo extra cushion basket dwarf humor cloud truck job boat submit', undefined, onlyJs)
+        ).toEqual(false);
+      });
+    });
+  }
+
+  it('allows usage of a different wordlist', (): void => {
+    const mnemonic = 'pompier circuler pulpe injure aspect abyssal nuque boueux équerre balisage pieuvre médecin petit suffixe soleil cumuler monstre arlequin liasse pixel garrigue noble buisson scandale';
+
+    expect(
+      mnemonicValidate(mnemonic, frenchWords)
+    ).toEqual(true);
+    expect(
+      mnemonicValidate(mnemonic)
+    ).toEqual(false);
+  });
+});

package/src/mnemonic/validate.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { hasBigInt } from '@pezkuwi/util';
+import { bip39Validate, isReady } from '@pezkuwi/wasm-crypto';
+
+import { validateMnemonic } from './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
+ * ```
+ */
+export function mnemonicValidate (mnemonic: string, wordlist?: string[], onlyJs?: boolean): boolean {
+  return !hasBigInt || (!wordlist && !onlyJs && isReady())
+    ? bip39Validate(mnemonic)
+    : validateMnemonic(mnemonic, wordlist);
+}

package/src/mnemonic/wordlists/en.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Adapted from the bitcoinjs/bip39 source
+// https://github.com/bitcoinjs/bip39/blob/1d063b6a6aee4145b34d701037cd3e67f5446ff9/ts_src/
+
+export 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('|');