@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/src/mnemonic/bip39.ts

@@ -1,127 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,58 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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/toEntropy.spec.ts

@@ -1,36 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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

@@ -1,13 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,52 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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/toMiniSecret.spec.ts

@@ -1,67 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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

@@ -1,23 +0,0 @@
-// Copyright 2017-2025 @polkadot/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

@@ -1,64 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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

@@ -1,39 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/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/mod.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export * from './index.js';

package/src/nacl/decrypt.spec.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { naclDecrypt, naclEncrypt } from './index.js';
-
-describe('naclDecrypt', (): void => {
-  it('decrypts a encrypted message', (): void => {
-    const secret = new Uint8Array(32);
-    const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    const { encrypted, nonce } = naclEncrypt(message, secret);
-
-    expect(
-      naclDecrypt(encrypted, nonce, secret)
-    ).toEqual(
-      message
-    );
-  });
-
-  it('returns null on invalid', (): void => {
-    expect(
-      naclDecrypt(new Uint8Array(), new Uint8Array(24), new Uint8Array(32))
-    ).toEqual(null);
-  });
-});

package/src/nacl/encrypt.spec.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { naclEncrypt } from './index.js';
-
-describe('naclEncrypt', (): void => {
-  it('encrypts a message', (): void => {
-    const secret = new Uint8Array(32);
-    const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-
-    expect(
-      naclEncrypt(message, secret, new Uint8Array(24))
-    ).toEqual({
-      encrypted: new Uint8Array([94, 21, 20, 69, 68, 221, 140, 245, 200, 67, 77, 188, 129, 85, 227, 141, 199, 60, 184, 251, 251, 129, 205, 46, 234]),
-      nonce: new Uint8Array(24)
-    });
-  });
-});