@pezkuwi/util-crypto 14.0.6 → 14.0.7

package/src/keccak/asU8a.spec.ts

@@ -1,56 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { hexToU8a, stringToU8a } from '@pezkuwi/util';
-import { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { perfWasm } from '../test/index.js';
-import { keccakAsU8a } from './index.js';
-
-describe('keccakAsU8a', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  const input = 'test value';
-  const output = {
-    256: hexToU8a(
-      '0x2d07364b5c231c56ce63d49430e085ea3033c750688ba532b24029124c26ca5e'
-    ),
-    512: hexToU8a(
-      '0xc1b50cc57f85ccd968a9d7c7a809dcebd140a548c8e0b67f3afcdd6fc14cca2b1d04187aef24ba0081b74f2ec362431e425760febe94a5607790854cafe5b197'
-    )
-  };
-
-  for (const bitLength of [256, 512] as const) {
-    describe(`bitLength=${bitLength}`, (): void => {
-      for (const onlyJs of [false, true]) {
-        describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
-          it('returns an hex representation (string)', (): void => {
-            expect(
-              keccakAsU8a(input, bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-
-          it('returns an hex representation (Buffer)', (): void => {
-            expect(
-              keccakAsU8a(Buffer.from(input), bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-
-          it('returns an hex representation (Uint8Array)', (): void => {
-            expect(
-              keccakAsU8a(stringToU8a(input), bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-        });
-      }
-
-      perfWasm(`keccakAsU8a, bitLength=${bitLength}`, 128000, (input, onlyJs) =>
-        keccakAsU8a(input, bitLength, onlyJs)
-      );
-    });
-  }
-});

package/src/keccak/asU8a.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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.
- * @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 '@pezkuwi/util-crypto';
- *
- * keccakAsU8a('123'); // => Uint8Array
- * ```
- */
-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.
- */
-export const keccakAsHex = /*#__PURE__*/ createAsHex(keccakAsU8a);

package/src/keccak/index.ts

@@ -1,8 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @summary Create Keccak256/512 values as hex & Uint8Array output
- */
-
-export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/src/key/DeriveJunction.ts

@@ -1,79 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-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 {
-  readonly #chainCode: Uint8Array = new Uint8Array(32);
-
-  #isHard = false;
-
-  public static from (value: string): DeriveJunction {
-    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;
-  }
-
-  public get chainCode (): Uint8Array {
-    return this.#chainCode;
-  }
-
-  public get isHard (): boolean {
-    return this.#isHard;
-  }
-
-  public get isSoft (): boolean {
-    return !this.#isHard;
-  }
-
-  public hard (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    return this.soft(value).harden();
-  }
-
-  public harden (): DeriveJunction {
-    this.#isHard = true;
-
-    return this;
-  }
-
-  public soft (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    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;
-  }
-
-  public soften (): DeriveJunction {
-    this.#isHard = false;
-
-    return this;
-  }
-}

package/src/key/extractPath.spec.ts

@@ -1,51 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { ExtractResult } from './extractPath.js';
-
-import { keyExtractPath } from './extractPath.js';
-
-describe('keyExtractPath', (): void => {
-  it('extracts properly from soft', (): void => {
-    const test = keyExtractPath('/1');
-
-    expect(test.parts).toEqual(['/1']);
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(false);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('extracts properly from hard', (): void => {
-    const test = keyExtractPath('//1');
-
-    expect(test.parts).toEqual(['//1']);
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('extracts properly from hard/soft', (): void => {
-    const test = keyExtractPath('//1/2');
-
-    expect(test.parts).toEqual(['//1', '/2']);
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(false);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('does not extract from invalid paths (1)', (): void => {
-    expect(
-      (): ExtractResult => keyExtractPath('1/2')
-    ).toThrow(/does not match input/);
-  });
-
-  it('does not extract from invalid paths (2)', (): void => {
-    expect(
-      (): ExtractResult => keyExtractPath('hello')
-    ).toThrow(/does not match input/);
-  });
-});

package/src/key/extractPath.ts

@@ -1,37 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { DeriveJunction } from './DeriveJunction.js';
-
-const RE_JUNCTION = /\/(\/?)([^/]+)/g;
-
-export interface ExtractResult {
-  parts: string[] | null;
-  path: DeriveJunction[];
-}
-
-/**
- * @description Extract derivation junctions from the supplied path
- */
-export function keyExtractPath (derivePath: string): ExtractResult {
-  const parts = derivePath.match(RE_JUNCTION);
-  const path: DeriveJunction[] = [];
-  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/src/key/extractSuri.spec.ts

@@ -1,147 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import type { ExtractResult } from './extractSuri.js';
-
-import { keyExtractSuri } from './extractSuri.js';
-
-describe('keyExtractSuri', (): void => {
-  it('does not extract from invalid suri', (): void => {
-    expect(
-      (): ExtractResult => keyExtractSuri('//2')
-    ).toThrow('Unable to match provided value to a secret URI');
-  });
-
-  it('derives on "hello world"', (): void => {
-    const test = keyExtractSuri('hello world');
-
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(0);
-  });
-
-  it('derives on "hello world/1', (): void => {
-    const test = keyExtractSuri('hello world/1');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(false);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world/DOT', (): void => {
-    const test = keyExtractSuri('hello world/DOT');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(false);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world//1', (): void => {
-    const test = keyExtractSuri('hello world//1');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world//DOT', (): void => {
-    const test = keyExtractSuri('hello world//DOT');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world//1/DOT', (): void => {
-    const test = keyExtractSuri('hello world//1/DOT');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(false);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world//DOT/1', (): void => {
-    const test = keyExtractSuri('hello world//DOT/1');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(false);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world///password"', (): void => {
-    const test = keyExtractSuri('hello world///password');
-
-    expect(test.password).toEqual('password');
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(0);
-  });
-
-  it('derives on "hello world//1/DOT///password"', (): void => {
-    const test = keyExtractSuri('hello world//1/DOT///password');
-
-    expect(test.password).toEqual('password');
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(false);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on "hello world/1//DOT///password"', (): void => {
-    const test = keyExtractSuri('hello world/1//DOT///password');
-
-    expect(test.password).toEqual('password');
-    expect(test.phrase).toEqual('hello world');
-    expect(test.path.length).toEqual(2);
-    expect(test.path[0].isHard).toEqual(false);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    expect(test.path[1].isHard).toEqual(true);
-    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on actual Alice', (): void => {
-    const test = keyExtractSuri('bottom drive obey lake curtain smoke basket hold race lonely fit walk//Alice');
-
-    expect(test.password).not.toBeDefined();
-    expect(test.phrase).toEqual('bottom drive obey lake curtain smoke basket hold race lonely fit walk');
-    expect(test.path.length).toEqual(1);
-    expect(test.path[0].isHard).toEqual(true);
-    expect(test.path[0].chainCode).toEqual(Uint8Array.from([20, 65, 108, 105, 99, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-  });
-
-  it('derives on uncommon characters', (): void => {
-    const languageMnemonics = {
-      chineseSimplified: '熙 礼 淀 谋 耗 搜 雨 瑞 雷 合 析 感',
-      chineseTraditional: '召 胸 捕 乏 講 祥 隙 幫 動 框 場 給',
-      french: 'ruiner minute maison ouragan palourde piscine nerveux descente romance édifier ancien médaille',
-      japanese: 'ほったん はちみつ おやゆび ほかん いりぐち さんいん てぶくろ だいじょうぶ ふとん でぬかえ ちしき あわてる',
-      korean: '김밥 방향 논리 저절로 증상 지진 회장 오히려 시리즈 최근 학용품 곡식'
-    };
-
-    Object.keys(languageMnemonics).forEach((mnemonic) => {
-      const test = keyExtractSuri(mnemonic);
-
-      expect(test.password).not.toBeDefined();
-      expect(test.phrase).toEqual(mnemonic);
-      expect(test.path.length).toEqual(0);
-    });
-  });
-});

package/src/key/extractSuri.ts

@@ -1,40 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DeriveJunction } from './DeriveJunction.js';
-
-import { keyExtractPath } from './extractPath.js';
-
-export interface ExtractResult {
-  derivePath: string,
-  password?: string;
-  path: DeriveJunction[];
-  phrase: string;
-}
-
-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: string): ExtractResult {
-  // 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/src/key/fromPath.ts

@@ -1,28 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair, KeypairType } from '../types.js';
-import type { DeriveJunction } from './DeriveJunction.js';
-
-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: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
-  const keyHdkd = generators[type];
-  let result = pair;
-
-  for (const junction of path) {
-    result = keyHdkd(result, junction);
-  }
-
-  return result;
-}

package/src/key/hdkdDerive.ts

@@ -1,17 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../types.js';
-import type { DeriveJunction } from './DeriveJunction.js';
-
-export function createSeedDeriveFn (fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair {
-  return (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair => {
-    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/src/key/hdkdEcdsa.ts

@@ -1,8 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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/src/key/hdkdEd25519.ts

@@ -1,7 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/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/src/key/hdkdSr25519.ts

@@ -1,14 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../types.js';
-import type { DeriveJunction } from './DeriveJunction.js';
-
-import { sr25519DeriveHard } from '../sr25519/deriveHard.js';
-import { sr25519DeriveSoft } from '../sr25519/deriveSoft.js';
-
-export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
-  return isSoft
-    ? sr25519DeriveSoft(keypair, chainCode)
-    : sr25519DeriveHard(keypair, chainCode);
-}

package/src/key/index.ts

@@ -1,12 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * @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/src/mnemonic/bip39.spec.ts

@@ -1,80 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import * as lists from './wordlists/index.js';
-import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, validateMnemonic } from './bip39.js';
-
-describe('wordlists', (): void => {
-  for (const [lang, words] of Object.entries(lists)) {
-    describe(`language ${lang}`, (): void => {
-      it('has the correct number of words', (): void => {
-        expect(words).toHaveLength(2048);
-      });
-
-      it('has no empty words', (): void => {
-        expect(
-          words.some((w) => !w.length || w.trim() !== w)
-        ).toEqual(false);
-      });
-    });
-  }
-});
-
-describe('bip39', (): void => {
-  const m = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
-  const e = mnemonicToEntropy(m);
-
-  it('generates a known entropy', (): void => {
-    expect(e).toEqual(
-      new Uint8Array([194, 249, 194, 50, 119, 69, 163, 120, 68, 162, 142, 34, 74, 50, 40, 197])
-    );
-  });
-
-  it('has a two-way entropy <-> mnemonic (default wordlist)', (): void => {
-    expect(
-      entropyToMnemonic(mnemonicToEntropy(entropyToMnemonic(e)))
-    ).toEqual(m);
-  });
-
-  for (const [lang, words] of Object.entries(lists)) {
-    const isUsingList = (test: string, length = 12): void => {
-      const split = test.split(' ');
-
-      expect(
-        split
-      ).toHaveLength(length);
-      expect(
-        split.some((w) => words.indexOf(w) === -1)
-      ).toEqual(false);
-    };
-
-    describe(`language ${lang}`, (): void => {
-      it('has a two-way entropy <-> mnemonic', (): void => {
-        const test = entropyToMnemonic(e, words);
-        const entr = mnemonicToEntropy(test, words);
-
-        isUsingList(test);
-
-        expect(
-          entr
-        ).toEqual(e);
-
-        expect(
-          entropyToMnemonic(entr, words)
-        ).toEqual(test);
-      });
-
-      it('generates a valid mnemonic', (): void => {
-        const test = generateMnemonic(24, words);
-
-        isUsingList(test, 24);
-
-        expect(
-          validateMnemonic(test, words)
-        ).toEqual(true);
-      });
-    });
-  }
-});