@pezkuwi/util-crypto 14.0.6 → 14.0.7

package/build-deno/xxhash/asU8a.ts

@@ -1,45 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady, twox } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { createAsHex } from '../helpers.ts';
-import { xxhash64 } from './xxhash64.ts';
-
-/**
- * @name xxhashAsU8a
- * @summary Creates a xxhash64 u8a from the input.
- * @description
- * From either a `string`, `Uint8Array` or a `Buffer` input, create the xxhash64 and return the result as a `Uint8Array` with the specified `bitLength`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { xxhashAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
- * ```
- */
-export function xxhashAsU8a (data: string | Uint8Array, bitLength: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512 = 64, onlyJs?: boolean): Uint8Array {
-  const rounds = Math.ceil(bitLength / 64);
-  const u8a = u8aToU8a(data);
-
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    return twox(u8a, rounds);
-  }
-
-  const result = new Uint8Array(rounds * 8);
-
-  for (let seed = 0; seed < rounds; seed++) {
-    result.set(xxhash64(u8a, seed).reverse(), seed * 8);
-  }
-
-  return result;
-}
-
-/**
- * @name xxhashAsHex
- * @description Creates a xxhash64 hex from the input.
- */
-export const xxhashAsHex = /*#__PURE__*/ createAsHex(xxhashAsU8a);

package/build-deno/xxhash/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Create xxhash64 values with specified bitlengths
- */
-
-export { xxhashAsHex, xxhashAsU8a } from './asU8a.ts';

package/build-deno/xxhash/xxhash64.ts

