[CI Skip] release/stable 12.6.1

skip-checks: true

.eslintignore

@@ -1,2 +0,0 @@
-packages/x-noble-hashes/**/*.ts
-packages/x-noble-secp256k1/**/*.ts

.eslintrc.cjs

@@ -1,22 +0,0 @@
-// Copyright 2017-2023 @polkadot/util authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-const base = require('@polkadot/dev/config/eslint.cjs');
-
-module.exports = {
-  ...base,
-  ignorePatterns: [
-    ...base.ignorePatterns
-  ],
-  parserOptions: {
-    ...base.parserOptions,
-    project: [
-      './tsconfig.eslint.json'
-    ]
-  },
-  rules: {
-    ...base.rules,
-    // this seems very broken atm, false positives
-    '@typescript-eslint/unbound-method': 'off'
-  }
-};

.github/workflows/pr-any.yml

@@ -22,5 +22,5 @@ jobs:
     - name: ${{ matrix.step }}
       if: always()
       run: |
-        yarn install --immutable | grep -v 'YN0013'
+        yarn install --immutable
         yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -27,5 +27,5 @@ jobs:
         node-version: 'lts/*'
     - name: ${{ matrix.step }}
       run: |
-        yarn install --immutable | grep -v 'YN0013'
+        yarn install --immutable
         yarn ${{ matrix.step }}

.prettierrc.cjs

@@ -1,4 +1,4 @@
-// Copyright 2017-2023 @polkadot/dev authors & contributors
+// Copyright 2017-2023 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 module.exports = require('@polkadot/dev/config/prettier.cjs');

.yarnrc.yml

@@ -2,6 +2,11 @@ enableImmutableInstalls: false
 
 enableProgressBars: false
 
+logFilters:
+  # Discard any "cannot be found in cache" messages
+  - code: YN0013
+    level: discard
+
 nodeLinker: node-modules
 
 plugins:

CHANGELOG.md

@@ -1,5 +1,96 @@
 # CHANGELOG
 
