@pezkuwi/util-crypto 14.0.1 → 14.0.3

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)
-    });
-  });
-});