@@ -1,138 +0,0 @@
-
-import { _0n, _1n } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { BigInt } from 'https://deno.land/x/pezkuwi/x-bigint/mod.ts';
-
-
-interface State {
-  seed: bigint;
-  u8a: Uint8Array;
-  u8asize: number;
-  v1: bigint;
-  v2: bigint;
-  v3: bigint;
-  v4: bigint;
-}
-
-const P64_1 = BigInt('11400714785074694791');
-const P64_2 = BigInt('14029467366897019727');
-const P64_3 = BigInt('1609587929392839161');
-const P64_4 = BigInt('9650029242287828579');
-const P64_5 = BigInt('2870177450012600261');
-
-const U64 = BigInt('0xffffffffffffffff');
-
-const _7n = BigInt(7);
-const _11n = BigInt(11);
-const _12n = BigInt(12);
-const _16n = BigInt(16);
-const _18n = BigInt(18);
-const _23n = BigInt(23);
-const _27n = BigInt(27);
-const _29n = BigInt(29);
-const _31n = BigInt(31);
-const _32n = BigInt(32);
-const _33n = BigInt(33);
-const _64n = BigInt(64);
-const _256n = BigInt(256);
-
-function rotl (a: bigint, b: bigint): bigint {
-  const c = a & U64;
-
-  return ((c << b) | (c >> (_64n - b))) & U64;
-}
-
-function fromU8a (u8a: Uint8Array, p: number, count: 2 | 4): bigint {
-  const bigints = new Array<bigint>(count);
-  let offset = 0;
-
-  for (let i = 0; i < count; i++, offset += 2) {
-    bigints[i] = BigInt(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
-  }
-
-  let result = _0n;
-
-  for (let i = count - 1; i >= 0; i--) {
-    result = (result << _16n) + bigints[i];
-  }
-
-  return result;
-}
-
-function init (seed: bigint, input: Uint8Array): State {
-  const state = {
-    seed,
-    u8a: new Uint8Array(32),
-    u8asize: 0,
-    v1: seed + P64_1 + P64_2,
-    v2: seed + P64_2,
-    v3: seed,
-    v4: seed - P64_1
-  };
-
-  if (input.length < 32) {
-    state.u8a.set(input);
-    state.u8asize = input.length;
-
-    return state;
-  }
-
-  const limit = input.length - 32;
-  let p = 0;
-
-  if (limit >= 0) {
-    const adjustV = (v: bigint) =>
-      P64_1 * rotl(v + P64_2 * fromU8a(input, p, 4), _31n);
-
-    do {
-      state.v1 = adjustV(state.v1); p += 8;
-      state.v2 = adjustV(state.v2); p += 8;
-      state.v3 = adjustV(state.v3); p += 8;
-      state.v4 = adjustV(state.v4); p += 8;
-    } while (p <= limit);
-  }
-
-  if (p < input.length) {
-    state.u8a.set(input.subarray(p, input.length));
-    state.u8asize = input.length - p;
-  }
-
-  return state;
-}
-
-export function xxhash64 (input: Uint8Array, initSeed: bigint | number): Uint8Array {
-  const { seed, u8a, u8asize, v1, v2, v3, v4 } = init(BigInt(initSeed), input);
-  let p = 0;
-  let h64 = U64 & (BigInt(input.length) + (
-    input.length >= 32
-      ? (((((((((rotl(v1, _1n) + rotl(v2, _7n) + rotl(v3, _12n) + rotl(v4, _18n)) ^ (P64_1 * rotl(v1 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v2 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v3 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v4 * P64_2, _31n))) * P64_1 + P64_4)
-      : (seed + P64_5)
-  ));
-
-  while (p <= (u8asize - 8)) {
-    h64 = U64 & (P64_4 + P64_1 * rotl(h64 ^ (P64_1 * rotl(P64_2 * fromU8a(u8a, p, 4), _31n)), _27n));
-    p += 8;
-  }
-
-  if ((p + 4) <= u8asize) {
-    h64 = U64 & (P64_3 + P64_2 * rotl(h64 ^ (P64_1 * fromU8a(u8a, p, 2)), _23n));
-    p += 4;
-  }
-
-  while (p < u8asize) {
-    h64 = U64 & (P64_1 * rotl(h64 ^ (P64_5 * BigInt(u8a[p++])), _11n));
-  }
-
-  h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
-  h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
-  h64 = U64 & (h64 ^ (h64 >> _32n));
-
-  const result = new Uint8Array(8);
-
-  for (let i = 7; i >= 0; i--) {
-    result[i] = Number(h64 % _256n);
-
-    h64 = h64 / _256n;
-  }
-
-  return result;
-}

package/build-tsc-cjs/packageDetect.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const packageInfo_1 = require("@pezkuwi/networks/packageInfo");
-const util_1 = require("@pezkuwi/util");
-const packageInfo_2 = require("@pezkuwi/util/packageInfo");
-const x_randomvalues_1 = require("@pezkuwi/x-randomvalues");
-const packageInfo_js_1 = require("./packageInfo.js");
-(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, x_randomvalues_1.packageInfo, packageInfo_2.packageInfo]);

package/src/address/addressToEvm.spec.ts

@@ -1,16 +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 } from '@pezkuwi/util';
-
-import { addressToEvm } from './addressToEvm.js';
-
-describe('addressToEvm', (): void => {
-  it('creates a valid known EVM address', (): void => {
-    expect(
-      addressToEvm('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
-    ).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee9'));
-  });
-});

package/src/address/addressToEvm.ts

@@ -1,12 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { decodeAddress } from './decode.js';
-
-/**
- * @name addressToEvm
- * @summary Converts an SS58 address to its corresponding EVM address.
- */
-export function addressToEvm (address: string | Uint8Array, ignoreChecksum?: boolean): Uint8Array {
-  return decodeAddress(address, ignoreChecksum).subarray(0, 20);
-}

package/src/address/check.spec.ts

@@ -1,44 +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 { checkAddress } from './index.js';
-
-describe('checkAddress', (): void => {
-  it('returns [true, null] for Kusama', (): void => {
-    expect(
-      checkAddress('FJaco77EJ99VtBmVFibuBJR3x5Qq9KQrgQJvWjqScCcCCae', 2)
-    ).toEqual([true, null]);
-  });
-
-  it('returns [true, null] for Substrate', (): void => {
-    expect(
-      checkAddress('5EnxxUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 42)
-    ).toEqual([true, null]);
-  });
-
-  it('fails when an invalid base58 character is supplied', (): void => {
-    expect(
-      checkAddress('5EnxIUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)
-    ).toEqual([false, 'Invalid base58 character "I" (0x49) at index 4']);
-  });
-
-  it('fails with invalid prefix when checking Substrate against Kusama prefix', (): void => {
-    expect(
-      checkAddress('5EnxxUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)
-    ).toEqual([false, 'Prefix mismatch, expected 2, found 42']);
-  });
-
-  it('fails with invalid length when some bytes are missing', (): void => {
-    expect(
-      checkAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b', 42)
-    ).toEqual([false, 'Invalid decoded address length']);
-  });
-
-  it('fails with invalid length on checksum mismatch', (): void => {
-    expect(
-      checkAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU', 42)
-    ).toEqual([false, 'Invalid decoded address checksum']);
-  });
-});

package/src/address/check.ts

@@ -1,34 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Prefix } from './types.js';
-
-import { base58Decode } from '../base58/index.js';
-import { checkAddressChecksum } from './checksum.js';
-import { defaults } from './defaults.js';
-
-/**
- * @name checkAddress
- * @summary Validates an ss58 address.
- * @description
- * From the provided input, validate that the address is a valid input.
- */
-export function checkAddress (address: string, prefix: Prefix): [boolean, string | null] {
-  let decoded;
-
-  try {
-    decoded = base58Decode(address);
-  } catch (error) {
-    return [false, (error as Error).message];
-  }
-
-  const [isValid,,, ss58Decoded] = checkAddressChecksum(decoded);
-
-  if (ss58Decoded !== prefix) {
-    return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
-  } else if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
-    return [false, 'Invalid decoded address length'];
-  }
-
-  return [isValid, isValid ? null : 'Invalid decoded address checksum'];
-}

package/src/address/checksum.spec.ts

@@ -1,45 +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 { base58Decode } from '../base58/index.js';
-import { checkAddressChecksum } from './checksum.js';
-
-describe('checkAddressChecksum', (): void => {
-  it('correctly extracts the info from a 1-byte-prefix address', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
-    ).toEqual([true, 33, 1, 2]);
-  });
-
-  it('correctly extracts the info from a 2-byte-prefix address (66)', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('cTGShekJ1L1UKFZR9xmv9UTJod7vqjFAPo4sDhXih2c3y1yLS'))
-    ).toEqual([true, 34, 2, 66]);
-  });
-
-  it('correctly extracts the info from a 2-byte-prefix address (69)', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('cnVvyMzRdqjwejTFuByQQ4w2yu78V2hpFixjHQz5zr6NSYsxA'))
-    ).toEqual([true, 34, 2, 69]);
-  });
-
-  it('correctly extracts the info from a 2-byte-prefix address (252)', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('xw8Ffc2SZtDqUJKd9Ky4vc7PRz2D2asuVkEEzf3WGAbw9cnfq'))
-    ).toEqual([true, 34, 2, 252]);
-  });
-
-  it('correctly extracts the info from a 2-byte-prefix address (255)', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k'))
-    ).toEqual([true, 34, 2, 255]);
-  });
-
-  it('correctly extracts the info from a 2-byte-prefix address (ecdsa, from Substrate)', (): void => {
-    expect(
-      checkAddressChecksum(base58Decode('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV'))
-    ).toEqual([true, 35, 2, 200]);
-  });
-});