+## 12.6.1 Nov 18, 2023
+
+Contributed:
+
+- Ledger support for Quartz (Thanks to https://github.com/CertainLach)
+- Add flag to disable same-version esm/cjs warnings (Thanks to https://github.com/forgetso)
+
+Changes:
+
+- Adjust logger check for `process.env`
+- Adjust `isRiscV` helper to check for `PVM\0` bytes
+- Drop support for Node 16 (EOL 11 Sep 2023)
+- Upgrade dependencies to latest stable versions
+
+
+## 12.5.1 Sep 15, 2023
+
+Contributed:
+
+- Add `isRiskV` helper (Thanks to https://github.com/peetzweg)
+- Ledger support for Enjin & Matrixchain (Thanks to https://github.com/leonardocustodio)
+
+Changes:
+
+- Expand interface type comments (assists in-editor helpers)
+- Upgrade dependencies to latest stable versions
+
+
+## 12.4.2 Aug 23, 2023
+
+Changes:
+
+- Fix `u8aTo{BigInt, Bn, Number}` for non-negative `i{8, 16, 32...}` inputs
+- Extend `u8aToBuffer` with `hasBuffer` check
+- Adjust util tests (extract input/output arrays)
+
+
+## 12.4.1 Aug 17, 2023
+
+Changes:
+
+- Add support for Ledger `signRaw`, as exposed by lower-level
+- Update code to use `?.` shortcuts where appropriate
+- Adjust `u8aToBuffer` & `isBuffer` typings to not require `Buffer`
+- Use `stringify/import.meta.url` helpers in specs
+- Upgrade dependencies to latest stable versions
+
+
+## 12.3.2 Jun 12, 2023
+
+Changes:
+
+- Adjust `SubstrateNetwork` typing with `HexString` genesisHash
+- Re-export `Constructor<T>` type (deprecated, replaced with `Class<T>`)
+
+
+## 12.3.1 Jun 11, 2023
+
+Changes:
+
+- Only allow padding characters in base64 strings
+- Expand typings for keyring meta with known keys
+- Adjust object index access for stricter tsconfig settings
+
+
+## 12.2.2 Jun 4, 2023
+
+Changes:
+
+- Apply missing count assignment for `for (...)` loops
+- Remove unused `@types/*` dev dependencies
+- Upgrade dependencies to latest stable versions
+
+
+## 12.2.1 May 13, 2023
+
+Changes:
+
+- Align `u8aToBigInt` tests with `u8aToBn`
+- Unroll loops on most-frequently used paths for `u8aToBigInt`
+- Add `module` to `package.json` export map (ESM-only)
+- Upgrade dependencies to latest stable versions
+
+
+## 12.1.2 May 1, 2023
+
+Changes:
+
+- Adjust typing for `isChildClass` & `Constructor` usage
+
+
 ## 12.1.1 Apr 29, 2023
 
 Changes:

CONTRIBUTORS

@@ -1,5 +1,5 @@
-    1606	Jaco                          	12.1.1 (#1819)
-      12	Carlo Sala                    	feat(networks): support ledger for pendulum (#1739)
+    1665	Jaco                          	12.6.1 (#1897)
+      13	Carlo Sala                    	feat(networks): add zeitgeist Ledger support (#1840)
        9	Antoine Estienne              	Add eth uri keyring test (#1291)
        6	Amaury Martiny                	Add tests from Rust (#283)
        5	Jakub Pánik                   	Add HydraDX parachain to genesis (#1583)
@@ -25,6 +25,7 @@
        1	Brad Larson                   	[FIX] Adjust error message (#646)
        1	Cameron Fairchild             	Add bittensor details (#1783)
        1	Carlos Medeiros               	add hydradx to knownLedger (#1647)
+       1	Chris                         	Get rid of warnings for dual esm and cjs packages of the same version (#1890)
        1	Eliott Teissonniere           	add nodle ledger specs (#1089)
        1	Guilane DENGUIR               	feat(VTB): Added support for VTB blockchain (#1651)
        1	h4x3rotab                     	Throws an error when signing with a locked keypair (#578)
@@ -36,6 +37,7 @@
        1	JesseAbram                    	added check if valid address to docs (#440)
        1	joe petrowski                 	Add example for multisig address creation (#590)
        1	kaelnew                       	add ledger support for stafi (#1569)
+       1	Leonardo Custodio             	Ledger support (#1879)
        1	Lezek123                      	logger - wildcard include/exclude with DEBUG env (#932)
        1	Mario Neises                  	remove redudant export (#257)
        1	Miguel Hervas                 	Add CFG Ledger Support (#1057)
@@ -43,6 +45,7 @@
        1	Mohsan Riaz                   	Add Ternoa for ledger hardware support (#1711)
        1	nahuseyoum                    	Reserving 65 for Aventus based on the new extended range (#871)
        1	Nantian                       	add acala ledger config (#1485)
+       1	peetzweg/                     	adds `isRiscV` guard function similar to isWasm (#1878)
        1	qwer951123                    	Add acala genesis (#1161)
        1	Raoul Millais                 	Fix yarn add instructions in x-global README (#873)
        1	Raymond Zhong                 	Add Edgeware ledger app (#1006)
@@ -56,4 +59,5 @@
        1	Wei Tang                      	ss58: add Kulupu prefix to the list (#595)
        1	WoeOm                         	Handing high precision scenes (#450)
        1	xx network                    	Add xxnetwork genesis hash and ledger app (#1463)
+       1	Yaroslav Bolyukin             	Add quartz support for ledger, update unique slip-0044 identifier (#1882)
        1	Yuri                          	Extra check for process for browser bundles (#923)

eslint.config.js

@@ -0,0 +1,8 @@
+// Copyright 2017-2023 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import baseConfig from '@polkadot/dev/config/eslint';
+
+export default [
+  ...baseConfig
+];

package.json

@@ -14,10 +14,10 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "versions": {
-    "git": "12.1.1",
-    "npm": "12.1.1"
+    "git": "12.6.1",
+    "npm": "12.6.1"
   },
   "workspaces": [
     "packages/*"
@@ -37,10 +37,10 @@
     "test:one": "polkadot-dev-run-test --env browser"
   },
   "devDependencies": {
-    "@polkadot/dev": "^0.73.6",
-    "@types/node": "^18.16.2"
+    "@polkadot/dev": "^0.77.1",
+    "@types/node": "^20.9.1"
   },
   "resolutions": {
-    "typescript": "^5.0.4"
+    "typescript": "^5.2.2"
   }
 }

packages/hw-ledger-transports/package.json

@@ -2,7 +2,7 @@
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger-transports#readme",
   "license": "Apache-2.0",
@@ -14,18 +14,18 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "browser": "browser.js",
   "main": "node.js",
   "react-native": "react-native.js",
   "dependencies": {
-    "@ledgerhq/hw-transport": "^6.28.2",
-    "@ledgerhq/hw-transport-webhid": "^6.27.13",
-    "@ledgerhq/hw-transport-webusb": "^6.27.13",
-    "@polkadot/util": "12.1.1",
-    "tslib": "^2.5.0"
+    "@ledgerhq/hw-transport": "^6.29.0",
+    "@ledgerhq/hw-transport-webhid": "^6.27.20",
+    "@ledgerhq/hw-transport-webusb": "^6.27.20",
+    "@polkadot/util": "12.6.1",
+    "tslib": "^2.6.2"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.28.10"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.29.0"
   }
 }

packages/hw-ledger-transports/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '12.1.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '12.6.1' };

packages/hw-ledger-transports/tsconfig.build.json

@@ -5,6 +5,9 @@
     "outDir": "./build",
     "rootDir": "./src"
   },
+  "exclude": [
+    "**/mod.ts"
+  ],
   "references": [
     { "path": "../util/tsconfig.build.json" }
   ]

packages/hw-ledger/package.json

@@ -2,7 +2,7 @@
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger#readme",
   "license": "Apache-2.0",
@@ -17,12 +17,12 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/hw-ledger-transports": "12.1.1",
-    "@polkadot/util": "12.1.1",
-    "@zondax/ledger-substrate": "^0.40.7",
-    "tslib": "^2.5.0"
+    "@polkadot/hw-ledger-transports": "12.6.1",
+    "@polkadot/util": "12.6.1",
+    "@zondax/ledger-substrate": "^0.41.3",
+    "tslib": "^2.6.2"
   }
 }

packages/hw-ledger/src/bundle.ts

@@ -8,7 +8,7 @@ import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerVersion } fr
 import { newSubstrateApp } from '@zondax/ledger-substrate';
 
 import { transports } from '@polkadot/hw-ledger-transports';
-import { hexAddPrefix, u8aToBuffer } from '@polkadot/util';
+import { hexAddPrefix, u8aToBuffer, u8aWrapBytes } from '@polkadot/util';
 
 import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants.js';
 import { ledgerApps } from './defaults.js';
@@ -30,6 +30,17 @@ async function wrapError <T extends WrappedResult> (promise: Promise<T>): Promis
   return result;
 }
 
+/** @internal Wraps a sign/signRaw call and returns the associated signature */
+function sign (method: 'sign' | 'signRaw', message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): (app: SubstrateApp) => Promise<LedgerSignature> {
+  return async (app: SubstrateApp): Promise<LedgerSignature> => {
+    const { signature } = await wrapError(app[method](account + accountOffset, change, addressIndex + addressOffset, u8aToBuffer(message)));
+
+    return {
+      signature: hexAddPrefix(signature.toString('hex'))
+    };
+  };
+}
+
 /**
  * @name Ledger
  *
@@ -89,17 +100,17 @@ export class Ledger {
   }
 
   /**
-   * Signs a transcation on the Ledger device
+   * Signs a transaction on the Ledger device
    */
-  public async sign (message: Uint8Array, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerSignature> {
-    return this.withApp(async (app: SubstrateApp): Promise<LedgerSignature> => {
-      const buffer = u8aToBuffer(message);
-      const { signature } = await wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));
+  public async sign (message: Uint8Array, accountOffset?: number, addressOffset?: number, options?: Partial<AccountOptions>): Promise<LedgerSignature> {
+    return this.withApp(sign('sign', message, accountOffset, addressOffset, options));
+  }
 
-      return {
-        signature: hexAddPrefix(signature.toString('hex'))
-      };
-    });
+  /**
+   * Signs a message (non-transactional) on the Ledger device
+   */
+  public async signRaw (message: Uint8Array, accountOffset?: number, addressOffset?: number, options?: Partial<AccountOptions>): Promise<LedgerSignature> {
+    return this.withApp(sign('signRaw', u8aWrapBytes(message), accountOffset, addressOffset, options));
   }
 
   /**

packages/hw-ledger/src/defaults.ts

@@ -15,6 +15,7 @@ export const ledgerApps: Record<string, string> = {
   darwinia: 'Darwinia',
   'dock-mainnet': 'Dock',
   edgeware: 'Edgeware',
+  enjin: 'Enjin',
   equilibrium: 'Equilibrium',
   genshiro: 'Genshiro',
   hydradx: 'HydraDX',
@@ -22,6 +23,7 @@ export const ledgerApps: Record<string, string> = {
   karura: 'Karura',
   khala: 'Khala',
   kusama: 'Kusama',
+  matrixchain: 'Matrixchain',
   nodle: 'Nodle',
   origintrail: 'OriginTrail',
   parallel: 'Parallel',
@@ -31,6 +33,7 @@ export const ledgerApps: Record<string, string> = {
   polkadex: 'Polkadex',
   polkadot: 'Polkadot',
   polymesh: 'Polymesh',
+  quartz: 'Quartz',
   sora: 'Sora',
   stafi: 'Stafi',
   statemine: 'Statemine',
@@ -38,5 +41,6 @@ export const ledgerApps: Record<string, string> = {
   ternoa: 'Ternoa',
   unique: 'Unique',
   vtb: 'VTB',
-  xxnetwork: 'XXNetwork'
+  xxnetwork: 'XXNetwork',
+  zeitgeist: 'Zeitgeist'
 };

packages/hw-ledger/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '12.1.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '12.6.1' };

packages/hw-ledger/tsconfig.build.json

@@ -5,6 +5,10 @@
     "outDir": "./build",
     "rootDir": "./src"
   },
+  "exclude": [
+    "**/*.spec.ts",
+    "**/mod.ts"
+  ],
   "references": [
     { "path": "../hw-ledger-transports/tsconfig.build.json" },
     { "path": "../util/tsconfig.build.json" }

packages/hw-ledger/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src",
+    "emitDeclarationOnly": false,
+    "noEmit": true
+  },
+  "include": [
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../hw-ledger/tsconfig.build.json" }
+  ]
+}

packages/keyring/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "Keyring management",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "license": "Apache-2.0",
@@ -18,15 +18,15 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/util": "12.1.1",
-    "@polkadot/util-crypto": "12.1.1",
-    "tslib": "^2.5.0"
+    "@polkadot/util": "12.6.1",
+    "@polkadot/util-crypto": "12.6.1",
+    "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "12.1.1",
-    "@polkadot/util-crypto": "12.1.1"
+    "@polkadot/util": "12.6.1",
+    "@polkadot/util-crypto": "12.6.1"
   }
 }

packages/keyring/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '12.1.1' };
+export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '12.6.1' };

packages/keyring/src/pair/index.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types.js';
 import type { PairInfo } from './types.js';
@@ -165,7 +164,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     setMeta: (additional: KeyringPair$Meta): void => {
       meta = objectSpread({}, meta, additional);
     },
-    sign: (message: HexString | string | Uint8Array, options: SignOptions = {}): Uint8Array => {
+    sign: (message: string | Uint8Array, options: SignOptions = {}): Uint8Array => {
       if (isLocked(secretKey)) {
         throw new Error('Cannot sign with a locked key pair');
       }
@@ -192,10 +191,10 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     unlock: (passphrase?: string): void => {
       return decodePkcs8(passphrase);
     },
-    verify: (message: HexString | string | Uint8Array, signature: HexString | string | Uint8Array, signerPublic: HexString | string | Uint8Array): boolean => {
+    verify: (message: string | Uint8Array, signature: string | Uint8Array, signerPublic: string | Uint8Array): boolean => {
       return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
     },
-    vrfSign: (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
+    vrfSign: (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
       if (isLocked(secretKey)) {
         throw new Error('Cannot sign with a locked key pair');
       }
@@ -208,7 +207,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
 
       return u8aConcat(vrfHash(proof, context, extra), proof);
     },
-    vrfVerify: (message: HexString | string | Uint8Array, vrfResult: Uint8Array, signerPublic: HexString | Uint8Array | string, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): boolean => {
+    vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean => {
       if (type === 'sr25519') {
         return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
       }

packages/keyring/src/pairs.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { KeyringPair, KeyringPairs } from './types.js';
 
 import { isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
@@ -22,7 +21,7 @@ export class Pairs implements KeyringPairs {
     return Object.values(this.#map);
   }
 
-  public get (address: HexString | string | Uint8Array): KeyringPair {
+  public get (address: string | Uint8Array): KeyringPair {
     const pair = this.#map[decodeAddress(address).toString()];
 
     if (!pair) {
@@ -36,7 +35,7 @@ export class Pairs implements KeyringPairs {
     return pair;
   }
 
-  public remove (address: HexString | string | Uint8Array): void {
+  public remove (address: string | Uint8Array): void {
     delete this.#map[decodeAddress(address).toString()];
   }
 }

packages/keyring/src/suri.spec.ts

@@ -95,7 +95,7 @@ describe('keyring.addFromUri', (): void => {
   for (const [type, tests] of Object.entries(TESTS)) {
     const keyring = new Keyring({ type: type as KeypairType });
 
-    describe(type, (): void => {
+    describe(`${type}`, (): void => {
       tests.forEach(({ pk, ss, uri }): void => {
         it(`creates ${uri}`, (): void => {
           const pair = keyring.addFromUri(uri, {}, type as KeypairType);

packages/keyring/src/testing.ts

@@ -119,7 +119,7 @@ function createMeta (name?: string, seed?: string) {
 
   return {
     isTesting: true,
-    name: name || (seed && seed.replace('//', '_').toLowerCase())
+    name: name || seed?.replace('//', '_').toLowerCase()
   };
 }
 

packages/keyring/src/testingPairs.spec.ts

@@ -42,12 +42,10 @@ describe('testingPairs', (): void => {
     const keyring = new Keyring({ type: 'ethereum' });
     const pair = keyring.createFromUri('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133');
 
-    expect(
-      pair && pair.address
-    ).toEqual(TEST_ADD);
+    expect(pair?.address).toEqual(TEST_ADD);
   });
 
-  it('checks eth test addresses', (): void => {
+  describe('checks eth test addresses', (): void => {
     const ring = createTestPairs({ type: 'ethereum' });
     const keyring = new Keyring({ type: 'ethereum' });
     // priv keys generated by  ganache-cli --mnemonic "bottom drive obey lake curtain smoke basket hold race lonely fit walk"
@@ -62,12 +60,20 @@ describe('testingPairs', (): void => {
       '0x4c42532034540267bf568198ccec4cb822a025da542861fcb146a5fab6433ff8',
       '0x94c49300a58d576011096bcb006aa06f5a91b34b4383891e8029c21dc39fbb8b'];
 
+    // @ts-expect-error We should not delete from the maps, however this is a test
     delete ring.nobody;
 
-    Object.keys(ring).forEach((testKeyring, i) => {
-      if (i < 6) {
-        expect(u8aToHex(ring[testKeyring].publicKey)).toEqual(u8aToHex(keyring.createFromUri(privKeys[i]).publicKey));
-      }
-    });
+    Object
+      .keys(ring)
+      .filter((_, i) => i < 6)
+      .forEach((testKeyring, i) => {
+        it(`checks #${i}`, (): void => {
+          expect(
+            u8aToHex(ring[testKeyring].publicKey)
+          ).toEqual(
+            u8aToHex(keyring.createFromUri(privKeys[i]).publicKey)
+          );
+        });
+      });
   });
 });

packages/keyring/src/testingPairs.ts

@@ -1,23 +1,56 @@
 // Copyright 2017-2023 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringOptions, KeyringPair } from './types.js';
 
 import { nobody } from './pair/nobody.js';
 import { createTestKeyring } from './testing.js';
 
 export interface TestKeyringMap {
+  nobody: KeyringPair;
+
   [index: string]: KeyringPair;
 }
 
-export function createTestPairs (options?: KeyringOptions, isDerived = true): TestKeyringMap {
+export interface TestKeyringMapSubstrate extends TestKeyringMap {
+  alice: KeyringPair;
+  bob: KeyringPair;
+  charlie: KeyringPair;
+  dave: KeyringPair;
+  eve: KeyringPair;
+  ferdie: KeyringPair;
+}
+
+export interface TestKeyringMapEthereum extends TestKeyringMap {
+  Alith: KeyringPair;
+  Baltathar: KeyringPair;
+  Charleth: KeyringPair;
+  Dorothy: KeyringPair;
+  Ethan: KeyringPair;
+  Faith: KeyringPair;
+}
+
+export type DetectMap<O extends KeyringOptions | undefined> = DetectPairType<O> extends 'ethereum'
+  ? TestKeyringMapEthereum
+  : TestKeyringMapSubstrate;
+
+export type DetectPairType<O extends KeyringOptions | undefined> = O extends KeyringOptions
+  ? O['type'] extends KeypairType
+    ? O['type']
+    : 'sr25519'
+  : 'sr25519';
+
+export function createTestPairs <O extends KeyringOptions, M = DetectMap<O>> (options?: O, isDerived = true): M {
   const keyring = createTestKeyring(options, isDerived);
   const pairs = keyring.getPairs();
   const map: TestKeyringMap = { nobody: nobody() };
 
   for (const p of pairs) {
-    map[p.meta.name as string] = p;
+    if (p.meta.name) {
+      map[p.meta.name] = p;
+    }
   }
 
-  return map;
+  return map as M;
 }

packages/keyring/src/types.ts

@@ -5,29 +5,74 @@ import type { HexString } from '@polkadot/util/types';
 import type { EncryptedJson, Keypair, KeypairType, Prefix } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
-  /**
-   * @description The ss58Format to use for address encoding (defaults to 42)
-   */
+  /** The ss58Format to use for address encoding (defaults to 42) */
   ss58Format?: Prefix;
-  /**
-   * @description The type of keyring to create (defaults to ed25519)
-   */
+  /** The type of keyring to create (defaults to ed25519) */
   type?: KeypairType;
 }
 
-export type KeyringPair$Meta = Record<string, unknown>;
+export interface KeyringPair$MetaHardware {
+  accountIndex?: number;
+  accountOffset?: number;
+  addressOffset?: number;
+  hardwareType?: 'ledger';
+}
+
+export interface KeyringPair$MetaFlags {
+  isDefaultAuthSelected?: boolean;
+  isExternal?: boolean;
+  isHardware?: boolean;
+  isHidden?: boolean;
+  isInjected?: boolean;
+  isMultisig?: boolean;
+  isProxied?: boolean;
+  isRecent?: boolean;
+  isTesting?: boolean;
+}
+
+export interface KeyringPair$MetaContract {
+  abi: string;
+  genesisHash?: HexString | null;
+}
+
+export interface KeyringPair$MetaExtension {
+  source?: string;
+}
+
+export interface KeyringPair$MetaMultisig {
+  threshold?: number;
+  who?: string[];
+}
+
+export interface KeyringPair$MetaParent {
+  parentAddress?: string;
+  parentName?: string;
+}
+
+export interface KeyringPair$Meta extends KeyringPair$MetaExtension, KeyringPair$MetaFlags, KeyringPair$MetaHardware, KeyringPair$MetaMultisig, KeyringPair$MetaParent {
+  address?: string;
+  contract?: KeyringPair$MetaContract;
+  genesisHash?: HexString | null;
+  name?: string;
+  suri?: string;
+  tags?: string[];
+  type?: KeypairType;
+  whenCreated?: number;
+  whenEdited?: number;
+  whenUsed?: number;
+
+  [key: string]: unknown;
+}
 
 export interface KeyringPair$Json extends EncryptedJson {
   /** The ss58 encoded address or the hex-encoded version (the latter is for ETH-compat chains) */
-  address: string | HexString;
+  address: string;
   /** The underlying metadata associated with the keypair */
   meta: KeyringPair$Meta;
 }
 
 export interface SignOptions {
-  /**
-   * @description Create a MultiSignature-compatible output with an indicator type
-   **/
+  /** Create a MultiSignature-compatible output with an indicator type */
   withType?: boolean;
 }
 
@@ -44,12 +89,12 @@ export interface KeyringPair {
   encodePkcs8 (passphrase?: string): Uint8Array;
   lock (): void;
   setMeta (meta: KeyringPair$Meta): void;
-  sign (message: HexString | string | Uint8Array, options?: SignOptions): Uint8Array;
+  sign (message: string | Uint8Array, options?: SignOptions): Uint8Array;
   toJson (passphrase?: string): KeyringPair$Json;
   unlock (passphrase?: string): void;
-  verify (message: HexString | string | Uint8Array, signature: Uint8Array, signerPublic: HexString | string | Uint8Array): boolean;
-  vrfSign (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): Uint8Array;
-  vrfVerify (message: HexString | string | Uint8Array, vrfResult: Uint8Array, signerPublic: HexString | Uint8Array | string, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): boolean;
+  verify (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array): boolean;
+  vrfSign (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
+  vrfVerify (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
 }
 
 export interface KeyringPairs {

packages/keyring/tsconfig.build.json

@@ -5,6 +5,10 @@
     "outDir": "./build",
     "rootDir": "./src"
   },
+  "exclude": [
+    "**/*.spec.ts",
+    "**/mod.ts"
+  ],
   "references": [
     { "path": "../util/tsconfig.build.json" },
     { "path": "../util-crypto/tsconfig.build.json" }

packages/keyring/tsconfig.spec.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src",
+    "emitDeclarationOnly": false,
+    "noEmit": true
+  },
+  "include": [
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../keyring/tsconfig.build.json" },
+    { "path": "../util/tsconfig.build.json" },
+    { "path": "../util-crypto/tsconfig.build.json" }
+  ]
+}

packages/networks/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "license": "Apache-2.0",
@@ -15,14 +15,14 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "main": "index.js",
   "dependencies": {
-    "@polkadot/util": "12.1.1",
-    "@substrate/ss58-registry": "^1.40.0",
-    "tslib": "^2.5.0"
+    "@polkadot/util": "12.6.1",
+    "@substrate/ss58-registry": "^1.44.0",
+    "tslib": "^2.6.2"
   },
   "devDependencies": {
-    "@polkadot/hw-ledger": "12.1.1"
+    "@polkadot/hw-ledger": "12.6.1"
   }
 }

packages/networks/src/defaults.spec.ts

@@ -6,22 +6,33 @@
 import { ledgerApps } from '@polkadot/hw-ledger/defaults';
 import { isHex } from '@polkadot/util';
 
-import { knownGenesis, knownLedger } from './defaults/index.js';
+import { knownGenesis, knownLedger, knownTestnet } from './defaults/index.js';
 
 describe('defaults', (): void => {
+  const genesisKeys = Object.keys(knownGenesis);
+  const ledgerKeys = Object.keys(knownLedger);
+
   describe('genesis', (): void => {
     it('has hex values for all genesis chains', (): void => {
       expect(
-        Object.keys(knownGenesis).filter((network) =>
+        genesisKeys.filter((network) =>
           !knownGenesis[network].length ||
           knownGenesis[network].some((g) => !isHex(g, 256))
         )
       ).toEqual([]);
     });
 
+    it('has no entries for testnets', (): void => {
+      expect(
+        genesisKeys.filter((network) =>
+          knownTestnet[network]
+        )
+      ).toEqual([]);
+    });
+
     it('has genesis for all Ledger chains', (): void => {
       expect(
-        Object.keys(knownLedger).filter((network) =>
+        ledgerKeys.filter((network) =>
           !knownGenesis[network]
         )
       ).toEqual([]);
@@ -31,7 +42,7 @@ describe('defaults', (): void => {
   describe('Ledger', (): void => {
     it('has entries for each of the apps (hwledger -> networks)', (): void => {
       expect(
-        Object.keys(knownLedger).filter((network) =>
+        ledgerKeys.filter((network) =>
           !ledgerApps[network]
         )
       ).toEqual([]);

packages/networks/src/defaults/genesis.ts

@@ -3,10 +3,14 @@
 
 import type { KnownGenesis } from '../types.js';
 
-// NOTE: In the case where the network was hard-spooned and multiple genesisHashes
-// are provided, it needs to be in reverse order, i.e. most-recent first, oldest
-// last. This make lookups for the current a simple genesisHash[0]
-// (See Kusama as an example)
+// In the case where the network was hard-spooned and multiple genesisHashes
+// are provided, it needs to be in reverse order, i.e. most-recent goes first,
+// oldest goes last. This make lookups for the current a simple genesisHash[0]
+// where the latest ios always the first entry (See Kusama as an example)
+//
+// IMPORTANT: Apart from the test relays, this list is limited to live parachains
+// and live production  networks. It does not and should not contain any testnets,
+// either stand-alone or connected to test relays such as Westend/Rococo
 export const knownGenesis: KnownGenesis = {
   acala: [
     '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
@@ -52,6 +56,9 @@ export const knownGenesis: KnownGenesis = {
   edgeware: [
     '0x742a2ca70c2fda6cee4f8df98d64c4c670a052d9568058982dad9d5a7a135c5b'
   ],
+  enjin: [
+    '0xd8761d3c88f26dc12875c00d3165f7d67243d56fc85b4cf19937601a7916e5a9'
+  ],
   equilibrium: [
     '0x6f1a800de3daff7f5e037ddf66ab22ce03ab91874debeddb1086f5f7dbd48925'
   ],
@@ -82,6 +89,9 @@ export const knownGenesis: KnownGenesis = {
     '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
     '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
   ],
+  matrixchain: [
+    '0x3af4ff48ec76d2efc8476730f423ac07e25ad48f5f4c9dc39c778b164d808615'
+  ],
   nodle: [
     '0x97da7ede98d7bad4e36b4d734b6055425a3be036da2a332ea5a7037656427a21'
   ],
@@ -113,6 +123,9 @@ export const knownGenesis: KnownGenesis = {
   polymesh: [
     '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
   ],
+  quartz: [
+    '0xcd4d732201ebe5d6b014edda071c4203e16867305332301dc8d092044b28e554'
+  ],
   rococo: [
     '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
     '0xaaf2cd1b74b5f726895921259421b534124726263982522174147046b8827897',
@@ -157,5 +170,8 @@ export const knownGenesis: KnownGenesis = {
   ],
   xxnetwork: [
     '0x50dd5d206917bf10502c68fb4d18a59fc8aa31586f4e8856b493e43544aa82aa'
+  ],
+  zeitgeist: [
+    '0x1bf2a2ecb4a868de66ea8610f2ce7c8c43706561b6476031315f6640fe38e060'
   ]
 };

packages/networks/src/defaults/ledger.ts

@@ -19,6 +19,7 @@ export const knownLedger: KnownLedger = {
   darwinia: 0x00000162,
   'dock-mainnet': 0x00000252,
   edgeware: 0x0000020b,
+  enjin: 0x00000483,
   equilibrium: 0x05f5e0fd,
   genshiro: 0x05f5e0fc,
   hydradx: 0x00000162,
@@ -26,6 +27,7 @@ export const knownLedger: KnownLedger = {
   karura: 0x000002ae,
   khala: 0x000001b2,
   kusama: 0x000001b2,
+  matrixchain: 0x00000483,
   nodle: 0x000003eb,
   origintrail: 0x00000162,
   parallel: 0x00000162,
@@ -35,12 +37,14 @@ export const knownLedger: KnownLedger = {
   polkadex: 0x0000031f,
   polkadot: 0x00000162,
   polymesh: 0x00000253,
+  quartz: 0x00000277,
   sora: 0x00000269,
   stafi: 0x0000038b,
   statemine: 0x000001b2, // common-good on Kusama, shares derivation
   statemint: 0x00000162, // common-good on Polkadot, shares derivation
   ternoa: 0x00003e3,
-  unique: 0x00000162,
+  unique: 0x00000295,
   vtb: 0x000002b6,
-  xxnetwork: 0x000007a3
+  xxnetwork: 0x000007a3,
+  zeitgeist: 0x00000162
 };

packages/networks/src/index.spec.ts

@@ -115,6 +115,6 @@ describe('selectableNetworks', (): void => {
 
   it('has a sorted list (first external, last external)', (): void => {
     expect(selectableNetworks[3].displayName).toEqual('3DP network');
-    expect(selectableNetworks[selectableNetworks.length - 1].displayName).toEqual('xx network');
+    expect(selectableNetworks[selectableNetworks.length - 1].displayName).toEqual('Zeitgeist');
   });
 });

packages/networks/src/interfaces.ts

@@ -29,8 +29,8 @@ function toExpanded (o: KnownSubstrate): SubstrateNetwork {
   n.isIgnored = n.isTestnet || (
     !(
       o.standardAccount &&
-      o.decimals && o.decimals.length &&
-      o.symbols && o.symbols.length
+      o.decimals?.length &&
+      o.symbols?.length
     ) &&
     o.prefix !== 42
   );

packages/networks/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '12.1.1' };
+export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '12.6.1' };

packages/networks/src/ss58registry.spec.ts

@@ -5,24 +5,30 @@
 
 import known from '@substrate/ss58-registry';
 import fs from 'node:fs';
-import path from 'node:path';
 
-const other = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'packages/networks/src/test/ss58registry.test.json'), 'utf-8')) as unknown;
+import { stringify } from '@polkadot/util';
 
 describe('@substrate/ss58-registry', (): void => {
   it('has known values', (): void => {
-    const json = JSON.stringify(known, null, 2);
+    const testUrl = new URL('../test/ss58registry.json', import.meta.url);
+    const json = stringify(known, 2);
 
     try {
-      expect(JSON.parse(json)).toEqual(other);
+      expect(
+        JSON.parse(json)
+      ).toEqual(
+        JSON.parse(
+          fs.readFileSync(testUrl, 'utf-8')
+        )
+      );
     } catch (error) {
-      if (process.env.GITHUB_REPOSITORY) {
+      if (process.env['GITHUB_REPOSITORY']) {
         console.error(json);
 
         throw error;
       }
 
-      fs.writeFileSync(path.join(process.cwd(), 'packages/networks/src/test/ss58registry.test.json'), json, { flag: 'w' });
+      fs.writeFileSync(testUrl, json, { flag: 'w' });
     }
   });
 });

packages/networks/src/types.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { RegistryEntry } from '@substrate/ss58-registry';
+import type { HexString } from '@polkadot/util/types';
 
 export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate';
 
@@ -9,22 +10,29 @@ export type KnownIcon = Record<string, Icon>;
 
 export type KnownLedger = Record<string, number>;
 
-export type KnownGenesis = Record<string, string[]>;
+export type KnownGenesis = Record<string, HexString[]>;
 
 export type KnownSubstrate = RegistryEntry;
 
 export type KnownTestnet = Record<string, true>;
 
 export interface SubstrateNetwork extends KnownSubstrate {
-  genesisHash: string[];
+  /** The genesisHash for the chain */
+  genesisHash: HexString[];
+  /** Does the chain has support for Ledger devices */
   hasLedgerSupport: boolean;
+  /** The IdentityIcon to use for the chain */
   icon: Icon;
+  /** Flag set when we don't include this chain */
   isIgnored: boolean;
+  /** Flag to indicate a testnet */
   isTestnet: boolean;
+  /** The Ledger-specific/required slip44 for the chain */
   slip44?: number | null;
 }
 
 export interface Network extends SubstrateNetwork {
+  /** The network assigned to this chain */
   network: string;
 }
 

packages/networks/test/ss58registry.json

@@ -222,15 +222,13 @@
     "network": "darwinia",
     "displayName": "Darwinia Network",
     "symbols": [
-      "RING",
-      "KTON"
+      "RING"
     ],
     "decimals": [
-      9,
-      9
+      18
     ],
-    "standardAccount": "*25519",
-    "website": "https://darwinia.network/"
+    "standardAccount": "secp256k1",
+    "website": "https://darwinia.network"
   },
   {
     "prefix": 19,
@@ -258,6 +256,19 @@
     "standardAccount": "*25519",
     "website": "https://stafi.io"
   },
+  {
+    "prefix": 21,
+    "network": "karmachain",
+    "displayName": "Karmacoin",
+    "symbols": [
+      "KCOIN"
+    ],
+    "decimals": [
+      6
+    ],
+    "standardAccount": "*25519",
+    "website": "https://karmaco.in"
+  },
   {
     "prefix": 22,
     "network": "dock-pos-mainnet",
@@ -497,12 +508,16 @@
   },
   {
     "prefix": 41,
-    "network": "poli",
-    "displayName": "Polimec Chain",
-    "symbols": [],
-    "decimals": [],
+    "network": "polimec",
+    "displayName": "Polimec Protocol",
+    "symbols": [
+      "PLMC"
+    ],
+    "decimals": [
+      10
+    ],
     "standardAccount": "*25519",
-    "website": "https://polimec.io/"
+    "website": "https://www.polimec.org/"
   },
   {
     "prefix": 42,
@@ -713,6 +728,19 @@
     "standardAccount": "*25519",
     "website": "https://hydradx.io"
   },
+  {
+    "prefix": 64,
+    "network": "ewx",
+    "displayName": "Energy Web X",
+    "symbols": [
+      "EWT"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.energyweb.org"
+  },
   {
     "prefix": 65,
     "network": "aventus",
@@ -1168,6 +1196,32 @@
     "standardAccount": "*25519",
     "website": "https://sora.org"
   },
+  {
+    "prefix": 440,
+    "network": "allfeat_network",
+    "displayName": "Allfeat Network",
+    "symbols": [
+      "AFT"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://allfeat.network"
+  },
+  {
+    "prefix": 666,
+    "network": "metaquity_network",
+    "displayName": "Metaquity Network",
+    "symbols": [
+      "MQTY"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://metaquity.xyz/"
+  },
   {
     "prefix": 789,
     "network": "geek",
@@ -1402,6 +1456,19 @@
     "standardAccount": "*25519",
     "website": "https://chainflip.io/"
   },
+  {
+    "prefix": 2199,
+    "network": "moonsama",
+    "displayName": "Moonsama",
+    "symbols": [
+      "SAMA"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "secp256k1",
+    "website": "https://moonsama.com"
+  },
   {
     "prefix": 2206,
     "network": "ICE",
@@ -1441,6 +1508,19 @@
     "standardAccount": "*25519",
     "website": "https://subspace.network"
   },
+  {
+    "prefix": 3333,
+    "network": "peerplays",
+    "displayName": "Peerplays",
+    "symbols": [
+      "PPY"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "secp256k1",
+    "website": "https://www.peerplays.com/"
+  },
   {
     "prefix": 4006,
     "network": "tangle",
@@ -1523,6 +1603,19 @@
     "standardAccount": "*25519",
     "website": "https://gmordie.com"
   },
+  {
+    "prefix": 7306,
+    "network": "krigan",
+    "displayName": "Krigan Network",
+    "symbols": [
+      "KRGN"
+    ],
+    "decimals": [
+      9
+    ],
+    "standardAccount": "*25519",
+    "website": "https://krigan.network"
+  },
   {
     "prefix": 7391,
     "network": "unique_mainnet",
@@ -1536,6 +1629,19 @@
     "standardAccount": "*25519",
     "website": "https://unique.network"
   },
+  {
+    "prefix": 8866,
+    "network": "golden_gate",
+    "displayName": "Golden Gate",
+    "symbols": [
+      "GGX"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://ggxchain.io/"
+  },
   {
     "prefix": 8883,
     "network": "sapphire_mainnet",
@@ -1549,6 +1655,19 @@
     "standardAccount": "*25519",
     "website": "https://unique.network"
   },
+  {
+    "prefix": 8886,
+    "network": "golden_gate_sydney",
+    "displayName": "Golden Gate Sydney",
+    "symbols": [
+      "GGXT"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://ggxchain.io/"
+  },
   {
     "prefix": 9072,
     "network": "hashed",
@@ -1691,5 +1810,18 @@
     ],
     "standardAccount": "*25519",
     "website": "https://bittensor.com"
+  },
+  {
+    "prefix": 14697,
+    "network": "goro",
+    "displayName": "GORO Network",
+    "symbols": [
+      "GORO"
+    ],
+    "decimals": [
+      9
+    ],
+    "standardAccount": "*25519",
+    "website": "https://goro.network"
   }
 ]

packages/networks/tsconfig.build.json

@@ -5,9 +5,10 @@
     "outDir": "./build",
     "rootDir": "./src"
   },
-  "include": [
-    "**/src/**/*.ts",
-    "**/test/*.json"
+  "exclude": [
+    "**/*.spec.ts",
+    "**/test/*",
+    "**/mod.ts"
   ],
   "references": [
     { "path": "../hw-ledger/tsconfig.build.json" },

packages/networks/tsconfig.spec.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src",
+    "emitDeclarationOnly": false,
+    "noEmit": true
+  },
+  "include": [
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../hw-ledger/tsconfig.build.json" },
+    { "path": "../networks/tsconfig.build.json" },
+    { "path": "../util/tsconfig.build.json" }
+  ]
+}

packages/util-crypto/package.json

@@ -3,7 +3,7 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "description": "A collection of useful crypto utilities for @polkadot",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "license": "Apache-2.0",
@@ -20,25 +20,25 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "12.1.1",
+  "version": "12.6.1",
   "browser": {
     "crypto": false,
     "stream": false
   },
   "main": "index.js",
   "dependencies": {
-    "@noble/curves": "1.0.0",
-    "@noble/hashes": "1.3.0",
-    "@polkadot/networks": "12.1.1",
-    "@polkadot/util": "12.1.1",
-    "@polkadot/wasm-crypto": "^7.1.2",
-    "@polkadot/wasm-util": "^7.1.2",
-    "@polkadot/x-bigint": "12.1.1",
-    "@polkadot/x-randomvalues": "12.1.1",
-    "@scure/base": "1.1.1",
-    "tslib": "^2.5.0"
+    "@noble/curves": "^1.2.0",
+    "@noble/hashes": "^1.3.2",
+    "@polkadot/networks": "12.6.1",
+    "@polkadot/util": "12.6.1",
+    "@polkadot/wasm-crypto": "^7.3.1",
+    "@polkadot/wasm-util": "^7.3.1",
+    "@polkadot/x-bigint": "12.6.1",
+    "@polkadot/x-randomvalues": "12.6.1",
+    "@scure/base": "^1.1.3",
+    "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "12.1.1"
+    "@polkadot/util": "12.6.1"
   }
 }

packages/util-crypto/src/address/addressToEvm.ts

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

packages/util-crypto/src/address/check.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { base58Decode } from '../base58/index.js';
@@ -14,7 +13,7 @@ import { defaults } from './defaults.js';
  * @description
  * From the provided input, validate that the address is a valid input.
  */
-export function checkAddress (address: HexString | string, prefix: Prefix): [boolean, string | null] {
+export function checkAddress (address: string, prefix: Prefix): [boolean, string | null] {
   let decoded;
 
   try {

packages/util-crypto/src/address/decode.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6
@@ -11,7 +10,7 @@ import { base58Decode } from '../base58/index.js';
 import { checkAddressChecksum } from './checksum.js';
 import { defaults } from './defaults.js';
 
-export function decodeAddress (encoded?: HexString | string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
+export function decodeAddress (encoded?: string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
   if (!encoded) {
     throw new Error('Invalid empty address passed');
   }

packages/util-crypto/src/address/derive.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { DeriveJunction } from '../key/DeriveJunction.js';
 import type { Prefix } from './types.js';
 
@@ -20,7 +19,7 @@ function filterHard ({ isHard }: DeriveJunction): boolean {
  * @description
  * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
  */
-export function deriveAddress (who: HexString | Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+export function deriveAddress (who: string | Uint8Array, suri: string, ss58Format?: Prefix): string {
   const { path } = keyExtractPath(suri);
 
   if (!path.length || path.every(filterHard)) {

packages/util-crypto/src/address/encode.spec.ts

@@ -5,8 +5,10 @@
 
 import { encodeAddress } from './index.js';
 
+// eslint-disable-next-line jest/no-export
 export const ALICE_PUBLIC_SR = new Uint8Array([212, 53, 147, 199, 21, 253, 211, 28, 97, 20, 26, 189, 4, 169, 159, 214, 130, 44, 133, 88, 133, 76, 205, 227, 154, 86, 132, 231, 165, 109, 162, 125]);
 
+// eslint-disable-next-line jest/no-export
 export const ALICE_PUBLIC_ED = new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79]);
 
 const SUBKEY = [

packages/util-crypto/src/address/encode.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L34
@@ -12,7 +11,7 @@ import { decodeAddress } from './decode.js';
 import { defaults } from './defaults.js';
 import { sshash } from './sshash.js';
 
-export function encodeAddress (key: HexString | Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
+export function encodeAddress (key: string | Uint8Array, ss58Format: Prefix = defaults.prefix): string {
   // decode it, this means we can re-encode an address
   const u8a = decodeAddress(key);
 

packages/util-crypto/src/address/encodeDerived.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { decodeAddress } from './decode.js';
@@ -15,6 +14,6 @@ import { createKeyDerived } from './keyDerived.js';
  * @description
  * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
  */
-export function encodeDerivedAddress (who: HexString | Uint8Array | string, index: bigint | BN | number, ss58Format?: Prefix): string {
+export function encodeDerivedAddress (who: string | Uint8Array, index: bigint | BN | number, ss58Format?: Prefix): string {
   return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
 }

packages/util-crypto/src/address/encodeMulti.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { encodeAddress } from './encode.js';
@@ -14,6 +13,6 @@ import { createKeyMulti } from './keyMulti.js';
  * @description
  * Creates a Substrate multisig address based on the input address and the required threshold.
  */
-export function encodeMultiAddress (who: (HexString | Uint8Array | string)[], threshold: bigint | BN | number, ss58Format?: Prefix): string {
+export function encodeMultiAddress (who: (string | Uint8Array)[], threshold: bigint | BN | number, ss58Format?: Prefix): string {
   return encodeAddress(createKeyMulti(who, threshold), ss58Format);
 }

packages/util-crypto/src/address/eq.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { u8aEq } from '@polkadot/util';
 
 import { decodeAddress } from './decode.js';
@@ -21,6 +19,6 @@ import { decodeAddress } from './decode.js';
  * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
  * ```
  */
-export function addressEq (a: HexString | string | Uint8Array, b: HexString | string | Uint8Array): boolean {
+export function addressEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
   return u8aEq(decodeAddress(a), decodeAddress(b));
 }

packages/util-crypto/src/address/evmToAddress.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { HashType } from '../secp256k1/types.js';
 import type { Prefix } from './types.js';
 
@@ -14,7 +13,7 @@ import { encodeAddress } from './encode.js';
  * @name evmToAddress
  * @summary Converts an EVM address to its corresponding SS58 address.
  */
-export function evmToAddress (evmAddress: HexString | string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
+export function evmToAddress (evmAddress: string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
   const message = u8aConcat('evm:', evmAddress);
 
   if (message.length !== 24) {

packages/util-crypto/src/address/is.ts

@@ -1,12 +1,11 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { validateAddress } from './validate.js';
 
-export function isAddress (address?: HexString | string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): address is string {
+export function isAddress (address?: string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): address is string {
   try {
     return validateAddress(address, ignoreChecksum, ss58Format);
   } catch {

packages/util-crypto/src/address/keyDerived.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
-import type { HexString } from '@polkadot/util/types';
 
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
@@ -12,7 +11,7 @@ import { decodeAddress } from './decode.js';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export function createKeyDerived (who: HexString | Uint8Array | string, index: bigint | BN | number): Uint8Array {
+export function createKeyDerived (who: string | Uint8Array, index: bigint | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

packages/util-crypto/src/address/keyMulti.ts

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
-import type { HexString } from '@polkadot/util/types';
 
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
 
@@ -12,7 +11,7 @@ import { addressToU8a } from './util.js';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export function createKeyMulti (who: (HexString | Uint8Array | string)[], threshold: bigint | BN | number): Uint8Array {
+export function createKeyMulti (who: (string | Uint8Array)[], threshold: bigint | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

packages/util-crypto/src/address/sort.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { u8aSorted } from '@polkadot/util';
@@ -9,7 +8,7 @@ import { u8aSorted } from '@polkadot/util';
 import { encodeAddress } from './encode.js';
 import { addressToU8a } from './util.js';
 
-export function sortAddresses (addresses: (HexString | Uint8Array | string)[], ss58Format?: Prefix): string[] {
+export function sortAddresses (addresses: (string | Uint8Array)[], ss58Format?: Prefix): string[] {
   const u8aToAddress = (u8a: Uint8Array) => encodeAddress(u8a, ss58Format);
 
   return u8aSorted(

packages/util-crypto/src/address/validate.ts

@@ -1,11 +1,10 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types.js';
 
 import { decodeAddress } from './decode.js';
 
-export function validateAddress (encoded?: HexString | string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): encoded is string {
+export function validateAddress (encoded?: string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): encoded is string {
   return !!decodeAddress(encoded, ignoreChecksum, ss58Format);
 }

packages/util-crypto/src/base32/helpers.ts

@@ -19,6 +19,7 @@ interface Config {
   ipfs?: string;
   regex?: RegExp;
   type: string;
+  withPadding?: boolean;
 }
 
 type DecodeFn = (value: string, ipfsCompat?: boolean) => Uint8Array;
@@ -63,21 +64,26 @@ export function createIs (validate: ValidateFn): ValidateFn {
 }
 
 /** @internal */
-export function createValidate ({ chars, ipfs, type }: Config): ValidateFn {
+export function createValidate ({ chars, ipfs, type, withPadding }: Config): ValidateFn {
   return (value?: unknown, ipfsCompat?: boolean): value is string => {
     if (typeof value !== 'string') {
       throw new Error(`Expected ${type} string input`);
-    } else if (ipfs && ipfsCompat && value[0] !== ipfs) {
+    } else if (ipfs && ipfsCompat && !value.startsWith(ipfs)) {
       throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
     }
 
-    for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
-      if (!(chars.includes(value[i]) || (
-        value[i] === '=' && (
-          (i === value.length - 1) ||
-          !chars.includes(value[i + 1])
-        )
-      ))) {
+    for (let i = (ipfsCompat ? 1 : 0), count = value.length; i < count; i++) {
+      if (chars.includes(value[i])) {
+        // all ok, character found
+      } else if (withPadding && value[i] === '=') {
+        if (i === count - 1) {
+          // last character, everything ok
+        } else if (value[i + 1] === '=') {
+          // next one is also padding, sequence ok
+        } else {
+          throw new Error(`Invalid ${type} padding sequence "${value[i]}${value[i + 1]}" at index ${i}`);
+        }
+      } else {
         throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
       }
     }

packages/util-crypto/src/base58/validate.spec.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2023 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { base58Validate } from './index.js';
+
+describe('base58Validate', (): void => {
+  it('validates encoded', (): void => {
+    expect(
+      base58Validate('a1UbyspTdnyZXLUQaQbciCxrCWWxz24kgSwGXSQnkbs', false)
+    ).toEqual(true);
+  });
+
+  it('fails on string with extra padding', (): void => {
+    expect(
+      () => base58Validate('a1UbyspTdnyZXLUQaQbciCxrCWWxz24kgSwGXSQnkbs=', false)
+    ).toThrow(/Invalid base58 character "="/);
+  });
+});

packages/util-crypto/src/base64/bs64.ts

@@ -8,7 +8,8 @@ import { createDecode, createEncode, createIs, createValidate } from '../base32/
 const config = {
   chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
   coder: base64,
-  type: 'base64'
+  type: 'base64',
+  withPadding: true
 };
 
 /**

packages/util-crypto/src/base64/trim.ts

@@ -6,7 +6,7 @@
  * @description Trims padding characters
  */
 export function base64Trim (value: string): string {
-  while (value.length && value[value.length - 1] === '=') {
+  while (value.length && value.endsWith('=')) {
     value = value.slice(0, -1);
   }
 

packages/util-crypto/src/base64/validate.spec.ts

@@ -11,4 +11,22 @@ describe('base64Validate', (): void => {
       () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
     ).toThrow(/Invalid base64 character "\^" \(0x5e\) at index 30/);
   });
+
+  it('validates with one extra padding character', (): void => {
+    expect(
+      base64Validate('bGlnaHQgd28=')
+    ).toEqual(true);
+  });
+
+  it('validates with two extra padding characters', (): void => {
+    expect(
+      base64Validate('bGlnaHQgdw==')
+    ).toEqual(true);
+  });
+
+  it('validates misplaced padding characters', (): void => {
+    expect(
+      () => base64Validate('bGlnaHQgdw=g=')
+    ).toThrow(/Invalid base64 padding sequence "=g"/);
+  });
 });

packages/util-crypto/src/blake2/asU8a.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { blake2b as blake2bJs } from '@noble/hashes/blake2b';
 
 import { hasBigInt, u8aToU8a } from '@polkadot/util';
@@ -24,7 +22,7 @@ import { createAsHex } from '../helpers.js';
  * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
  * ```
  */
-export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength: 64 | 128 | 256 | 384 | 512 = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
+export function blake2AsU8a (data: string | Uint8Array, bitLength: 64 | 128 | 256 | 384 | 512 = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
   const byteLength = Math.ceil(bitLength / 8);
   const u8a = u8aToU8a(data);
 

packages/util-crypto/src/crypto.spec.ts

@@ -3,9 +3,6 @@
 
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
-// no TS, this is not meant to be a global...
-export {};
-
 describe('cryptoWaitReady', (): void => {
   it('should return false when it cannot initialize', async (): Promise<void> => {
     const old = global.WebAssembly;

packages/util-crypto/src/ed25519/sign.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types.js';
 
 import { ed25519 } from '@noble/curves/ed25519';
@@ -23,7 +22,7 @@ import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';
  * ed25519Sign([...], [...]); // => [...]
  * ```
  */
-export function ed25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
+export function ed25519Sign (message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
   if (!secretKey) {
     throw new Error('Expected a valid secretKey');
   } else if (!publicKey) {

packages/util-crypto/src/ed25519/verify.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { ed25519 } from '@noble/curves/ed25519';
 
 import { hasBigInt, u8aToU8a } from '@polkadot/util';
@@ -22,7 +20,7 @@ import { ed25519Verify as wasmVerify, isReady } from '@polkadot/wasm-crypto';
  * ed25519Verify([...], [...], [...]); // => true/false
  * ```
  */
-export function ed25519Verify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, publicKey: HexString | Uint8Array | string, onlyJs?: boolean): boolean {
+export function ed25519Verify (message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, onlyJs?: boolean): boolean {
   const messageU8a = u8aToU8a(message);
   const publicKeyU8a = u8aToU8a(publicKey);
   const signatureU8a = u8aToU8a(signature);

packages/util-crypto/src/ethereum/encode.ts

@@ -16,7 +16,7 @@ function getH160 (u8a: Uint8Array): Uint8Array {
   return u8a.slice(-20);
 }
 
-export function ethereumEncode (addressOrPublic?: HexString | string | Uint8Array): HexString {
+export function ethereumEncode (addressOrPublic?: string | Uint8Array): HexString {
   if (!addressOrPublic) {
     return '0x';
   }

packages/util-crypto/src/ethereum/isAddress.ts

@@ -1,13 +1,11 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { isHex } from '@polkadot/util';
 
 import { isEthereumChecksum } from './isChecksum.js';
 
-export function isEthereumAddress (address?: HexString | string): boolean {
+export function isEthereumAddress (address?: string): boolean {
   if (!address || address.length !== 42 || !isHex(address)) {
     return false;
   } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {

packages/util-crypto/src/helpers.ts

@@ -21,14 +21,14 @@ export function createAsHex <T extends (...args: never[]) => Uint8Array> (fn: T)
 }
 
 /** @internal */
-export function createBitHasher (bitLength: 256 | 512, fn: (data: HexString | Uint8Array | string, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: HexString | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
-  return (data: HexString | Uint8Array | string, onlyJs?: boolean): Uint8Array =>
+export function createBitHasher (bitLength: 256 | 512, fn: (data: string | Uint8Array, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array {
+  return (data: string | Uint8Array, onlyJs?: boolean): Uint8Array =>
     fn(data, bitLength, onlyJs);
 }
 
 /** @internal */
-export function createDualHasher (wa: DualHash, js: DualHash): (value: HexString | Uint8Array | string, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
-  return (value: HexString | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
+export function createDualHasher (wa: DualHash, js: DualHash): (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
+  return (value: string | Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
     const u8a = u8aToU8a(value);
 
     return !hasBigInt || (!onlyJs && isReady())

packages/util-crypto/src/json/types.ts

@@ -1,19 +1,22 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
 
 export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
 
 export interface EncryptedJsonDescriptor {
+  /** Descriptor for the content */
   content: string[];
+  /** The encoding (in current/latest versions this is always an array) */
   type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
+  /** The version of encoding applied */
   version: EncryptedJsonVersion;
 }
 
 export interface EncryptedJson {
-  encoded: HexString | string;
+  /** The encoded string */
+  encoded: string;
+  /** The encoding used */
   encoding: EncryptedJsonDescriptor;
 }

packages/util-crypto/src/key/DeriveJunction.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { BN, bnToU8a, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
 
 import { blake2AsU8a } from '../blake2/asU8a.js';
@@ -46,7 +44,7 @@ export class DeriveJunction {
     return !this.#isHard;
   }
 
-  public hard (value: HexString | number | string | bigint | BN | Uint8Array): DeriveJunction {
+  public hard (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
     return this.soft(value).harden();
   }
 
@@ -56,7 +54,7 @@ export class DeriveJunction {
     return this;
   }
 
-  public soft (value: HexString | number | string | bigint | BN | Uint8Array): DeriveJunction {
+  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)) {

packages/util-crypto/src/key/extractPath.spec.ts

@@ -37,13 +37,13 @@ describe('keyExtractPath', (): void => {
     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', (): void => {
+  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', (): void => {
+  it('does not extract from invalid paths (2)', (): void => {
     expect(
       (): ExtractResult => keyExtractPath('hello')
     ).toThrow(/does not match input/);

packages/util-crypto/src/key/extractPath.ts

@@ -6,7 +6,7 @@ import { DeriveJunction } from './DeriveJunction.js';
 const RE_JUNCTION = /\/(\/?)([^/]+)/g;
 
 export interface ExtractResult {
-  parts: null | string[];
+  parts: string[] | null;
   path: DeriveJunction[];
 }
 

packages/util-crypto/src/key/extractSuri.ts

@@ -25,7 +25,7 @@ export function keyExtractSuri (suri: string): ExtractResult {
     throw new Error('Unable to match provided value to a secret URI');
   }
 
-  const [, phrase, , derivePath, , , password] = matches as string[];
+  const [, phrase, , derivePath, , , password] = matches;
   const { path } = keyExtractPath(derivePath);
 
   return {

packages/util-crypto/src/mnemonic/bip39.ts

@@ -81,7 +81,7 @@ export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAUL
 
   // calculate the checksum and compare
   const matched = entropyBits.match(/(.{1,8})/g);
-  const entropyBytes = matched && matched.map(binaryToByte);
+  const entropyBytes = matched?.map(binaryToByte);
 
   if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
     throw new Error(INVALID_ENTROPY);
@@ -103,7 +103,7 @@ export function entropyToMnemonic (entropy: Uint8Array, wordlist: string[] = DEF
   }
 
   const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
-  const mapped = matched && matched.map((b) => wordlist[binaryToByte(b)]);
+  const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
 
   if (!mapped || (mapped.length < 12)) {
     throw new Error('Unable to map entropy to mnemonic');

packages/util-crypto/src/mnemonic/toMiniSecretCmp.spec.ts

@@ -28,7 +28,7 @@ for (const onlyJsMnemonic of [false, true]) {
             // NOTE we cannot actually use the onlyJsMnemonic flag here
             const mnemonic = mnemonicGenerate(12);
 
-            describe(mnemonic, (): void => {
+            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 => {

packages/util-crypto/src/nacl/tweetnacl-secretbox.spec.ts

@@ -136,7 +136,7 @@ describe('tweetnacl/secretbox', (): void => {
   });
 
   describe('tweetnacl/test/04-secretbox.js', (): void => {
-    for (let i = 0; i < TEST_DATA.length; i++) {
+    for (let i = 0, count = TEST_DATA.length; i < count; i++) {
       const [keyBase64, nonceBase64, msgBase64, expBase64] = TEST_DATA[i];
 
       it(`is ok on "${msgBase64}"`, (): void => {

packages/util-crypto/src/nacl/tweetnacl.ts

@@ -958,7 +958,7 @@ function checkLengths (k: Uint8Array, n: Uint8Array): void {
 // }
 
 function checkArrayTypes (...args: unknown[]): void {
-  for (let i = 0; i < args.length; i++) {
+  for (let i = 0, count = args.length; i < count; i++) {
     if (!(args[i] instanceof Uint8Array))
       throw new TypeError('unexpected type, use Uint8Array');
   }

packages/util-crypto/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Do not edit, auto-generated by @polkadot/dev
 
-export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '12.1.1' };
+export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '12.6.1' };

packages/util-crypto/src/pbkdf2/encode.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { pbkdf2 as pbkdf2Js } from '@noble/hashes/pbkdf2';
 import { sha512 } from '@noble/hashes/sha512';
 
@@ -17,7 +15,7 @@ interface Result {
   salt: Uint8Array;
 }
 
-export function pbkdf2Encode (passphrase?: HexString | Uint8Array | string, salt: Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
+export function pbkdf2Encode (passphrase?: string | Uint8Array, salt: Uint8Array = randomAsU8a(), rounds = 2048, onlyJs?: boolean): Result {
   const u8aPass = u8aToU8a(passphrase);
   const u8aSalt = u8aToU8a(salt);
 

packages/util-crypto/src/scrypt/defaults.ts

@@ -1,7 +1,9 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export const DEFAULT_PARAMS = {
+import type { ScryptParams } from './types.js';
+
+export const DEFAULT_PARAMS: ScryptParams = {
   N: 1 << 15,
   p: 1,
   r: 8

packages/util-crypto/src/scrypt/encode.spec.ts

@@ -9,10 +9,13 @@ import { perfWasm } from '../test/index.js';
 import { DEFAULT_PARAMS } from './defaults.js';
 import { scryptEncode } from './index.js';
 
+// eslint-disable-next-line jest/no-export
 export const KNOWN_TEST = 'testing, 123';
 
+// eslint-disable-next-line jest/no-export
 export const KNOWN_PASS = new Uint8Array([223, 185, 241, 135, 125, 17, 195, 27, 64, 64, 154, 69, 47, 82, 123, 38, 255, 230, 199, 200, 101, 115, 21, 116, 119, 59, 67, 43, 58, 220, 112, 70, 124, 139, 240, 206, 42, 148, 140, 132, 64, 226, 164, 25, 104, 80, 49, 92, 144, 132, 109, 178, 76, 225, 171, 116, 151, 181, 34, 243, 177, 235, 134, 76]);
 
+// eslint-disable-next-line jest/no-export
 export const KNOWN_SALT = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8]);
 
 describe('scryptEncode', (): void => {

packages/util-crypto/src/scrypt/encode.ts

@@ -1,8 +1,7 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-import type { Params } from './types.js';
+import type { ScryptParams } from './types.js';
 
 import { scrypt as scryptJs } from '@noble/hashes/scrypt';
 
@@ -13,12 +12,12 @@ import { randomAsU8a } from '../random/asU8a.js';
 import { DEFAULT_PARAMS } from './defaults.js';
 
 interface Result {
-  params: Params,
+  params: ScryptParams,
   password: Uint8Array;
   salt: Uint8Array;
 }
 
-export function scryptEncode (passphrase?: HexString | Uint8Array | string, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs?: boolean): Result {
+export function scryptEncode (passphrase?: string | Uint8Array, salt = randomAsU8a(), params = DEFAULT_PARAMS, onlyJs?: boolean): Result {
   const u8a = u8aToU8a(passphrase);
 
   return {

packages/util-crypto/src/scrypt/fromU8a.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Params } from './types.js';
+import type { ScryptParams } from './types.js';
 
 import { u8aToBn } from '@polkadot/util';
 
@@ -9,7 +9,7 @@ import { BN_LE_OPTS } from '../bn.js';
 import { DEFAULT_PARAMS } from './defaults.js';
 
 interface Result {
-  params: Params,
+  params: ScryptParams,
   salt: Uint8Array;
 }
 
@@ -19,9 +19,10 @@ export function scryptFromU8a (data: Uint8Array): Result {
   const p = u8aToBn(data.subarray(32 + 4, 32 + 8), BN_LE_OPTS).toNumber();
   const r = u8aToBn(data.subarray(32 + 8, 32 + 12), BN_LE_OPTS).toNumber();
 
-  // FIXME At this moment we assume these to be fixed params, this is not a great idea since we lose flexibility
-  // and updates for greater security. However we need some protection against carefully-crafted params that can
-  // eat up CPU since these are user inputs. So we need to get very clever here, but atm we only allow the defaults
+  // FIXME At this moment we assume these to be fixed params, this is not a great idea
+  // since we lose flexibility and updates for greater security. However we need some
+  // protection against carefully-crafted params that can eat up CPU since these are user
+  // inputs. So we need to get very clever here, but atm we only allow the defaults
   // and if no match, bail out
   if (N !== DEFAULT_PARAMS.N || p !== DEFAULT_PARAMS.p || r !== DEFAULT_PARAMS.r) {
     throw new Error('Invalid injected scrypt params found');

packages/util-crypto/src/scrypt/toU8a.ts

@@ -1,13 +1,13 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Params } from './types.js';
+import type { ScryptParams } from './types.js';
 
 import { bnToU8a, u8aConcat } from '@polkadot/util';
 
 import { BN_LE_32_OPTS } from '../bn.js';
 
-export function scryptToU8a (salt: Uint8Array, { N, p, r }: Params): Uint8Array {
+export function scryptToU8a (salt: Uint8Array, { N, p, r }: ScryptParams): Uint8Array {
   return u8aConcat(
     salt,
     bnToU8a(N, BN_LE_32_OPTS),

packages/util-crypto/src/scrypt/types.ts

@@ -1,7 +1,8 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export interface Params {
+/** The params that control scrypt generation */
+export interface ScryptParams {
   N: number;
   p: number;
   r: number;

packages/util-crypto/src/secp256k1/recover.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { HashType } from './types.js';
 
 import { secp256k1 } from '@noble/curves/secp256k1';
@@ -16,7 +15,7 @@ import { secp256k1Expand } from './expand.js';
  * @name secp256k1Recover
  * @description Recovers a publicKey from the supplied signature
  */
-export function secp256k1Recover (msgHash: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, recovery: number, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
+export function secp256k1Recover (msgHash: string | Uint8Array, signature: string | Uint8Array, recovery: number, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
   const sig = u8aToU8a(signature).subarray(0, 64);
   const msg = u8aToU8a(msgHash);
   const publicKey = !hasBigInt || (!onlyJs && isReady())

packages/util-crypto/src/secp256k1/verify.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { HashType } from './types.js';
 
 import { u8aEq, u8aToU8a } from '@polkadot/util';
@@ -13,7 +12,7 @@ import { secp256k1Recover } from './recover.js';
  * @name secp256k1Verify
  * @description Verifies the signature of `message`, using the supplied pair
  */
-export function secp256k1Verify (msgHash: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, address: HexString | Uint8Array | string, hashType: HashType = 'blake2', onlyJs?: boolean): boolean {
+export function secp256k1Verify (msgHash: string | Uint8Array, signature: string | Uint8Array, address: string | Uint8Array, hashType: HashType = 'blake2', onlyJs?: boolean): boolean {
   const sig = u8aToU8a(signature);
 
   if (sig.length !== 65) {

packages/util-crypto/src/signature/verify.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { KeypairType, VerifyResult } from '../types.js';
 
 import { u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
@@ -87,7 +86,7 @@ function getVerifyFn (signature: Uint8Array): VerifyFn {
     : verifyDetect;
 }
 
-export function signatureVerify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, addressOrPublicKey: HexString | Uint8Array | string): VerifyResult {
+export function signatureVerify (message: string | Uint8Array, signature: string | Uint8Array, addressOrPublicKey: string | Uint8Array): VerifyResult {
   const signatureU8a = u8aToU8a(signature);
 
   if (![64, 65, 66].includes(signatureU8a.length)) {

packages/util-crypto/src/sr25519/agreement.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { u8aToU8a } from '@polkadot/util';
 import { sr25519Agree } from '@polkadot/wasm-crypto';
 
@@ -10,7 +8,7 @@ import { sr25519Agree } from '@polkadot/wasm-crypto';
  * @name sr25519Agreement
  * @description Key agreement between other's public key and self secret key
  */
-export function sr25519Agreement (secretKey: HexString | Uint8Array | string, publicKey: HexString | Uint8Array | string): Uint8Array {
+export function sr25519Agreement (secretKey: string | Uint8Array, publicKey: string | Uint8Array): Uint8Array {
   const secretKeyU8a = u8aToU8a(secretKey);
   const publicKeyU8a = u8aToU8a(publicKey);
 

packages/util-crypto/src/sr25519/derivePublic.ts

@@ -1,12 +1,10 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { isU8a, u8aToU8a } from '@polkadot/util';
 import { sr25519DerivePublicSoft } from '@polkadot/wasm-crypto';
 
-export function sr25519DerivePublic (publicKey: HexString | Uint8Array | string, chainCode: Uint8Array): Uint8Array {
+export function sr25519DerivePublic (publicKey: string | Uint8Array, chainCode: Uint8Array): Uint8Array {
   const publicKeyU8a = u8aToU8a(publicKey);
 
   if (!isU8a(chainCode) || chainCode.length !== 32) {

packages/util-crypto/src/sr25519/pair/fromSeed.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types.js';
 
 import { u8aToU8a } from '@polkadot/util';
@@ -13,7 +12,7 @@ import { sr25519PairFromU8a } from './fromU8a.js';
  * @name sr25519PairFromSeed
  * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
  */
-export function sr25519PairFromSeed (seed: HexString | Uint8Array | string): Keypair {
+export function sr25519PairFromSeed (seed: string | Uint8Array): Keypair {
   const seedU8a = u8aToU8a(seed);
 
   if (seedU8a.length !== 32) {

packages/util-crypto/src/sr25519/pair/fromU8a.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types.js';
 
 import { u8aToU8a } from '@polkadot/util';
@@ -10,7 +9,7 @@ const SEC_LEN = 64;
 const PUB_LEN = 32;
 const TOT_LEN = SEC_LEN + PUB_LEN;
 
-export function sr25519PairFromU8a (full: HexString | Uint8Array | string): Keypair {
+export function sr25519PairFromU8a (full: string | Uint8Array): Keypair {
   const fullU8a = u8aToU8a(full);
 
   if (fullU8a.length !== TOT_LEN) {

packages/util-crypto/src/sr25519/pair/testing.spec.ts

@@ -153,6 +153,7 @@ const tests: Test[] = [
   ]
 ];
 
+// eslint-disable-next-line jest/no-export
 export default tests;
 
 it('has a test', (): void => {

packages/util-crypto/src/sr25519/sign.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types.js';
 
 import { u8aToU8a } from '@polkadot/util';
@@ -11,7 +10,7 @@ import { sr25519Sign as wasmSign } from '@polkadot/wasm-crypto';
  * @name sr25519Sign
  * @description Returns message signature of `message`, using the supplied pair
  */
-export function sr25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
+export function sr25519Sign (message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
   if (publicKey?.length !== 32) {
     throw new Error('Expected a valid publicKey, 32-bytes');
   } else if (secretKey?.length !== 64) {

packages/util-crypto/src/sr25519/verify.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { u8aToU8a } from '@polkadot/util';
 import { sr25519Verify as wasmVerify } from '@polkadot/wasm-crypto';
 
@@ -10,7 +8,7 @@ import { sr25519Verify as wasmVerify } from '@polkadot/wasm-crypto';
  * @name sr25519Verify
  * @description Verifies the signature of `message`, using the supplied pair
  */
-export function sr25519Verify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, publicKey: HexString | Uint8Array | string): boolean {
+export function sr25519Verify (message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array): boolean {
   const publicKeyU8a = u8aToU8a(publicKey);
   const signatureU8a = u8aToU8a(signature);
 

packages/util-crypto/src/sr25519/vrfSign.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types.js';
 
 import { u8aToU8a } from '@polkadot/util';
@@ -13,7 +12,7 @@ const EMPTY_U8A = new Uint8Array();
  * @name sr25519VrfSign
  * @description Sign with sr25519 vrf signing (deterministic)
  */
-export function sr25519VrfSign (message: HexString | Uint8Array | string, { secretKey }: Partial<Keypair>, context: HexString | string | Uint8Array = EMPTY_U8A, extra: HexString | string | Uint8Array = EMPTY_U8A): Uint8Array {
+export function sr25519VrfSign (message: string | Uint8Array, { secretKey }: Partial<Keypair>, context: string | Uint8Array = EMPTY_U8A, extra: string | Uint8Array = EMPTY_U8A): Uint8Array {
   if (secretKey?.length !== 64) {
     throw new Error('Invalid secretKey, expected 64-bytes');
   }

packages/util-crypto/src/sr25519/vrfVerify.ts

@@ -1,8 +1,6 @@
 // Copyright 2017-2023 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { HexString } from '@polkadot/util/types';
-
 import { u8aToU8a } from '@polkadot/util';
 import { vrfVerify } from '@polkadot/wasm-crypto';
 
@@ -12,7 +10,7 @@ const EMPTY_U8A = new Uint8Array();
  * @name sr25519VrfVerify
  * @description Verify with sr25519 vrf verification
  */
-export function sr25519VrfVerify (message: HexString | Uint8Array | string, signOutput: HexString | string | Uint8Array, publicKey: HexString | Uint8Array | string, context: HexString | string | Uint8Array = EMPTY_U8A, extra: HexString | string | Uint8Array = EMPTY_U8A): boolean {
+export function sr25519VrfVerify (message: string | Uint8Array, signOutput: string | Uint8Array, publicKey: string | Uint8Array, context: string | Uint8Array = EMPTY_U8A, extra: string | Uint8Array = EMPTY_U8A): boolean {
   const publicKeyU8a = u8aToU8a(publicKey);
   const proofU8a = u8aToU8a(signOutput);
 

packages/util-crypto/src/types.ts

@@ -5,20 +5,29 @@ export * from './address/types.js';
 export * from './json/types.js';
 
 export interface Keypair {
+  /** The publicKey for this pair */
   publicKey: Uint8Array;
+  /** The secretKey for this pair */
   secretKey: Uint8Array;
 }
 
 export interface Seedpair {
+  /** The publicKey for this pair */
   publicKey: Uint8Array;
+  /** The seed used to construct the pair */
   seed: Uint8Array;
 }
 
+/** The supported types of pairs */
 export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa' | 'ethereum';
 
 export interface VerifyResult {
+  /** The detected crypto interface, or 'none' if not detected */
   crypto: 'none' | KeypairType;
+  /** The validity for this result, false if invalid */
   isValid: boolean;
+  /** Flag to indicate if the passed data was wrapped in <Bytes>...</Bytes> */
   isWrapped: boolean;
+  /** The extracted publicKey */
   publicKey: Uint8Array;
 }