@pezkuwi/util-crypto 14.0.22 → 14.0.23

package/cjs/blake2/asU8a.d.ts

@@ -17,4 +17,4 @@ export declare function blake2AsU8a(data: string | Uint8Array, bitLength?: 64 |
  * @name blake2AsHex
  * @description Creates a blake2b hex from the input.
  */
-export declare const blake2AsHex: (data: string | Uint8Array<ArrayBufferLike>, bitLength?: 256 | 512 | 64 | 128 | 384 | undefined, key?: Uint8Array<ArrayBufferLike> | null | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;
+export declare const blake2AsHex: (data: string | Uint8Array, bitLength?: 256 | 512 | 64 | 128 | 384 | undefined, key?: Uint8Array | null | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/cjs/keccak/asU8a.d.ts

@@ -27,4 +27,4 @@ export declare const keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolea
  * @name keccakAsHex
  * @description Creates a keccak hex string from the input.
  */
-export declare const keccakAsHex: (value: string | Uint8Array<ArrayBufferLike>, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;
+export declare const keccakAsHex: (value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/cjs/packageInfo.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/util-crypto', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.22' };
+exports.packageInfo = { name: '@pezkuwi/util-crypto', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.10' };

package/cjs/scrypt/encode.d.ts

@@ -4,5 +4,5 @@ interface Result {
     password: Uint8Array;
     salt: Uint8Array;
 }
-export declare function scryptEncode(passphrase?: string | Uint8Array, salt?: Uint8Array<ArrayBufferLike>, params?: ScryptParams, onlyJs?: boolean): Result;
+export declare function scryptEncode(passphrase?: string | Uint8Array, salt?: Uint8Array, params?: ScryptParams, onlyJs?: boolean): Result;
 export {};

package/cjs/sr25519/agreement.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sr25519Agreement = sr25519Agreement;
-const scure_sr25519_1 = require("@pezkuwi/scure-sr25519");
+const sr25519_1 = require("@pezkuwi/scure-sr25519");
 const util_1 = require("@pezkuwi/util");
 /**
  * @name sr25519Agreement
@@ -16,5 +16,5 @@ function sr25519Agreement(secretKey, publicKey) {
     else if (secretKeyU8a.length !== 64) {
         throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
     }
-    return (0, scure_sr25519_1.getSharedSecret)(secretKeyU8a, publicKeyU8a);
+    return (0, sr25519_1.getSharedSecret)(secretKeyU8a, publicKeyU8a);
 }

package/cjs/xxhash/asU8a.d.ts

@@ -17,4 +17,4 @@ export declare function xxhashAsU8a(data: string | Uint8Array, bitLength?: 64 |
  * @name xxhashAsHex
  * @description Creates a xxhash64 hex from the input.
  */
-export declare const xxhashAsHex: (data: string | Uint8Array<ArrayBufferLike>, bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;
+export declare const xxhashAsHex: (data: string | Uint8Array, bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/keccak/asU8a.d.ts

@@ -27,4 +27,4 @@ export declare const keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolea
  * @name keccakAsHex
  * @description Creates a keccak hex string from the input.
  */
-export declare const keccakAsHex: (value: string | Uint8Array<ArrayBufferLike>, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;
+export declare const keccakAsHex: (value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@pezkuwi/util/types").HexString;

package/package.json

@@ -20,17 +20,15 @@
     "./cjs/packageDetect.js"
   ],
   "type": "module",
-  "version": "14.0.22",
-  "main": "./cjs/index.js",
-  "module": "./cjs/index.js",
+  "types": "./index.d.ts",
+  "version": "14.0.23",
   "browser": {
     "crypto": false,
     "stream": false
   },
-  "types": "./cjs/index.d.ts",
+  "main": "./cjs/index.js",
+  "module": "./index.js",
   "exports": {
-    "./cjs/package.json": "./cjs/package.json",
-    "./cjs/*": "./cjs/*.js",
     ".": {
       "module": {
         "types": "./index.d.ts",
@@ -535,6 +533,8 @@
         "default": "./bundleInit.js"
       }
     },
+    "./cjs/*": "./cjs/*.js",
+    "./cjs/package.json": "./cjs/package.json",
     "./crypto": {
       "module": {
         "types": "./crypto.d.ts",
@@ -1407,7 +1407,7 @@
         "default": "./packageDetect.js"
       }
     },
-    "./packageInfo.js": {
+    "./packageInfo": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -1421,7 +1421,7 @@
         "default": "./packageInfo.js"
       }
     },
-    "./packageInfo": {
+    "./packageInfo.js": {
       "module": {
         "types": "./packageInfo.d.ts",
         "default": "./packageInfo.js"
@@ -2041,17 +2041,17 @@
   "dependencies": {
     "@noble/curves": "^1.3.0",
     "@noble/hashes": "^1.3.3",
-    "@pezkuwi/networks": "14.0.22",
+    "@pezkuwi/networks": "14.0.23",
     "@pezkuwi/scure-sr25519": "^0.2.1",
-    "@pezkuwi/util": "14.0.22",
-    "@pezkuwi/wasm-crypto": "^7.5.11",
+    "@pezkuwi/util": "14.0.23",
+    "@pezkuwi/wasm-crypto": "^7.5.15",
     "@pezkuwi/wasm-util": "^7.5.10",
-    "@pezkuwi/x-bigint": "14.0.22",
-    "@pezkuwi/x-randomvalues": "14.0.22",
+    "@pezkuwi/x-bigint": "14.0.23",
+    "@pezkuwi/x-randomvalues": "14.0.23",
     "@scure/base": "^1.1.7",
     "tslib": "^2.8.0"
   },
   "peerDependencies": {
-    "@pezkuwi/util": "14.0.22"
+    "@pezkuwi/util": "14.0.23"
   }
 }

package/packageInfo.js

@@ -1 +1 @@
-export const packageInfo = { name: '@pezkuwi/util-crypto', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.22' };
+export const packageInfo = { name: '@pezkuwi/util-crypto', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '14.0.10' };

package/scrypt/encode.d.ts

@@ -4,5 +4,5 @@ interface Result {
     password: Uint8Array;
     salt: Uint8Array;
 }
-export declare function scryptEncode(passphrase?: string | Uint8Array, salt?: Uint8Array<ArrayBufferLike>, params?: ScryptParams, onlyJs?: boolean): Result;
+export declare function scryptEncode(passphrase?: string | Uint8Array, salt?: Uint8Array, params?: ScryptParams, onlyJs?: boolean): Result;
 export {};

package/src/address/addressToEvm.spec.ts

@@ -0,0 +1,16 @@
+// 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

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,34 @@
+// 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

@@ -0,0 +1,45 @@
+// 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

@@ -0,0 +1,25 @@
+// 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

@@ -0,0 +1,138 @@
+// 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

@@ -0,0 +1,41 @@
+// 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

@@ -0,0 +1,12 @@
+// 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

@@ -0,0 +1,26 @@
+// 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

@@ -0,0 +1,36 @@
+// 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);
+}