package/src/address/checksum.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { sshash } from './sshash.js';
-
-export function checkAddressChecksum (decoded: Uint8Array): [boolean, number, number, number] {
-  const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
-  const ss58Decoded = ss58Length === 1
-    ? decoded[0]
-    : ((decoded[0] & 0b0011_1111) << 2) | (decoded[1] >> 6) | ((decoded[1] & 0b0011_1111) << 8);
-
-  // 32/33 bytes public + 2 bytes checksum + prefix
-  const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
-  const length = decoded.length - (isPublicKey ? 2 : 1);
-
-  // calculate the hash and do the checksum byte checks
-  const hash = sshash(decoded.subarray(0, length));
-  const isValid = (decoded[0] & 0b1000_0000) === 0 && ![46, 47].includes(decoded[0]) && (
-    isPublicKey
-      ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-      : decoded[decoded.length - 1] === hash[0]
-  );
-
-  return [isValid, length, ss58Length, ss58Decoded];
-}

package/src/address/decode.spec.ts

@@ -1,138 +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, u8aToHex } from '@pezkuwi/util';
-
-import { ALICE_PUBLIC_SR } from './encode.spec.js';
-import { decodeAddress } from './index.js';
-
-describe('decodeAddress', (): void => {
-  it('decodes an address', (): void => {
-    expect(
-      decodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
-    ).toEqual(
-      ALICE_PUBLIC_SR
-    );
-  });
-
-  it('decodes the council address', (): void => {
-    expect(
-      u8aToHex(decodeAddress('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
-    ).toEqual(u8aToHex(stringToU8a('modlpy/trsry'.padEnd(32, '\0'))));
-  });
-
-  it('converts a publicKey (u8a) as-is', (): void => {
-    expect(
-      decodeAddress(new Uint8Array([1, 2, 3]))
-    ).toEqual(
-      new Uint8Array([1, 2, 3])
-    );
-  });
-
-  it('converts a publicKey (hex) as-is', (): void => {
-    expect(
-      decodeAddress('0x01020304')
-    ).toEqual(
-      new Uint8Array([1, 2, 3, 4])
-    );
-  });
-
-  it('decodes a short address', (): void => {
-    expect(
-      decodeAddress('F7NZ')
-    ).toEqual(new Uint8Array([1]));
-  });
-
-  it('decodes a 1-byte accountId (with prefix)', (): void => {
-    expect(
-      decodeAddress('g4b', false, 2)
-    ).toEqual(new Uint8Array([1]));
-  });
-
-  it('decodes a 2-byte accountId', (): void => {
-    expect(
-      decodeAddress('3xygo', false, 2)
-    ).toEqual(new Uint8Array([0, 1]));
-  });
-
-  it('encodes a 4-byte address', (): void => {
-    expect(
-      decodeAddress('zswfoZa', false, 2)
-    ).toEqual(new Uint8Array([1, 2, 3, 4]));
-  });
-
-  it('decodes a 8-byte address', (): void => {
-    expect(
-      decodeAddress('848Gh2GcGaZia', false, 2)
-    ).toEqual(new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]));
-  });
-
-  it('decodes a 33-byte address', (): void => {
-    expect(
-      decodeAddress('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
-    ).toEqual(
-      hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
-    );
-  });
-
-  it('decodes a 2-byte prefix (65)', (): void => {
-    expect(
-      decodeAddress('cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF')
-    ).toEqual(
-      hexToU8a('0x08e8969768fc14399930d4b8d693f68a2ff6c6a597325d6946095e5e9d9d1b0e')
-    );
-  });
-
-  it('decodes a 2-byte prefix (69)', (): void => {
-    expect(
-      decodeAddress('cnUaoo5wodnTVA4bnr4woSweto8hWZADUvLFXkR9Q6U7BRsbF')
-    ).toEqual(
-      hexToU8a('0x88eafe0305d460d1695cf34c2f786050df8e40d215e488790cc70929c9e8316d')
-    );
-  });
-
-  it('decodes a 2-byte prefix (252)', (): void => {
-    expect(
-      decodeAddress('xw9Hca4RJTmBRgzJT4ieJBh7XCK9gE3NXBDSEmgGHd4TCrbnG')
-    ).toEqual(
-      hexToU8a('0xfc422da6c3bc6dfa2a436a506428072941662f816987baaa8914e02ff5947f4b')
-    );
-  });
-
-  it('decodes a 2-byte prefix (255)', (): void => {
-    expect(
-      decodeAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
-    ).toEqual(
-      decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua')
-    );
-  });
-
-  it('decodes a 2-byte prefix (ecdsa, from Substrate)', (): void => {
-    expect(
-      u8aToHex(decodeAddress('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV'))
-    ).toEqual('0x035676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba9');
-  });
-
-  it('fails when length is invalid', (): void => {
-    expect(
-      (): Uint8Array => decodeAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')
-    ).toThrow(/address length/);
-  });
-
-  it('fails when the checksum does not match', (): void => {
-    expect(
-      (): Uint8Array => decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMa9cj')
-    ).toThrow(/address checksum/);
-    expect(
-      (): Uint8Array => decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
-    ).toThrow(/address checksum/);
-  });
-
-  it('fails when invalid base58 encoded address is found', (): void => {
-    expect(
-      () => u8aToHex(decodeAddress('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
-    ).toThrow(/Decoding F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29: Invalid base58 character "I" \(0x49\) at index 4/);
-  });
-});

package/src/address/decode.ts

@@ -1,41 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Prefix } from './types.js';
-
-// Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6
-import { isHex, isU8a, u8aToU8a } from '@pezkuwi/util';
-
-import { base58Decode } from '../base58/index.js';
-import { checkAddressChecksum } from './checksum.js';
-import { defaults } from './defaults.js';
-
-export function decodeAddress (encoded?: string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
-  if (!encoded) {
-    throw new Error('Invalid empty address passed');
-  }
-
-  if (isU8a(encoded) || isHex(encoded)) {
-    return u8aToU8a(encoded);
-  }
-
-  try {
-    const decoded = base58Decode(encoded);
-
-    if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
-      throw new Error('Invalid decoded address length');
-    }
-
-    const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
-
-    if (!isValid && !ignoreChecksum) {
-      throw new Error('Invalid decoded address checksum');
-    } else if (ss58Format !== -1 && ss58Format !== ss58Decoded) {
-      throw new Error(`Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
-    }
-
-    return decoded.slice(ss58Length, endPos);
-  } catch (error) {
-    throw new Error(`Decoding ${encoded}: ${(error as Error).message}`);
-  }
-}

package/src/address/defaults.ts

@@ -1,12 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { availableNetworks } from '../networks.js';
-
-export const defaults = {
-  allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
-  // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
-  allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
-  allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
-  prefix: 42
-};

package/src/address/derive.spec.ts

@@ -1,26 +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 { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { deriveAddress } from './index.js';
-
-describe('deriveAddress', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  it('derives a known path', (): void => {
-    expect(
-      deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
-    ).toEqual('5GZ4srnepXvdsuNVoxCGyVZd8ScDm4gkGLTKuaGARy9akjTa');
-  });
-
-  it('fails on hard paths', (): void => {
-    expect(
-      () => deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
-    ).toThrow(/Expected suri to contain a combination of non-hard paths/);
-  });
-});

package/src/address/derive.ts

@@ -1,36 +0,0 @@
-// Copyright 2017-2025 @pezkuwi/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { DeriveJunction } from '../key/DeriveJunction.js';
-import type { Prefix } from './types.js';
-
-import { keyExtractPath } from '../key/index.js';
-import { sr25519DerivePublic } from '../sr25519/index.js';
-import { decodeAddress } from './decode.js';
-import { encodeAddress } from './encode.js';
-
-function filterHard ({ isHard }: DeriveJunction): boolean {
-  return isHard;
-}
-
-/**
- * @name deriveAddress
- * @summary Creates a sr25519 derived address from the supplied and path.
- * @description
- * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
- */
-export function deriveAddress (who: string | Uint8Array, suri: string, ss58Format?: Prefix): string {
-  const { path } = keyExtractPath(suri);
-
-  if (!path.length || path.every(filterHard)) {
-    throw new Error('Expected suri to contain a combination of non-hard paths');
-  }
-
-  let publicKey = decodeAddress(who);
-
-  for (const { chainCode } of path) {
-    publicKey = sr25519DerivePublic(publicKey, chainCode);
-  }
-
-  return encodeAddress(publicKey, ss58Format);
-}