[CI Skip] release/stable 10.1.14

skip-checks: true

.123trigger

@@ -1,30 +0,0 @@
-8
-2.6.2
-2.12.2
-5.2.2
-5.2.3
-5.4.2
-5.4.3
-5.4.4
-5.5.2
-5.6.2
-5.6.3
-5.9.2
-6.0.2
-6.0.3
-6.0.4
-6.0.5
-
-7.0.2
-7.0.3
-7.1.2
-7.8.2
-7.9.2
-8.0.2
-8.0.3
-8.0.4
-8.0.5
-8.1.2
-8.2.2
-8.3.2
-8.3.3

.github/issue_template.md

@@ -1,50 +1,86 @@
 <!--
 
-For general support, howto, coding and bundling questions, please use the Substrate & Polkadot StackExchange at https://substrate.stackexchange.com/ and get other ecosystem developers involved. This issues in this repository are meant for the tracking of feature requests and bug reports.
+For general support, howto, coding and bundling questions, please
+use the Substrate & Polkadot StackExchange at
 
-While all issues are looked at non-bug and non-features would take quite a bit longer to get to and may yield less than satisfactory responses in this format.
+  https://substrate.stackexchange.com/
 
-Additionally, please ensure you have done a search on the existing and closed issues before logging a new request. This saves time on all sides.
+and get other ecosystem developers involved. This issues in this
+repository are meant for the tracking of feature requests and bug
+reports.
+
+While all issues are looked at non-bug and non-features would take
+quite a bit longer to get to and may yield less than satisfactory
+responses in this format.
+
+Additionally, please ensure you have done a search on the existing
+and closed issues before logging a new request. This saves time on
+all sides.
 
 -->
 
 
 * **I'm submitting a ...**
 
-<!--- Try and classify your actual report -->
+<!---
+
+REQUIRED:
+
+Classify the type of report your are submitting
+
+-->
 
   - [ ] Bug report
   - [ ] Feature request
-  - [ ] Support request (please bear the comments above in mind)
+  - [ ] Support request
   - [ ] Other
 
 
 * **What is the current behavior and expected behavior?**
 
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
+<!---
+
+REQUIRED:
+
+If you're describing a bug, tell us what should happen. If you're
+suggesting a change/improvement, tell us how it should work.
+
+-->
 
 
 * **What is the motivation for changing the behavior?**
 
-<!--- Not obligatory, but suggest a motivation for the request -->
-<!--- or ideas how to implement the addition or change -->
+<!---
+
+OPTIONAL:
+
+Suggest a motivation for the request or ideas how to implement the
+addition or change
+
+-->
 
 
 * **Please tell us about your environment:**
 
-<!--- Include as many relevant details about the environment you experienced the issue in -->
-<!--- Also snsure that you have tested against the latest stable releases if a bug -->
+<!---
+
+REQUIRED:
+
+Include as many relevant details about the environment in which you
+experienced the issue. Also ensure that you have tested against the
+latest stable releases if you believe this to be a bug
+
+-->
 
   - Version:
   - Environment:
 
     - [ ] Node.js
     - [ ] Browser
-    - [ ] Other (limited support for other environments available)
+    - [ ] Other (limited support for other environments)
 
   - Language:
 
     - [ ] JavaScript
-    - [ ] TypeScript
+    - [ ] TypeScript (include tsc --version)
     - [ ] Other

.github/workflows/auto-approve.yml

@@ -9,7 +9,7 @@ jobs:
     if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && (!github.event.pull_request || github.event.pull_request.head.repo.full_name == github.repository)"
     runs-on: ubuntu-latest
     steps:
-      - uses: jacogr/action-approve@master
+      - uses: jacogr/action-approve@9d6ce78d26f23ad29d009d034822cf773f2cb50e
         with:
           authors: jacogr
           labels: -auto

.github/workflows/auto-merge.yml

@@ -8,7 +8,7 @@ jobs:
   merge:
     runs-on: ubuntu-latest
     steps:
-      - uses: jacogr/action-merge@master
+      - uses: jacogr/action-merge@3b4b49af8a8644bf5cbb5409ee236abe04eeb1b0
         with:
           checks: build,lint,test
           labels: -auto

.github/workflows/lock.yml

@@ -10,7 +10,7 @@ jobs:
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-      - uses: dessant/lock-threads@v2
+      - uses: dessant/lock-threads@f1a42f0f44eb83361d617a014663e1a76cf282d2
         with:
           github-token: ${{ secrets.GH_PAT_BOT }}
           issue-lock-inactive-days: '7'

.github/workflows/pr-any.yml

@@ -5,15 +5,19 @@ jobs:
   pr:
     strategy:
       matrix:
-        step: ['lint', 'test', 'build']
+        step: ['lint', 'test', 'build', 'deno']
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
     env:
       YARN_ENABLE_SCRIPTS: false
       CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@7884fcad6b5d53d10323aee724dc68d8b9096a2e
+    - uses: denoland/setup-deno@004814556e37c54a2f6e31384c9e18e983317366
+      with:
+        deno-version: vx.x.x
     - name: ${{ matrix.step }}
+      if: always()
       run: |
         yarn install --immutable | grep -v 'YN0013'
         yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -19,7 +19,7 @@ jobs:
       GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
       NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@7884fcad6b5d53d10323aee724dc68d8b9096a2e
       with:
         fetch-depth: 0
         token: ${{ secrets.GH_PAT }}

.github/workflows/semgrep.yml

@@ -12,8 +12,8 @@ jobs:
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-      - uses: actions/checkout@v2
-      - uses: returntocorp/semgrep-action@v1
+      - uses: actions/checkout@7884fcad6b5d53d10323aee724dc68d8b9096a2e
+      - uses: returntocorp/semgrep-action@aeafd770072c4f48798b991e3449592bddc2c435
         with:
           auditOn: push
           publishToken: ${{ secrets.SEMGREP_APP_TOKEN }}

.github/workflows/stale.yml

@@ -9,7 +9,7 @@ jobs:
     env:
       YARN_ENABLE_SCRIPTS: false
     steps:
-      - uses: actions/stale@v3
+      - uses: actions/stale@98ed4cb500039dbcccf4bd9bedada4d0187f2757
         with:
           repo-token: ${{ secrets.GH_PAT_BOT }}
           stale-issue-message: 'This issue has been open for 21 days with no activity and is not labelled as an enhancement. It will be closed in 7 days.'

.gitignore

@@ -1,13 +1,12 @@
 --test-*
 _book/
 build/
-build-cjs/
-build-esm/
-build-docs/
+build-*/
 coverage/
-docs/.vuepress/dist/
 node_modules/
 tmp/
+/import_map.json
+/mod.ts
 .DS_Store
 .env.local
 .env.development.local
@@ -26,6 +25,4 @@ npm-debug.log*
 package-lock.json
 yarn-debug.log*
 yarn-error.log*
-store.db
-store.db.compacted
 tsconfig.*buildinfo

CHANGELOG.md

@@ -1,5 +1,193 @@
 # CHANGELOG
 
+## 10.1.14 Nov 27, 2022
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.13 Nov 20, 2022
+
+Contributed:
+
+- Ledger support for Origintrail (Thanks to https://github.com/carlosala)
+
+Changes:
+
+- Expand type descriptions around Ledger-based structures
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.12 Nov 13, 2022
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.11 Oct 15, 2022
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.10 Oct 7, 2022
+
+Changes:
+
+- Ensure `{bn, n, number}ToHex(0)` always respects `bitLength`
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.9 Sep 24, 2022
+
+Contributed:
+
+- Ledger support for VTB (Thanks to https://github.com/GuilaneDen)
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.8 Sep 17, 2022
+
+Contributed:
+
+- Ledger support for Darwinia, Phala & Khala (Thanks to https://github.com/carlosala)
+- Ledger support for HydraX (Thanks to https://github.com/chcmedeiros)
+
+Changes:
+
+- Expand test cases
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.7 Sep 2, 2022
+
+Changes:
+
+- Hoist Ledger interface wrapError (internal adjustment)
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.6 Aug 23, 2022
+
+Changes:
+
+- Adjust `nextTick` with greater care for browser loops
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.5 Aug 21, 2022
+
+Changes:
+
+- Adjust `ledgerApps` to use new `@zondax/ledger-substrate` interfaces
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.4 Aug 12, 2022
+
+Contributed:
+
+- Ledger support for Kusama Bifrost (Thanks to https://github.com/awesomepan)
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.3 Aug 5, 2022
+
+Changes:
+
+- Optimization for empty `arrayFlatten` case
+- Coding cleanups for logger (no `as` casting)
+- Optiomizations in assertion checks
+
+
+## 10.1.2 Jul 29, 2022
+
+Changes:
+
+- Upgrade dependencies to latest stable versions
+
+
+## 10.1.1 Jul 21, 2022
+
+Changes:
+
+- Add `arrayUnzip` as reverse of `arrayZip`
+- Adjust `objectSpread` to natively handle `Map` entries spreads
+- Adjust `isAscii` check to disallow `\t`, `\n`, & `\r` characters
+- Adjust `nobody` zero-key pair with pre-computed address
+- Align `objectProperty` & `lazyMethod` call signatures (backwards compatible)
+- Various internal speed optimizations
+- Upgrade dependencies to latest stable versions
+
+
+## 10.0.2 Jul 10, 2022
+
+Changes:
+
+- Adjust async import in `x-fetch` to be Jest-friendly
+
+
+## 10.0.1 Jul 8, 2022
+
+- **Breaking change** In this major version version previously deprecated function signatures have been removed. If still using the old forms for either `bnToHex`, `bnToU8a`, `formatBalance`, `hexToBn` or `u8aToBn`, please update and only pass through an options object as the second parameter.
+
+Contributed:
+
+- Ledger support for Stafi (Thanks to https://github.com/kaelnew)
+- Ledger support for Aleph Zero (Thanks to https://github.com/carlosala)
+- Add genesis for HydraDX parachain (Thanks to https://github.com/jak-pan)
+
+Changes:
+
+- Remove deprecated signatures for `bnToHex`, `bnToU8a`, `formatBalance`, `hexToBn`, `u8aToBn`
+- Align option handling of `n*` (BigInt) functions with `bn*` (BN)
+- Allow for usage without `@types/node` installed
+- Adjust for available ESM-only dependencies
+- Upgrade dependencies to latest stable versions
+- Upgrade to `@polkadot/wasm-crypto` 6.2.3
+
+
+## 9.7.2 Jul 4, 2022
+
+Changes:
+
+- Upgrade to `@polkadot/wasm-crypto` 6.2.2
+
+
+## 9.7.1 Jul 1, 2022
+
+Changes:
+
+- Update signatures where `readonly` arrays are used
+- Upgrade dependencies to latest stable versions
+- Upgrade to `@polkadot/wasm-crypto` 6.2.1
+
+
+## 9.6.2 Jun 25, 2022
+
+Changes:
+
+- Fix `hexToU8a` where `0x` is not correctly converted
+
+
+## 9.6.1 Jun 23, 2022
+
+Changes:
+
+- Add `floatToU8a` and `u8aToFloat` (both 32 & 64-bit, le & be)
+- Adjust `isUndefined` check (local variable available)
+- Adjust use of `assert`, `isUndefined` & `isNull`
+
+
 ## 9.5.1 Jun 18, 2022
 
 Contributed:

CONTRIBUTORS

@@ -1,12 +1,12 @@
-    1363	Jaco                          	9.5.1 (#1545)
+    1488	Jaco                          	10.1.14 (#1681)
        9	Antoine Estienne              	Add eth uri keyring test (#1291)
+       9	Carlo Sala                    	feat(networks): support ledger for origintrail (#1674)
        6	Amaury Martiny                	Add tests from Rust (#283)
+       5	Jakub Pánik                   	Add HydraDX parachain to genesis (#1583)
        5	kwingram25                    	Add BN consts and timeToString (#610)
        4	Adam Dossa                    	Update Polymesh Genesis Hash (#1193)
-       4	Carlo Sala                    	add Composable support for ledger (#1515)
-       4	Jakub Pánik                   	Add basilisk 🐍 (#1396)
+       4	pan                           	add bifrost kusama (#1626)
        3	Luke Schoen                   	docs: Fix example in readme since we use default imports (#243)
-       3	pan                           	update bifrost genesis hash (#1521)
        2	AndreasGassmann               	feat(dependencies): remove moment.js (#530)
        2	Gav Wood                      	Fix stake:unstake (#182)
        2	Hyungsuk Kang                 	Add cross client Encryption/Decryption (#496)
@@ -21,7 +21,9 @@
        1	amphineko                     	chore: fix typo in versionDetect messages (#941)
        1	Axel Chalon                   	Simplify @polkadot/keyring KeyringPair (#419)
        1	Brad Larson                   	[FIX] Adjust error message (#646)
+       1	Carlos Medeiros               	add hydradx to knownLedger (#1647)
        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)
        1	Harry Liu                     	Update README.md (#446)
        1	Hoon Kim                      	replace plasm genesis with astar (#1397)
@@ -30,6 +32,7 @@
        1	Jake Naviasky                 	Add evmToAddress and addressToEvm crypto utils. (#705)
        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	Lezek123                      	logger - wildcard include/exclude with DEBUG env (#932)
        1	Mario Neises                  	remove redudant export (#257)
        1	Miguel Hervas                 	Add CFG Ledger Support (#1057)

import_map.in.json

@@ -0,0 +1,5 @@
+{
+  "imports": {
+    "https://esm.sh/v90/@types/bn.js@~5.2/index.d.ts": "https://esm.sh/v90/@types/bn.js@5.1.0/index.d.ts"
+  }
+}

package.json

@@ -10,28 +10,34 @@
     "url": "https://github.com/polkadot-js/common.git"
   },
   "sideEffects": false,
-  "version": "9.5.1",
+  "type": "module",
+  "version": "10.1.14",
+  "versions": {
+    "git": "10.1.14",
+    "npm": "10.1.14"
+  },
   "workspaces": [
     "packages/*"
   ],
   "scripts": {
     "build": "polkadot-dev-build-ts",
+    "build:networks": "yarn test:one packages/networks/src",
     "build:release": "polkadot-ci-ghact-build",
     "build:rollup": "polkadot-exec-rollup --config",
     "clean": "polkadot-dev-clean-build",
+    "deno": "yarn polkadot-dev-deno-map && yarn build && deno check --import-map=import_map.json mod.ts",
     "lint": "polkadot-dev-run-lint",
-    "networks:crosscheck": "polkadot-dev-run-test packages/networks/src/crosscheck",
     "postinstall": "polkadot-dev-yarn-only",
-    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck --testPathIgnorePatterns toMiniSecretCmp",
+    "test": "NODE_OPTIONS=--experimental-vm-modules polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck --testPathIgnorePatterns toMiniSecretCmp",
     "test:mnemonicCmp": "polkadot-dev-run-test packages/util-crypto/src/mnemonic/toMiniSecretCmp.spec.ts",
     "test:one": "polkadot-dev-run-test --runInBand"
   },
   "devDependencies": {
-    "@babel/core": "^7.18.5",
-    "@polkadot/dev": "^0.67.4",
-    "@types/jest": "^28.1.2"
+    "@babel/core": "^7.20.2",
+    "@polkadot/dev": "^0.67.163",
+    "@types/jest": "^29.2.3"
   },
   "resolutions": {
-    "typescript": "^4.7.3"
+    "typescript": "^4.9.3"
   }
 }

packages/hw-ledger-transports/package.json

@@ -16,18 +16,18 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "browser": "browser.js",
   "main": "node.js",
   "react-native": "react-native.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@ledgerhq/hw-transport": "^6.27.1",
-    "@ledgerhq/hw-transport-webhid": "^6.27.1",
-    "@ledgerhq/hw-transport-webusb": "^6.27.1",
-    "@polkadot/util": "9.5.1"
+    "@babel/runtime": "^7.20.1",
+    "@ledgerhq/hw-transport": "^6.27.7",
+    "@ledgerhq/hw-transport-webhid": "^6.27.7",
+    "@ledgerhq/hw-transport-webusb": "^6.27.7",
+    "@polkadot/util": "10.1.14"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.27.1"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.28.4"
   }
 }

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

@@ -0,0 +1,8 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TransportDef } from './types';
+
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [];

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

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './empty';

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: '9.5.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', path: 'auto', type: 'auto', version: '10.1.14' };

packages/hw-ledger-transports/src/react-native.ts

@@ -1,8 +1,4 @@
 // Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TransportDef } from './types';
-
-export { packageInfo } from './packageInfo';
-
-export const transports: TransportDef[] = [];
+export * from './empty';

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

@@ -6,6 +6,8 @@ import Transport from '@ledgerhq/hw-transport';
 export type LedgerTypes = 'hid' | 'u2f' | 'webusb';
 
 export interface TransportDef {
+  /** Create a transport to be used in Ledger operations */
   create (): Promise<Transport>;
+  /** The type of the underlying transport definition */
   type: LedgerTypes;
 }

packages/hw-ledger/package.json

@@ -19,13 +19,13 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@ledgerhq/hw-transport": "^6.27.1",
-    "@polkadot/hw-ledger-transports": "9.5.1",
-    "@polkadot/util": "9.5.1",
-    "@zondax/ledger-substrate": "^0.31.0"
+    "@babel/runtime": "^7.20.1",
+    "@ledgerhq/hw-transport": "^6.27.7",
+    "@polkadot/hw-ledger-transports": "10.1.14",
+    "@polkadot/util": "10.1.14",
+    "@zondax/ledger-substrate": "^0.40.1"
   }
 }

packages/hw-ledger/src/bundle.ts

@@ -1,11 +1,13 @@
 // Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { ResponseBase, SubstrateApp } from '@zondax/ledger-substrate';
+import type { SubstrateApp } from '@zondax/ledger-substrate';
 import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';
 
+import { newSubstrateApp } from '@zondax/ledger-substrate';
+
 import { transports } from '@polkadot/hw-ledger-transports';
-import { assert, u8aToBuffer } from '@polkadot/util';
+import { hexAddPrefix, u8aToBuffer } from '@polkadot/util';
 
 import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
 import { ledgerApps } from './defaults';
@@ -14,6 +16,19 @@ export { packageInfo } from './packageInfo';
 
 type Chain = keyof typeof ledgerApps;
 
+type WrappedResult = Awaited<ReturnType<SubstrateApp['getAddress' | 'getVersion' | 'sign']>>;
+
+/** @internal Wraps a SubstrateApp call, checking the result for any errors which result in a rejection */
+async function wrapError <T extends WrappedResult> (promise: Promise<T>): Promise<T> {
+  const result = await promise;
+
+  if (result.return_code !== LEDGER_SUCCESS_CODE) {
+    throw new Error(result.error_message);
+  }
+
+  return result;
+}
+
 // A very basic wrapper for a ledger app -
 //  - it connects automatically, creating an app as required
 //  - Promises return errors (instead of wrapper errors)
@@ -26,8 +41,11 @@ export class Ledger {
 
   constructor (transport: LedgerTypes, chain: Chain) {
     // u2f is deprecated
-    assert(['hid', 'webusb'].includes(transport), () => `Unsupported transport ${transport}`);
-    assert(Object.keys(ledgerApps).includes(chain), () => `Unsupported chain ${chain}`);
+    if (!['hid', 'webusb'].includes(transport)) {
+      throw new Error(`Unsupported transport ${transport}`);
+    } else if (!Object.keys(ledgerApps).includes(chain)) {
+      throw new Error(`Unsupported chain ${chain}`);
+    }
 
     this.#chain = chain;
     this.#transport = transport;
@@ -35,18 +53,18 @@ export class Ledger {
 
   public async getAddress (confirm = false, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE }: Partial<AccountOptions> = {}): Promise<LedgerAddress> {
     return this.#withApp(async (app: SubstrateApp): Promise<LedgerAddress> => {
-      const { address, pubKey } = await this.#wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));
+      const { address, pubKey } = await wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));
 
       return {
         address,
-        publicKey: `0x${pubKey}`
+        publicKey: hexAddPrefix(pubKey)
       };
     });
   }
 
   public async getVersion (): Promise<LedgerVersion> {
     return this.#withApp(async (app: SubstrateApp): Promise<LedgerVersion> => {
-      const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await this.#wrapError(app.getVersion());
+      const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await wrapError(app.getVersion());
 
       return {
         isLocked,
@@ -59,10 +77,10 @@ export class Ledger {
   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 this.#wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));
+      const { signature } = await wrapError(app.sign(account + accountOffset, change, addressIndex + addressOffset, buffer));
 
       return {
-        signature: `0x${signature.toString('hex')}`
+        signature: hexAddPrefix(signature.toString('hex'))
       };
     });
   }
@@ -71,11 +89,13 @@ export class Ledger {
     if (!this.#app) {
       const def = transports.find(({ type }) => type === this.#transport);
 
-      assert(def, () => `Unable to find a transport for ${this.#transport}`);
+      if (!def) {
+        throw new Error(`Unable to find a transport for ${this.#transport}`);
+      }
 
       const transport = await def.create();
 
-      this.#app = ledgerApps[this.#chain](transport);
+      this.#app = newSubstrateApp(transport, ledgerApps[this.#chain]);
     }
 
     return this.#app;
@@ -92,12 +112,4 @@ export class Ledger {
       throw error;
     }
   };
-
-  #wrapError = async <T extends ResponseBase> (promise: Promise<T>): Promise<T> => {
-    const result = await promise;
-
-    assert(result.return_code === LEDGER_SUCCESS_CODE, () => result.error_message);
-
-    return result;
-  };
 }

packages/hw-ledger/src/defaults.spec.ts

@@ -0,0 +1,16 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { supportedApps } from '@zondax/ledger-substrate';
+
+import { ledgerApps } from './defaults';
+
+describe('ledgerApps', (): void => {
+  it.each(Object.keys(ledgerApps))('%s is known', (k): void => {
+    expect(
+      supportedApps.find(({ name }) =>
+        name === ledgerApps[k]
+      )
+    ).toBeDefined();
+  });
+});

packages/hw-ledger/src/defaults.ts

@@ -1,31 +1,38 @@
 // Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type Transport from '@ledgerhq/hw-transport';
-import type { SubstrateApp } from '@zondax/ledger-substrate';
-
-import { newAcalaApp, newAstarApp, newBifrostApp, newCentrifugeApp, newComposableApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKaruraApp, newKusamaApp, newNodleApp, newParallelApp, newPolkadexApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStatemineApp, newStatemintApp, newXXNetworkApp } from '@zondax/ledger-substrate';
-
 // These match up with the keys of the knownLedger object in the @polkadot/networks/defaults/ledger.ts
-export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
-  acala: newAcalaApp,
-  astar: newAstarApp,
-  bifrost: newBifrostApp,
-  centrifuge: newCentrifugeApp,
-  composable: newComposableApp,
-  'dock-mainnet': newDockApp,
-  edgeware: newEdgewareApp,
-  equilibrium: newEquilibriumApp,
-  genshiro: newGenshiroApp,
-  karura: newKaruraApp,
-  kusama: newKusamaApp,
-  'nodle-para': newNodleApp,
-  parallel: newParallelApp,
-  polkadex: newPolkadexApp,
-  polkadot: newPolkadotApp,
-  polymesh: newPolymeshApp,
-  sora: newSoraApp,
-  statemine: newStatemineApp,
-  statemint: newStatemintApp,
-  xxnetwork: newXXNetworkApp
+// and maps to the known name in the @zondax/ledger-substrate/supported_apps package
+export const ledgerApps: Record<string, string> = {
+  acala: 'Acala',
+  'aleph-node': 'AlephZero',
+  astar: 'Astar',
+  bifrost: 'Bifrost',
+  'bifrost-kusama': 'BifrostKusama',
+  centrifuge: 'Centrifuge',
+  composable: 'Composable',
+  darwinia: 'Darwinia',
+  'dock-mainnet': 'Dock',
+  edgeware: 'Edgeware',
+  equilibrium: 'Equilibrium',
+  genshiro: 'Genshiro',
+  hydradx: 'HydraDX',
+  'interlay-parachain': 'Interlay',
+  karura: 'Karura',
+  khala: 'Khala',
+  kusama: 'Kusama',
+  'nodle-para': 'Nodle',
+  origintrail: 'OriginTrail',
+  parallel: 'Parallel',
+  phala: 'Phala',
+  polkadex: 'Polkadex',
+  polkadot: 'Polkadot',
+  polymesh: 'Polymesh',
+  sora: 'Sora',
+  stafi: 'Stafi',
+  statemine: 'Statemine',
+  statemint: 'Statemint',
+  unique: 'Unique',
+  vtb: 'VTB',
+  xxnetwork: 'XXNetwork'
 };

packages/hw-ledger/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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: '9.5.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '10.1.14' };

packages/hw-ledger/src/types.ts

@@ -6,25 +6,31 @@ import type { HexString } from '@polkadot/util/types';
 export type LedgerTypes = 'hid' | 'u2f' | 'webusb';
 
 export interface AccountOptions {
+  /** The index of the account */
   account: number;
+  /** The index of the address */
   addressIndex: number;
+  /** The change to apply */
   change: number;
 }
 
 export interface LedgerAddress {
+  /** The ss58 encoded address */
   address: string;
+  /** The hex-encoded publicKey */
   publicKey: HexString;
 }
 
 export interface LedgerSignature {
+  /** A hex-encoded signature, as generated by the device */
   signature: HexString;
 }
 
 export interface LedgerVersion {
+  /** Indicator flag for locked status */
   isLocked: boolean;
+  /** Indicator flag for testmode status */
   isTestMode: boolean;
-  /**
-   * @description Tuple with major, minor, patch
-   */
-  version: [number, number, number];
+  /** The software version for this device */
+  version: [major: number, minor: number, patch: number];
 }

packages/keyring/package.json

@@ -20,15 +20,15 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "9.5.1",
-    "@polkadot/util-crypto": "9.5.1"
+    "@babel/runtime": "^7.20.1",
+    "@polkadot/util": "10.1.14",
+    "@polkadot/util-crypto": "10.1.14"
   },
   "peerDependencies": {
-    "@polkadot/util": "9.5.1",
-    "@polkadot/util-crypto": "9.5.1"
+    "@polkadot/util": "10.1.14",
+    "@polkadot/util-crypto": "10.1.14"
   }
 }

packages/keyring/src/keyring.ts

@@ -4,7 +4,7 @@
 import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types';
 
-import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
+import { hexToU8a, isHex, stringToU8a } from '@polkadot/util';
 import { base64Decode, decodeAddress, ed25519PairFromSeed as ed25519FromSeed, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed, sr25519PairFromSeed as sr25519FromSeed } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
@@ -50,7 +50,9 @@ export class Keyring implements KeyringInstance {
   constructor (options: KeyringOptions = {}) {
     options.type = options.type || 'ed25519';
 
-    assert(['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), () => `Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
+    if (!['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined')) {
+      throw new Error(`Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
+    }
 
     this.#pairs = new Pairs();
     this.#ss58 = options.ss58Format;
@@ -162,7 +164,9 @@ export class Keyring implements KeyringInstance {
    * @description Creates a pair from a JSON keyfile
    */
   public createFromJson ({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    assert(version !== '3' || content[0] === 'pkcs8', () => `Unable to decode non-pkcs8 type, [${content.join(',')}] found}`);
+    if (version === '3' && content[0] !== 'pkcs8') {
+      throw new Error(`Unable to decode non-pkcs8 type, [${content.join(',')}] found}`);
+    }
 
     const cryptoType = version === '0' || !Array.isArray(content)
       ? this.type
@@ -171,7 +175,9 @@ export class Keyring implements KeyringInstance {
       ? [type]
       : type;
 
-    assert(['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType), () => `Unknown crypto type ${cryptoType}`);
+    if (!['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType)) {
+      throw new Error(`Unknown crypto type ${cryptoType}`);
+    }
 
     // Here the address and publicKey are 32 bytes and isomorphic. This is why the address field needs to be the public key for ethereum type pairs
     const publicKey = isHex(address)
@@ -216,7 +222,9 @@ export class Keyring implements KeyringInstance {
           ? mnemonicToLegacySeed(phrase, '', false, 64)
           : mnemonicToMiniSecret(phrase, password);
       } else {
-        assert(phrase.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
+        if (phrase.length > 32) {
+          throw new Error('specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
+        }
 
         seed = stringToU8a(phrase.padEnd(32));
       }
@@ -238,7 +246,7 @@ export class Keyring implements KeyringInstance {
   public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
     return this.type === 'ethereum'
       ? ethereumEncode(address)
-      : encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
+      : encodeAddress(address, ss58Format === undefined ? this.#ss58 : ss58Format);
   };
 
   /**

packages/keyring/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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: '9.5.1' };
+export const packageInfo = { name: '@polkadot/keyring', path: 'auto', type: 'auto', version: '10.1.14' };

packages/keyring/src/pair/decode.ts

@@ -4,7 +4,7 @@
 import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/types';
 import type { PairInfo } from './types';
 
-import { assert, isUndefined, u8aEq } from '@polkadot/util';
+import { u8aEq } from '@polkadot/util';
 import { jsonDecryptData } from '@polkadot/util-crypto';
 
 import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
@@ -16,13 +16,15 @@ type DecodeResult = PairInfo & {
 };
 
 export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, _encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[]): DecodeResult {
-  const encType = Array.isArray(_encType) || isUndefined(_encType)
+  const encType = Array.isArray(_encType) || _encType === undefined
     ? _encType
     : [_encType];
   const decrypted = jsonDecryptData(encrypted, passphrase, encType);
   const header = decrypted.subarray(0, PKCS8_HEADER.length);
 
-  assert(u8aEq(header, PKCS8_HEADER), 'Invalid Pkcs8 header found in body');
+  if (!u8aEq(header, PKCS8_HEADER)) {
+    throw new Error('Invalid Pkcs8 header found in body');
+  }
 
   let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
   let divOffset = SEED_OFFSET + SEC_LENGTH;
@@ -34,7 +36,9 @@ export function decodePair (passphrase?: string, encrypted?: Uint8Array | null,
     secretKey = decrypted.subarray(SEED_OFFSET, divOffset);
     divider = decrypted.subarray(divOffset, divOffset + PKCS8_DIVIDER.length);
 
-    assert(u8aEq(divider, PKCS8_DIVIDER), 'Invalid Pkcs8 divider found in body');
+    if (!u8aEq(divider, PKCS8_DIVIDER)) {
+      throw new Error('Invalid Pkcs8 divider found in body');
+    }
   }
 
   const pubOffset = divOffset + PKCS8_DIVIDER.length;

packages/keyring/src/pair/encode.ts

@@ -3,13 +3,15 @@
 
 import type { PairInfo } from './types';
 
-import { assert, u8aConcat } from '@polkadot/util';
+import { u8aConcat } from '@polkadot/util';
 import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';
 
 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';
 
 export function encodePair ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
-  assert(secretKey, 'Expected a valid secretKey to be passed to encode');
+  if (!secretKey) {
+    throw new Error('Expected a valid secretKey to be passed to encode');
+  }
 
   const encoded = u8aConcat(
     PKCS8_HEADER,

packages/keyring/src/pair/index.spec.ts

@@ -217,11 +217,11 @@ describe('pair', (): void => {
   });
 
   it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRSSR25519[0].publicKey, secretKey: PAIRSSR25519[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: hexToU8a(PAIRSSR25519[0].p), secretKey: hexToU8a(PAIRSSR25519[0].s) }, {});
     const stash = alice.derive('//stash');
     const soft = alice.derive('//funding/0');
 
-    expect(stash.publicKey).toEqual(PAIRSSR25519[1].publicKey);
+    expect(stash.publicKey).toEqual(hexToU8a(PAIRSSR25519[1].p));
     expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
   });
 

packages/keyring/src/pair/index.ts

@@ -6,7 +6,7 @@ import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import type { PairInfo } from './types';
 
-import { assert, objectSpread, u8aConcat, u8aEmpty, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { objectSpread, u8aConcat, u8aEmpty, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { blake2AsU8a, convertPublicKeyToCurve25519, convertSecretKeyToCurve25519, ed25519PairFromSeed as ed25519FromSeed, ed25519Sign, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclOpen, naclSeal, secp256k1Compress, secp256k1Expand, secp256k1PairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify, sr25519PairFromSeed as sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify } from '@polkadot/util-crypto';
 
 import { decodePair } from './decode';
@@ -145,8 +145,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     // eslint-disable-next-line sort-keys
     decodePkcs8,
     decryptMessage: (encryptedMessageWithNonce: HexString | string | Uint8Array, senderPublicKey: HexString | string | Uint8Array): Uint8Array | null => {
-      assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
-      assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot encrypt with a locked key pair');
+      } else if (['ecdsa', 'ethereum'].includes(type)) {
+        throw new Error('Secp256k1 not supported yet');
+      }
 
       const messageU8a = u8aToU8a(encryptedMessageWithNonce);
 
@@ -158,8 +161,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       );
     },
     derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
-      assert(type !== 'ethereum', 'Unable to derive on this keypair');
-      assert(!isLocked(secretKey), 'Cannot derive on a locked keypair');
+      if (type === 'ethereum') {
+        throw new Error('Unable to derive on this keypair');
+      } else if (isLocked(secretKey)) {
+        throw new Error('Cannot derive on a locked keypair');
+      }
 
       const { path } = keyExtractPath(suri);
       const derived = keyFromPath({ publicKey, secretKey }, path, type);
@@ -170,8 +176,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       return recode(passphrase);
     },
     encryptMessage: (message: HexString | string | Uint8Array, recipientPublicKey: HexString | string | Uint8Array, nonceIn?: Uint8Array): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
-      assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot encrypt with a locked key pair');
+      } else if (['ecdsa', 'ethereum'].includes(type)) {
+        throw new Error('Secp256k1 not supported yet');
+      }
 
       const { nonce, sealed } = naclSeal(u8aToU8a(message), convertSecretKeyToCurve25519(secretKey), convertPublicKeyToCurve25519(u8aToU8a(recipientPublicKey)), nonceIn);
 
@@ -184,7 +193,9 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       meta = objectSpread({}, meta, additional);
     },
     sign: (message: HexString | string | Uint8Array, options: SignOptions = {}): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot sign with a locked key pair');
+      }
 
       return u8aConcat(
         options.withType
@@ -212,7 +223,9 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
     },
     vrfSign: (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
-      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
+      if (isLocked(secretKey)) {
+        throw new Error('Cannot sign with a locked key pair');
+      }
 
       if (type === 'sr25519') {
         return sr25519VrfSign(message, { secretKey }, context, extra);

packages/keyring/src/pair/nobody.ts

@@ -3,10 +3,11 @@
 
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';
 
-import { encodeAddress } from '@polkadot/util-crypto';
-
+// empty publicKey
 const publicKey = new Uint8Array(32);
-const address = encodeAddress(publicKey);
+
+// pre-computed via encodeAddress(publicKey)
+const address = '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM';
 
 const meta = {
   isTesting: true,

packages/keyring/src/pairs.ts

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { KeyringPair, KeyringPairs } from './types';
 
-import { assert, isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 
 type KeyringPairMap = Record<string, KeyringPair>;
@@ -25,11 +25,13 @@ export class Pairs implements KeyringPairs {
   public get (address: HexString | string | Uint8Array): KeyringPair {
     const pair = this.#map[decodeAddress(address).toString()];
 
-    assert(pair, () => `Unable to retrieve keypair '${
-      isU8a(address) || isHex(address)
-        ? u8aToHex(u8aToU8a(address))
-        : address
-    }'`);
+    if (!pair) {
+      throw new Error(`Unable to retrieve keypair '${
+        isU8a(address) || isHex(address)
+          ? u8aToHex(u8aToU8a(address))
+          : address
+      }'`);
+    }
 
     return pair;
   }

packages/keyring/src/testing.ts

@@ -1,19 +1,20 @@
 // Copyright 2017-2022 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
+import type { KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions } from './types';
 
-import { assert, hexToU8a } from '@polkadot/util';
-import { KeypairType } from '@polkadot/util-crypto/types';
+import { hexToU8a } from '@polkadot/util';
 
 import { Keyring } from './keyring';
 import { createPair } from './pair';
 
 interface PairDef {
   name?: string;
-  publicKey: Uint8Array;
+  p: HexString;
+  s: HexString;
   seed?: string;
-  secretKey?: Uint8Array;
   type: KeypairType
 }
 
@@ -23,50 +24,50 @@ interface PairDef {
 // adding the keys when only the keyring is used.
 export const PAIRSSR25519: PairDef[] = [
   {
-    publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
-    secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'), // nosemgrep
+    p: '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d',
+    s: '0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011', // nosemgrep
     seed: 'Alice',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
-    secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'), // nosemgrep
+    p: '0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f',
+    s: '0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd', // nosemgrep
     seed: 'Alice//stash',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
-    secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'), // nosemgrep
+    p: '0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48',
+    s: '0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325', // nosemgrep
     seed: 'Bob',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
-    secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'), // nosemgrep
+    p: '0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e',
+    s: '0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde', // nosemgrep
     seed: 'Bob//stash',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
-    secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'), // nosemgrep
+    p: '0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22',
+    s: '0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c', // nosemgrep
     seed: 'Charlie',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
-    secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'), // nosemgrep
+    p: '0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20',
+    s: '0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568', // nosemgrep
     seed: 'Dave',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
-    secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'), // nosemgrep
+    p: '0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e',
+    s: '0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587', // nosemgrep
     seed: 'Eve',
     type: 'sr25519'
   },
   {
-    publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
-    secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'), // nosemgrep
+    p: '0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c',
+    s: '0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426', // nosemgrep
     seed: 'Ferdie',
     type: 'sr25519'
   }
@@ -75,44 +76,46 @@ export const PAIRSSR25519: PairDef[] = [
 export const PAIRSETHEREUM: PairDef[] = [
   {
     name: 'Alith',
-    publicKey: hexToU8a('0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f'),
-    secretKey: hexToU8a('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'), // nosemgrep
+    p: '0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f',
+    s: '0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133', // nosemgrep
     type: 'ethereum'
   },
   {
     name: 'Baltathar',
-    publicKey: hexToU8a('0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518'),
-    secretKey: hexToU8a('0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'), // nosemgrep
+    p: '0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518',
+    s: '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b', // nosemgrep
     type: 'ethereum'
   },
   {
     name: 'Charleth',
-    publicKey: hexToU8a('0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e'),
-    secretKey: hexToU8a('0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b'), // nosemgrep
+    p: '0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e',
+    s: '0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b', // nosemgrep
     type: 'ethereum'
   },
   {
     name: 'Dorothy',
-    publicKey: hexToU8a('0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c'),
-    secretKey: hexToU8a('0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'), // nosemgrep
+    p: '0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c',
+    s: '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68', // nosemgrep
     type: 'ethereum'
   },
   {
     name: 'Ethan',
-    publicKey: hexToU8a('0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa'),
-    secretKey: hexToU8a('0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4'), // nosemgrep
+    p: '0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa',
+    s: '0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4', // nosemgrep
     type: 'ethereum'
   },
   {
     name: 'Faith',
-    publicKey: hexToU8a('0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74'),
-    secretKey: hexToU8a('0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df'), // nosemgrep
+    p: '0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74',
+    s: '0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df', // nosemgrep
     type: 'ethereum'
   }
 ];
 
 function createMeta (name?: string, seed?: string) {
-  assert(name || seed, 'Testing pair should have either a name or a seed');
+  if (!name && !seed) {
+    throw new Error('Testing pair should have either a name or a seed');
+  }
 
   return {
     isTesting: true,
@@ -128,16 +131,20 @@ function createMeta (name?: string, seed?: string) {
  */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
-  const pairs = (options.type && options.type === 'ethereum')
+  const pairs = options.type === 'ethereum'
     ? PAIRSETHEREUM
     : PAIRSSR25519;
 
-  for (const { name, publicKey, secretKey, seed, type } of pairs) {
+  for (const { name, p, s, seed, type } of pairs) {
     const meta = createMeta(name, seed);
     const pair = !isDerived && !name && seed
       ? keyring.addFromUri(seed, meta, options.type)
       : keyring.addPair(
-        createPair({ toSS58: keyring.encodeAddress, type }, { publicKey, secretKey }, meta)
+        createPair(
+          { toSS58: keyring.encodeAddress, type },
+          { publicKey: hexToU8a(p), secretKey: hexToU8a(s) },
+          meta
+        )
       );
 
     pair.lock = (): void => {

packages/keyring/src/types.ts

@@ -18,7 +18,9 @@ export interface KeyringOptions {
 export type KeyringPair$Meta = Record<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;
+  /** The underlying metadata associated with the keypair */
   meta: KeyringPair$Meta;
 }
 

packages/networks/package.json

@@ -17,15 +17,14 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/util": "9.5.1",
-    "@substrate/ss58-registry": "^1.22.0"
+    "@babel/runtime": "^7.20.1",
+    "@polkadot/util": "10.1.14",
+    "@substrate/ss58-registry": "^1.35.0"
   },
   "devDependencies": {
-    "@polkadot/hw-ledger": "9.5.1",
-    "@polkadot/x-fetch": "9.5.1"
+    "@polkadot/hw-ledger": "10.1.14"
   }
 }

packages/networks/src/crosscheck.spec.ts

@@ -1,75 +0,0 @@
-// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Ss58Registry } from './types';
-
-import fs from 'fs';
-
-import { objectKeys, stringify } from '@polkadot/util';
-import { fetch } from '@polkadot/x-fetch';
-
-import { allNetworks } from './';
-
-const REGISTRY = 'https://raw.githubusercontent.com/paritytech/ss58-registry/main/ss58-registry.json';
-const OUTPUT = './.github/ss58-check.md';
-
-function assertAndLog (check: boolean, error: string): void {
-  if (!check) {
-    process.env.CI_LOG && fs.appendFileSync(OUTPUT, `
-
-${error}
-`);
-
-    throw new Error(error);
-  }
-}
-
-describe('check latest Substrate ss58 registry', (): void => {
-  let original: Ss58Registry;
-
-  beforeAll(async (): Promise<void> => {
-    original = (await (await fetch(REGISTRY)).json()) as Ss58Registry;
-  });
-
-  it('has the same number as the original', (): void => {
-    assertAndLog(allNetworks.length === original.registry.length, `Number of entries mismatched:: Expected ${original.registry.length} found ${allNetworks.length}`);
-  });
-
-  it('has no missing any entries', (): void => {
-    const missing = original.registry
-      .filter(({ prefix }) => !allNetworks.some((n) => n.prefix === prefix))
-      .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
-
-    assertAndLog(!missing.length, `Missing entries found: ${stringify(missing, 2)}`);
-  });
-
-  it('has no extra entries', (): void => {
-    const missing = allNetworks
-      .filter(({ prefix }) => !original.registry.some((n) => n.prefix === prefix))
-      .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
-
-    assertAndLog(!missing.length, `Extra entries found: ${stringify(missing, 2)}`);
-  });
-
-  it('has the same values as the original', (): void => {
-    const fields = objectKeys(original.schema);
-    const errors = original.registry
-      .map((n): [string, string[]] => {
-        const other = allNetworks.find(({ prefix }) => prefix === n.prefix);
-
-        return [
-          `${n.displayName} (${n.prefix})`,
-          other
-            ? fields.filter((f) =>
-              ['decimals', 'symbols'].includes(f)
-                ? stringify(n[f] || []) !== stringify(other[f] || [])
-                : stringify(n[f]) !== stringify(other[f])
-            )
-            : []
-        ];
-      })
-      .filter(([, fields]) => fields.length);
-
-    assertAndLog(!errors.length, `Mismatches found: ${stringify(errors.map(([n, m]) => `${n}:: ${m.join(', ')}`), 2)}`);
-  });
-});

packages/networks/src/defaults/genesis.ts

@@ -11,6 +11,9 @@ export const knownGenesis: KnownGenesis = {
   acala: [
     '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
   ],
+  'aleph-node': [
+    '0x70255b4d28de0fc4e1a193d7e175ad1ccef431598211c55538f1018651a0344e'
+  ],
   astar: [
     '0x9eb76c5184c4ab8679d2d5d819fdf90b9c001403e9e17da2e14b6d8aec4029c6'
   ],
@@ -20,6 +23,9 @@ export const knownGenesis: KnownGenesis = {
   bifrost: [
     '0x262e1b2ad728475fd6fe88e62d34c200abe6fd693931ddad144059b1eb884e5b'
   ],
+  'bifrost-kusama': [
+    '0x9f28c6a68e0fc9646eff64935684f6eeeece527e37bbe1f213d22caa1d9d6bed'
+  ],
   centrifuge: [
     '0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82',
     '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
@@ -27,6 +33,9 @@ export const knownGenesis: KnownGenesis = {
   composable: [
     '0xdaab8df776eb52ec604a5df5d388bb62a050a0aaec4556a64265b9d42755552d'
   ],
+  darwinia: [
+    '0xe71578b37a7c799b0ab4ee87ffa6f059a6b98f71f06fb8c84a8d88013a548ad6'
+  ],
   'dock-mainnet': [
     '0x6bfe24dca2a3be10f22212678ac13a6446ec764103c0f3471c71609eac384aae',
     '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
@@ -41,14 +50,21 @@ export const knownGenesis: KnownGenesis = {
     '0x9b8cefc0eb5c568b527998bdd76c184e2b76ae561be76e4667072230217ea243'
   ],
   hydradx: [
+    '0xafdc188f45c71dacbaa0b62e16a91f726c7b8699a9748cdf715459de6b7f366d', // HydraDX Parachain
     '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc', // Snakenet Gen3-1
     '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9', // Snakenet Gen3
     '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047', // Snakenet Gen2
     '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2' // Snakenet Gen1
   ],
+  'interlay-parachain': [
+    '0xbf88efe70e9e0e916416e8bed61f2b45717f517d7f3523e33c7b001e5ffcbc72'
+  ],
   karura: [
     '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
   ],
+  khala: [
+    '0xd43540ba6d3eb4897c28a77d48cb5b729fea37603cbbfc7a86a73b72adb3be8d'
+  ],
   kulupu: [
     '0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'
   ],
@@ -60,9 +76,15 @@ export const knownGenesis: KnownGenesis = {
   'nodle-para': [
     '0x97da7ede98d7bad4e36b4d734b6055425a3be036da2a332ea5a7037656427a21'
   ],
+  origintrail: [
+    '0xe7e0962324a3b86c83404dbea483f25fb5dab4c224791c81b756cfc948006174'
+  ],
   parallel: [
     '0xe61a41c53f5dcd0beb09df93b34402aada44cb05117b71059cce40a2723a4e97'
   ],
+  phala: [
+    '0x1bb969d85965e4bb5a651abbedf21a54b6b31a21f66b5401cc3f1e286268d736'
+  ],
   picasso: [
     '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
   ],
@@ -104,6 +126,13 @@ export const knownGenesis: KnownGenesis = {
   subsocial: [
     '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
   ],
+  unique: [
+    '0x84322d9cddbf35088f1e54e9a85c967a41a56a4f43445768125e61af166c7d31'
+  ],
+  vtb: [
+    '0x286bc8414c7000ce1d6ee6a834e29a54c1784814b76243eb77ed0b2c5573c60f',
+    '0x7483b89572fb2bd687c7b9a93b242d0b237f9aba463aba07ec24503931038aaa'
+  ],
   westend: [
     '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e'
   ],

packages/networks/src/defaults/ledger.ts

@@ -9,23 +9,34 @@ import type { KnownLedger } from '../types';
 // NOTE: Any network here needs to have a genesisHash attached in the ./genesis.ts config
 export const knownLedger: KnownLedger = {
   acala: 0x00000313,
+  'aleph-node': 0x00000283,
   astar: 0x0000032a,
   bifrost: 0x00000314,
+  'bifrost-kusama': 0x00000314,
   centrifuge: 0x000002eb,
   composable: 0x00000162,
+  darwinia: 0x00000162,
   'dock-mainnet': 0x00000252,
   edgeware: 0x0000020b,
   equilibrium: 0x05f5e0fd,
   genshiro: 0x05f5e0fc,
+  hydradx: 0x00000162,
+  'interlay-parachain': 0x00000162,
   karura: 0x000002ae,
+  khala: 0x000001b2,
   kusama: 0x000001b2,
   'nodle-para': 0x000003eb,
+  origintrail: 0x00000162,
   parallel: 0x00000162,
+  phala: 0x00000162,
   polkadex: 0x0000031f,
   polkadot: 0x00000162,
   polymesh: 0x00000253,
   sora: 0x00000269,
+  stafi: 0x0000038b,
   statemine: 0x000001b2, // common-good on Kusama, shares derivation
   statemint: 0x00000162, // common-good on Polkadot, shares derivation
+  unique: 0x00000162,
+  vtb: 0x000002b6,
   xxnetwork: 0x000007a3
 };

packages/networks/src/defaults/testnets.ts

@@ -10,6 +10,7 @@ export const knownTestnet: KnownTestnet = {
   'dock-testnet': true,
   jupiter: true,
   'mathchain-testnet': true,
+  p3dt: true,
   subspace_testnet: true,
   'zero-alphaville': true
 };

packages/networks/src/index.spec.ts

@@ -11,7 +11,7 @@ describe('availableNetworks', (): void => {
     expect(availableNetworks.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
   });
 
-  it('has a sorted list (first external, last external)', (): void => {
+  it.skip('has a sorted list (first external, last external)', (): void => {
     expect(availableNetworks[3].displayName).toEqual('Acala');
     expect(availableNetworks[availableNetworks.length - 1].displayName).toEqual('ZERO');
   });

packages/networks/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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: '9.5.1' };
+export const packageInfo = { name: '@polkadot/networks', path: 'auto', type: 'auto', version: '10.1.14' };

packages/networks/src/test/ss58registry.test.json

@@ -232,6 +232,19 @@
     "standardAccount": "*25519",
     "website": "https://darwinia.network/"
   },
+  {
+    "prefix": 19,
+    "network": "watr",
+    "displayName": "Watr Protocol",
+    "symbols": [
+      "WATR"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.watr.org"
+  },
   {
     "prefix": 20,
     "network": "stafi",
@@ -438,7 +451,7 @@
       "NODL"
     ],
     "decimals": [
-      18
+      11
     ],
     "standardAccount": "*25519",
     "website": "https://nodle.io/"
@@ -599,9 +612,11 @@
     "network": "oak",
     "displayName": "OAK Network",
     "symbols": [
-      "OAK"
+      "OAK",
+      "TUR"
     ],
     "decimals": [
+      10,
       10
     ],
     "standardAccount": "*25519",
@@ -659,6 +674,32 @@
     "standardAccount": "*25519",
     "website": "https://xx.network"
   },
+  {
+    "prefix": 56,
+    "network": "pendulum",
+    "displayName": "Pendulum chain",
+    "symbols": [
+      "PEN"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://pendulumchain.org/"
+  },
+  {
+    "prefix": 57,
+    "network": "amplitude",
+    "displayName": "Amplitude chain",
+    "symbols": [
+      "AMPE"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://pendulumchain.org/"
+  },
   {
     "prefix": 63,
     "network": "hydradx",
@@ -741,6 +782,32 @@
     "standardAccount": "*25519",
     "website": "https://sora.org"
   },
+  {
+    "prefix": 71,
+    "network": "p3d",
+    "displayName": "3DP network",
+    "symbols": [
+      "P3D"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://3dpass.org"
+  },
+  {
+    "prefix": 72,
+    "network": "p3dt",
+    "displayName": "3DP test network",
+    "symbols": [
+      "P3Dt"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://3dpass.org"
+  },
   {
     "prefix": 73,
     "network": "zeitgeist",
@@ -806,6 +873,32 @@
     "standardAccount": "*25519",
     "website": "https://polkadex.trade"
   },
+  {
+    "prefix": 90,
+    "network": "frequency",
+    "displayName": "Frequency",
+    "symbols": [
+      "FRQCY"
+    ],
+    "decimals": [
+      8
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.frequency.xyz"
+  },
+  {
+    "prefix": 92,
+    "network": "anmol",
+    "displayName": "Anmol Network",
+    "symbols": [
+      "ANML"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://anmol.network/"
+  },
   {
     "prefix": 93,
     "network": "fragnova",
@@ -845,6 +938,19 @@
     "standardAccount": "*25519",
     "website": "https://polkafoundry.com"
   },
+  {
+    "prefix": 100,
+    "network": "ibtida",
+    "displayName": "Anmol Network Ibtida Canary network",
+    "symbols": [
+      "IANML"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://anmol.network/"
+  },
   {
     "prefix": 101,
     "network": "origintrail-parachain",
@@ -906,6 +1012,19 @@
     "standardAccount": "*25519",
     "website": "https://invarch.network"
   },
+  {
+    "prefix": 126,
+    "network": "joystream",
+    "displayName": "Joystream",
+    "symbols": [
+      "JOY"
+    ],
+    "decimals": [
+      10
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.joystream.org"
+  },
   {
     "prefix": 128,
     "network": "clover",
@@ -919,6 +1038,19 @@
     "standardAccount": "*25519",
     "website": "https://clover.finance"
   },
+  {
+    "prefix": 129,
+    "network": "dorafactory-polkadot",
+    "displayName": "Dorafactory Polkadot Network",
+    "symbols": [
+      "DORA"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://dorafactory.org"
+  },
   {
     "prefix": 131,
     "network": "litmus",
@@ -945,6 +1077,19 @@
     "standardAccount": "*25519",
     "website": "https://centrifuge.io/"
   },
+  {
+    "prefix": 137,
+    "network": "vara",
+    "displayName": "Vara Network",
+    "symbols": [
+      "VARA"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://vara-network.io/"
+  },
   {
     "prefix": 172,
     "network": "parallel",
@@ -979,7 +1124,7 @@
       "QTZ"
     ],
     "decimals": [
-      15
+      18
     ],
     "standardAccount": "*25519",
     "website": "https://unique.network"
@@ -1033,9 +1178,35 @@
     "decimals": [
       18
     ],
-    "standardAccount": "Sr25519",
+    "standardAccount": "*25519",
     "website": "https://efinity.io/"
   },
+  {
+    "prefix": 1221,
+    "network": "peaq",
+    "displayName": "Peaq Network",
+    "symbols": [
+      "PEAQ"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "Sr25519",
+    "website": "https://www.peaq.network/"
+  },
+  {
+    "prefix": 1222,
+    "network": "apex",
+    "displayName": "Apex Network",
+    "symbols": [
+      "APEX"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "Sr25519",
+    "website": "https://www.peaq.network/"
+  },
   {
     "prefix": 1284,
     "network": "moonbeam",
@@ -1088,6 +1259,19 @@
     "standardAccount": "*25519",
     "website": "https://ajuna.io"
   },
+  {
+    "prefix": 1985,
+    "network": "seals",
+    "displayName": "Seals Network",
+    "symbols": [
+      "SEAL"
+    ],
+    "decimals": [
+      9
+    ],
+    "standardAccount": "*25519",
+    "website": "https://seals.app"
+  },
   {
     "prefix": 2007,
     "network": "kapex",
@@ -1101,6 +1285,19 @@
     "standardAccount": "*25519",
     "website": "https://totemaccounting.com"
   },
+  {
+    "prefix": 2009,
+    "network": "cloudwalk_mainnet",
+    "displayName": "CloudWalk Network Mainnet",
+    "symbols": [
+      "CWN"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://explorer.mainnet.cloudwalk.io"
+  },
   {
     "prefix": 2032,
     "network": "interlay",
@@ -1127,6 +1324,71 @@
     "standardAccount": "*25519",
     "website": "https://interlay.io/"
   },
+  {
+    "prefix": 2106,
+    "network": "bitgreen",
+    "displayName": "Bitgreen",
+    "symbols": [
+      "BBB"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://bitgreen.org/"
+  },
+  {
+    "prefix": 2112,
+    "network": "chainflip",
+    "displayName": "Chainflip",
+    "symbols": [
+      "FLIP"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://chainflip.io/"
+  },
+  {
+    "prefix": 2114,
+    "network": "Turing",
+    "displayName": "Turing Network",
+    "symbols": [
+      "TUR"
+    ],
+    "decimals": [
+      10
+    ],
+    "standardAccount": "*25519",
+    "website": "https://oak.tech/turing/home/"
+  },
+  {
+    "prefix": 2207,
+    "network": "SNOW",
+    "displayName": "SNOW: ICE Canary Network",
+    "symbols": [
+      "ICZ"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://icenetwork.io"
+  },
+  {
+    "prefix": 2208,
+    "network": "ICE",
+    "displayName": "ICE Network",
+    "symbols": [
+      "ICY"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://icenetwork.io"
+  },
   {
     "prefix": 2254,
     "network": "subspace_testnet",
@@ -1140,6 +1402,45 @@
     "standardAccount": "*25519",
     "website": "https://subspace.network"
   },
+  {
+    "prefix": 4006,
+    "network": "tangle",
+    "displayName": "Tangle Network",
+    "symbols": [
+      "TNT"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://www.webb.tools/"
+  },
+  {
+    "prefix": 4450,
+    "network": "g1",
+    "displayName": "Ğ1",
+    "symbols": [
+      "G1"
+    ],
+    "decimals": [
+      2
+    ],
+    "standardAccount": "*25519",
+    "website": "https://duniter.org"
+  },
+  {
+    "prefix": 5234,
+    "network": "humanode",
+    "displayName": "Humanode Network",
+    "symbols": [
+      "HMND"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://humanode.io"
+  },
   {
     "prefix": 6094,
     "network": "subspace",
@@ -1158,7 +1459,7 @@
     "network": "tidefi",
     "displayName": "Tidefi",
     "symbols": [
-      "TIFI"
+      "TDFY"
     ],
     "decimals": [
       12
@@ -1166,6 +1467,23 @@
     "standardAccount": "*25519",
     "website": "https://tidefi.com"
   },
+  {
+    "prefix": 7013,
+    "network": "gm",
+    "displayName": "GM",
+    "symbols": [
+      "FREN",
+      "GM",
+      "GN"
+    ],
+    "decimals": [
+      12,
+      0,
+      0
+    ],
+    "standardAccount": "*25519",
+    "website": "https://gmordie.com"
+  },
   {
     "prefix": 7391,
     "network": "unique_mainnet",
@@ -1179,6 +1497,32 @@
     "standardAccount": "*25519",
     "website": "https://unique.network"
   },
+  {
+    "prefix": 8883,
+    "network": "sapphire_mainnet",
+    "displayName": "Sapphire by Unique",
+    "symbols": [
+      "QTZ"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://unique.network"
+  },
+  {
+    "prefix": 9072,
+    "network": "hashed",
+    "displayName": "Hashed Network",
+    "symbols": [
+      "HASH"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://hashed.network"
+  },
   {
     "prefix": 9807,
     "network": "dentnet",
@@ -1192,6 +1536,19 @@
     "standardAccount": "*25519",
     "website": "https://www.dentnet.io"
   },
+  {
+    "prefix": 9935,
+    "network": "t3rn",
+    "displayName": "t3rn",
+    "symbols": [
+      "TRN"
+    ],
+    "decimals": [
+      12
+    ],
+    "standardAccount": "*25519",
+    "website": "https://t3rn.io/"
+  },
   {
     "prefix": 10041,
     "network": "basilisk",
@@ -1231,6 +1588,19 @@
     "standardAccount": "*25519",
     "website": "https://cess.cloud"
   },
+  {
+    "prefix": 11486,
+    "network": "luhn",
+    "displayName": "Luhn Network",
+    "symbols": [
+      "LUHN"
+    ],
+    "decimals": [
+      18
+    ],
+    "standardAccount": "*25519",
+    "website": "https://luhn.network"
+  },
   {
     "prefix": 11820,
     "network": "contextfree",

packages/networks/tsconfig.build.json

@@ -12,7 +12,6 @@
   ],
   "references": [
     { "path": "../hw-ledger/tsconfig.build.json" },
-    { "path": "../util/tsconfig.build.json" },
-    { "path": "../x-fetch/tsconfig.build.json" }
+    { "path": "../util/tsconfig.build.json" }
   ]
 }

packages/util-crypto/package.json

@@ -22,21 +22,21 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "browser": {
     "crypto": false,
     "stream": false
   },
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@noble/hashes": "1.1.1",
-    "@noble/secp256k1": "1.6.0",
-    "@polkadot/networks": "9.5.1",
-    "@polkadot/util": "9.5.1",
-    "@polkadot/wasm-crypto": "^6.1.1",
-    "@polkadot/x-bigint": "9.5.1",
-    "@polkadot/x-randomvalues": "9.5.1",
+    "@babel/runtime": "^7.20.1",
+    "@noble/hashes": "1.1.3",
+    "@noble/secp256k1": "1.7.0",
+    "@polkadot/networks": "10.1.14",
+    "@polkadot/util": "10.1.14",
+    "@polkadot/wasm-crypto": "^6.3.1",
+    "@polkadot/x-bigint": "10.1.14",
+    "@polkadot/x-randomvalues": "10.1.14",
     "@scure/base": "1.1.1",
     "ed2curve": "^0.3.0",
     "tweetnacl": "^1.0.3"
@@ -45,6 +45,6 @@
     "@types/ed2curve": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "9.5.1"
+    "@polkadot/util": "10.1.14"
   }
 }

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

@@ -5,14 +5,16 @@ import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6
-import { assert, isHex, isU8a, u8aToU8a } from '@polkadot/util';
+import { isHex, isU8a, u8aToU8a } from '@polkadot/util';
 
 import { base58Decode } from '../base58';
 import { checkAddressChecksum } from './checksum';
 import { defaults } from './defaults';
 
 export function decodeAddress (encoded?: HexString | string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
-  assert(encoded, 'Invalid empty address passed');
+  if (!encoded) {
+    throw new Error('Invalid empty address passed');
+  }
 
   if (isU8a(encoded) || isHex(encoded)) {
     return u8aToU8a(encoded);
@@ -21,12 +23,17 @@ export function decodeAddress (encoded?: HexString | string | Uint8Array | null,
   try {
     const decoded = base58Decode(encoded);
 
-    assert(defaults.allowedEncodedLengths.includes(decoded.length), 'Invalid decoded address length');
+    if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
+      throw new Error('Invalid decoded address length');
+    }
 
     const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
 
-    assert(ignoreChecksum || isValid, 'Invalid decoded address checksum');
-    assert([-1, ss58Decoded].includes(ss58Format), () => `Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+    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) {

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

@@ -5,8 +5,6 @@ import type { HexString } from '@polkadot/util/types';
 import type { DeriveJunction } from '../key/DeriveJunction';
 import type { Prefix } from './types';
 
-import { assert } from '@polkadot/util';
-
 import { keyExtractPath } from '../key';
 import { sr25519DerivePublic } from '../sr25519';
 import { decodeAddress } from './decode';
@@ -25,7 +23,9 @@ function filterHard ({ isHard }: DeriveJunction): boolean {
 export function deriveAddress (who: HexString | Uint8Array | string, suri: string, ss58Format?: Prefix): string {
   const { path } = keyExtractPath(suri);
 
-  assert(path.length && !path.every(filterHard), 'Expected suri to contain a combination of non-hard paths');
+  if (!path.length || path.every(filterHard)) {
+    throw new Error('Expected suri to contain a combination of non-hard paths');
+  }
 
   let publicKey = decodeAddress(who);
 

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

@@ -5,7 +5,7 @@ import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L34
-import { assert, u8aConcat } from '@polkadot/util';
+import { u8aConcat } from '@polkadot/util';
 
 import { base58Encode } from '../base58';
 import { decodeAddress } from './decode';
@@ -16,8 +16,11 @@ export function encodeAddress (key: HexString | Uint8Array | string, ss58Format:
   // decode it, this means we can re-encode an address
   const u8a = decodeAddress(key);
 
-  assert(ss58Format >= 0 && ss58Format <= 16383 && ![46, 47].includes(ss58Format), 'Out of range ss58Format specified');
-  assert(defaults.allowedDecodedLengths.includes(u8a.length), () => `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+  if ((ss58Format < 0) || (ss58Format > 16383) || [46, 47].includes(ss58Format)) {
+    throw new Error('Out of range ss58Format specified');
+  } else if (!defaults.allowedDecodedLengths.includes(u8a.length)) {
+    throw new Error(`Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+  }
 
   const input = u8aConcat(
     ss58Format < 64

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

@@ -5,7 +5,7 @@ import type { HexString } from '@polkadot/util/types';
 import type { HashType } from '../secp256k1/types';
 import type { Prefix } from './types';
 
-import { assert, u8aConcat } from '@polkadot/util';
+import { u8aConcat } from '@polkadot/util';
 
 import { hasher } from '../secp256k1/hasher';
 import { encodeAddress } from './encode';
@@ -17,7 +17,9 @@ import { encodeAddress } from './encode';
 export function evmToAddress (evmAddress: HexString | string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
   const message = u8aConcat('evm:', evmAddress);
 
-  assert(message.length === 24, () => `Converting ${evmAddress as string}: Invalid evm address length`);
+  if (message.length !== 24) {
+    throw new Error(`Converting ${evmAddress as string}: Invalid evm address length`);
+  }
 
   return encodeAddress(hasher(hashType, message), ss58Format);
 }

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

@@ -3,7 +3,7 @@
 
 import type { U8aLike } from '@polkadot/util/types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 
 // re-export the type so *.d.ts files don't have ../src imports
 export type { U8aLike } from '@polkadot/util/types';
@@ -65,22 +65,23 @@ export function createIs (validate: ValidateFn): ValidateFn {
 /** @internal */
 export function createValidate ({ chars, ipfs, type }: Config): ValidateFn {
   return (value?: unknown, ipfsCompat?: boolean): value is string => {
-    assert(value && typeof value === 'string', () => `Expected non-null, non-empty ${type} string input`);
+    if (!value || typeof value !== 'string') {
+      throw new Error(`Expected non-null, non-empty ${type} string input`);
+    }
 
-    if (ipfs && ipfsCompat) {
-      assert(value[0] === ipfs, () => `Expected ipfs-compatible ${type} to start with '${ipfs}'`);
+    if (ipfs && ipfsCompat && value[0] !== ipfs) {
+      throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
     }
 
     for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
-      assert(
-        chars.includes(value[i]) || (
-          value[i] === '=' && (
-            (i === value.length - 1) ||
-            !chars.includes(value[i + 1])
-          )
-        ),
-        () => `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`
-      );
+      if (!(chars.includes(value[i]) || (
+        value[i] === '=' && (
+          (i === value.length - 1) ||
+          !chars.includes(value[i + 1])
+        )
+      ))) {
+        throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+      }
     }
 
     return true;

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

@@ -1,6 +1,8 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+export {};
+
 describe('cryptoWaitReady', (): void => {
   it('should return false when it cannot initialize', async (): Promise<void> => {
     const old = global.WebAssembly;

packages/util-crypto/src/crypto.ts

@@ -1,7 +1,6 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert } from '@polkadot/util';
 import { isReady, waitReady } from '@polkadot/wasm-crypto';
 
 export const cryptoIsReady = isReady;
@@ -9,7 +8,9 @@ export const cryptoIsReady = isReady;
 export function cryptoWaitReady (): Promise<boolean> {
   return waitReady()
     .then((): boolean => {
-      assert(isReady(), 'Unable to initialize @polkadot/util-crypto');
+      if (!isReady()) {
+        throw new Error('Unable to initialize @polkadot/util-crypto');
+      }
 
       return true;
     })

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

@@ -1,14 +1,16 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert, compactAddLength, isU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
 import { blake2AsU8a } from '../blake2/asU8a';
 
 const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));
 
 export function ed25519DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
-  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  }
 
   return blake2AsU8a(
     u8aConcat(HDKD, seed, chainCode)

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

@@ -6,7 +6,7 @@ import type { Keypair } from '../types';
 
 import nacl from 'tweetnacl';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';
 
 /**
@@ -24,7 +24,9 @@ import { ed25519Sign as wasmSign, isReady } from '@polkadot/wasm-crypto';
  * ```
  */
 export function ed25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
-  assert(secretKey, 'Expected a valid secretKey');
+  if (!secretKey) {
+    throw new Error('Expected a valid secretKey');
+  }
 
   const messageU8a = u8aToU8a(message);
 

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

@@ -5,7 +5,7 @@ import type { HexString } from '@polkadot/util/types';
 
 import nacl from 'tweetnacl';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { ed25519Verify as wasmVerify, isReady } from '@polkadot/wasm-crypto';
 
 /**
@@ -27,8 +27,11 @@ export function ed25519Verify (message: HexString | Uint8Array | string, signatu
   const publicKeyU8a = u8aToU8a(publicKey);
   const signatureU8a = u8aToU8a(signature);
 
-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
-  assert(signatureU8a.length === 64, () => `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+  } else if (signatureU8a.length !== 64) {
+    throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  }
 
   return !onlyJs && isReady()
     ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)

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

@@ -3,7 +3,7 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import { assert, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { u8aToHex, u8aToU8a } from '@polkadot/util';
 
 import { keccakAsU8a } from '../keccak';
 import { secp256k1Expand } from '../secp256k1';
@@ -23,7 +23,9 @@ export function ethereumEncode (addressOrPublic?: HexString | string | Uint8Arra
 
   const u8aAddress = u8aToU8a(addressOrPublic);
 
-  assert([20, 32, 33, 65].includes(u8aAddress.length), 'Invalid address or publicKey passed');
+  if (![20, 32, 33, 65].includes(u8aAddress.length)) {
+    throw new Error('Invalid address or publicKey passed');
+  }
 
   const address = u8aToHex(getH160(u8aAddress), -1, false);
   const hash = u8aToHex(keccakAsU8a(address), -1, false);

packages/util-crypto/src/hd/ethereum/index.ts

@@ -3,7 +3,7 @@
 
 import type { Keypair } from '../../types';
 
-import { assert, bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
 import { BN_BE_32_OPTS } from '../../bn';
 import { hmacShaAsU8a } from '../../hmac';
@@ -51,7 +51,9 @@ export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
     return hd;
   }
 
-  assert(hdValidatePath(path), 'Invalid derivation path');
+  if (!hdValidatePath(path)) {
+    throw new Error('Invalid derivation path');
+  }
 
   const parts = path.split('/').slice(1);
 

packages/util-crypto/src/hd/ledger/index.ts

@@ -3,8 +3,6 @@
 
 import type { Keypair } from '../../types';
 
-import { assert } from '@polkadot/util';
-
 import { ed25519PairFromSeed } from '../../ed25519';
 import { mnemonicValidate } from '../../mnemonic';
 import { HARDENED, hdValidatePath } from '../validatePath';
@@ -17,14 +15,19 @@ export function hdLedger (_mnemonic: string, path: string): Keypair {
     .map((s) => s.trim())
     .filter((s) => s);
 
-  assert([12, 24, 25].includes(words.length), 'Expected a mnemonic with 24 words (or 25 including a password)');
+  if (![12, 24, 25].includes(words.length)) {
+    throw new Error('Expected a mnemonic with 24 words (or 25 including a password)');
+  }
 
   const [mnemonic, password] = words.length === 25
     ? [words.slice(0, 24).join(' '), words[24]]
     : [words.join(' '), ''];
 
-  assert(mnemonicValidate(mnemonic), 'Invalid mnemonic passed to ledger derivation');
-  assert(hdValidatePath(path), 'Invalid derivation path');
+  if (!mnemonicValidate(mnemonic)) {
+    throw new Error('Invalid mnemonic passed to ledger derivation');
+  } else if (!hdValidatePath(path)) {
+    throw new Error('Invalid derivation path');
+  }
 
   const parts = path.split('/').slice(1);
   let seed = ledgerMaster(mnemonic, password);

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

@@ -3,13 +3,15 @@
 
 import type { EncryptedJson } from './types';
 
-import { assert, hexToU8a, isHex } from '@polkadot/util';
+import { hexToU8a, isHex } from '@polkadot/util';
 
 import { base64Decode } from '../base64';
 import { jsonDecryptData } from './decryptData';
 
 export function jsonDecrypt ({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array {
-  assert(encoded, 'No encrypted data available to decode');
+  if (!encoded) {
+    throw new Error('No encrypted data available to decode');
+  }
 
   return jsonDecryptData(
     isHex(encoded)

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

@@ -3,15 +3,18 @@
 
 import type { EncryptedJsonEncoding } from './types';
 
-import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
+import { stringToU8a, u8aFixLength } from '@polkadot/util';
 
 import { naclDecrypt } from '../nacl';
 import { scryptEncode, scryptFromU8a } from '../scrypt';
 import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants';
 
 export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: string | null, encType: EncryptedJsonEncoding[] = ENCODING): Uint8Array {
-  assert(encrypted, 'No encrypted data available to decode');
-  assert(passphrase || !encType.includes('xsalsa20-poly1305'), 'Password required to decode encrypted data');
+  if (!encrypted) {
+    throw new Error('No encrypted data available to decode');
+  } else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+    throw new Error('Password required to decode encrypted data');
+  }
 
   let encoded: Uint8Array | null = encrypted;
 
@@ -34,7 +37,9 @@ export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: str
     );
   }
 
-  assert(encoded, 'Unable to decode using the supplied passphrase');
+  if (!encoded) {
+    throw new Error('Unable to decode using the supplied passphrase');
+  }
 
   return encoded;
 }

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

@@ -1,8 +1,6 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert } from '@polkadot/util';
-
 import { DeriveJunction } from './DeriveJunction';
 
 const RE_JUNCTION = /\/(\/?)([^/]+)/g;
@@ -28,7 +26,9 @@ export function keyExtractPath (derivePath: string): ExtractResult {
     }
   }
 
-  assert(constructed === derivePath, () => `Re-constructed path "${constructed}" does not match input`);
+  if (constructed !== derivePath) {
+    throw new Error(`Re-constructed path "${constructed}" does not match input`);
+  }
 
   return {
     parts,

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

@@ -1,8 +1,6 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert, isNull } from '@polkadot/util';
-
 import { DeriveJunction } from './DeriveJunction';
 import { keyExtractPath } from './extractPath';
 
@@ -22,7 +20,9 @@ export function keyExtractSuri (suri: string): ExtractResult {
   // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
   const matches = suri.match(RE_CAPTURE);
 
-  assert(!isNull(matches), 'Unable to match provided value to a secret URI');
+  if (matches === null) {
+    throw new Error('Unable to match provided value to a secret URI');
+  }
 
   const [, phrase, , derivePath, , , password] = matches as string[];
   const { path } = keyExtractPath(derivePath);

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

@@ -3,13 +3,13 @@
 
 import type { Keypair } from '../types';
 
-import { assert } from '@polkadot/util';
-
 import { DeriveJunction } from './DeriveJunction';
 
 export function createSeedDeriveFn (fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair {
   return (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair => {
-    assert(isHard, 'A soft key was found in the path and is not supported');
+    if (!isHard) {
+      throw new Error('A soft key was found in the path and is not supported');
+    }
 
     return fromSeed(
       derive(keypair.secretKey.subarray(0, 32), chainCode)

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

@@ -1,6 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { entropyToMnemonic, mnemonicToEntropy } from './bip39';
 import DEFAULT_WORDLIST from './bip39-en';
 
 describe('wordlist', (): void => {
@@ -12,3 +13,13 @@ describe('wordlist', (): void => {
     expect(DEFAULT_WORDLIST.some((n) => !n.length || n.trim() !== n)).toEqual(false);
   });
 });
+
+describe('bip39', (): void => {
+  it('has a two-way entropy <-> mnemonic', (): void => {
+    const m = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+
+    expect(
+      entropyToMnemonic(mnemonicToEntropy(m))
+    ).toEqual(m);
+  });
+});

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

@@ -14,7 +14,7 @@
 //   - Remove mnemonicToSeed (we only use the sync variant)
 //   - generateMnemonic takes number of words (instead of strength)
 
-import { assert, stringToU8a, u8aToU8a } from '@polkadot/util';
+import { stringToU8a, u8aToU8a } from '@polkadot/util';
 
 import { pbkdf2Encode } from '../pbkdf2';
 import { randomAsU8a } from '../random';
@@ -53,14 +53,18 @@ export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8A
 export function mnemonicToEntropy (mnemonic: string): Uint8Array {
   const words = normalize(mnemonic).split(' ');
 
-  assert(words.length % 3 === 0, INVALID_MNEMONIC);
+  if (words.length % 3 !== 0) {
+    throw new Error(INVALID_MNEMONIC);
+  }
 
   // convert word indices to 11 bit binary strings
   const bits = words
     .map((word): string => {
       const index = DEFAULT_WORDLIST.indexOf(word);
 
-      assert(index !== -1, INVALID_MNEMONIC);
+      if (index === -1) {
+        throw new Error(INVALID_MNEMONIC);
+      }
 
       return index.toString(2).padStart(11, '0');
     })
@@ -72,30 +76,36 @@ export function mnemonicToEntropy (mnemonic: string): Uint8Array {
   const checksumBits = bits.slice(dividerIndex);
 
   // calculate the checksum and compare
-  const entropyBytes = entropyBits.match(/(.{1,8})/g)?.map(binaryToByte);
+  const matched = entropyBits.match(/(.{1,8})/g);
+  const entropyBytes = matched && matched.map(binaryToByte);
 
-  assert(entropyBytes && (entropyBytes.length % 4 === 0) && (entropyBytes.length >= 16) && (entropyBytes.length <= 32), INVALID_ENTROPY);
+  if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+    throw new Error(INVALID_ENTROPY);
+  }
 
   const entropy = u8aToU8a(entropyBytes);
-  const newChecksum = deriveChecksumBits(entropy);
 
-  assert(newChecksum === checksumBits, INVALID_CHECKSUM);
+  if (deriveChecksumBits(entropy) !== checksumBits) {
+    throw new Error(INVALID_CHECKSUM);
+  }
 
   return entropy;
 }
 
 export function entropyToMnemonic (entropy: Uint8Array): string {
   // 128 <= ENT <= 256
-  assert((entropy.length % 4 === 0) && (entropy.length >= 16) && (entropy.length <= 32), INVALID_ENTROPY);
+  if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
+    throw new Error(INVALID_ENTROPY);
+  }
 
-  const entropyBits = bytesToBinary(Array.from(entropy));
-  const checksumBits = deriveChecksumBits(entropy);
+  const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
+  const mapped = matched && matched.map((binary) => DEFAULT_WORDLIST[binaryToByte(binary)]);
 
-  // we just set it prior, so this is a safe check
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return (entropyBits + checksumBits).match(/(.{1,11})/g)!
-    .map((binary) => DEFAULT_WORDLIST[binaryToByte(binary)])
-    .join(' ');
+  if (!mapped || (mapped.length < 12)) {
+    throw new Error('Unable to map entropy to mnemonic');
+  }
+
+  return mapped.join(' ');
 }
 
 export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24): string {

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert, hasBigInt } from '@polkadot/util';
+import { hasBigInt } from '@polkadot/util';
 import { bip39ToSeed, isReady } from '@polkadot/wasm-crypto';
 
 import { mnemonicToSeedSync } from './bip39';
@@ -25,8 +25,11 @@ import { mnemonicValidate } from './validate';
  * ```
  */
 export function mnemonicToLegacySeed (mnemonic: string, password = '', onlyJs?: boolean, byteLength: 32 | 64 = 32): Uint8Array {
-  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
-  assert([32, 64].includes(byteLength), () => `Invalid seed length ${byteLength}, expected 32 or 64`);
+  if (!mnemonicValidate(mnemonic)) {
+    throw new Error('Invalid bip39 mnemonic specified');
+  } else if (![32, 64].includes(byteLength)) {
+    throw new Error(`Invalid seed length ${byteLength}, expected 32 or 64`);
+  }
 
   return byteLength === 32
     ? !hasBigInt || (!onlyJs && isReady())

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert, stringToU8a } from '@polkadot/util';
+import { stringToU8a } from '@polkadot/util';
 import { bip39ToMiniSecret, isReady } from '@polkadot/wasm-crypto';
 
 import { pbkdf2Encode } from '../pbkdf2';
@@ -9,7 +9,9 @@ import { mnemonicToEntropy } from './toEntropy';
 import { mnemonicValidate } from './validate';
 
 export function mnemonicToMiniSecret (mnemonic: string, password = '', onlyJs?: boolean): Uint8Array {
-  assert(mnemonicValidate(mnemonic), 'Invalid bip39 mnemonic specified');
+  if (!mnemonicValidate(mnemonic)) {
+    throw new Error('Invalid bip39 mnemonic specified');
+  }
 
   if (!onlyJs && isReady()) {
     return bip39ToMiniSecret(mnemonic, password);

packages/util-crypto/src/mod.ts

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './index';

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: '9.5.1' };
+export const packageInfo = { name: '@polkadot/util-crypto', path: 'auto', type: 'auto', version: '10.1.14' };

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

@@ -3,7 +3,7 @@
 
 import type { Params } from './types';
 
-import { assert, u8aToBn } from '@polkadot/util';
+import { u8aToBn } from '@polkadot/util';
 
 import { BN_LE_OPTS } from '../bn';
 import { DEFAULT_PARAMS } from './defaults';
@@ -23,7 +23,9 @@ export function scryptFromU8a (data: Uint8Array): Result {
   // 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
-  assert(N === DEFAULT_PARAMS.N && p === DEFAULT_PARAMS.p && r === DEFAULT_PARAMS.r, 'Invalid injected scrypt params found');
+  if (N !== DEFAULT_PARAMS.N || p !== DEFAULT_PARAMS.p || r !== DEFAULT_PARAMS.r) {
+    throw new Error('Invalid injected scrypt params found');
+  }
 
   return { params: { N, p, r }, salt };
 }

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

@@ -3,7 +3,7 @@
 
 import { Point } from '@noble/secp256k1';
 
-import { assert, hasBigInt } from '@polkadot/util';
+import { hasBigInt } from '@polkadot/util';
 import { isReady, secp256k1Compress as wasm } from '@polkadot/wasm-crypto';
 
 export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uint8Array {
@@ -11,7 +11,9 @@ export function secp256k1Compress (publicKey: Uint8Array, onlyJs?: boolean): Uin
     return publicKey;
   }
 
-  assert(publicKey.length === 65, 'Invalid publicKey provided');
+  if (publicKey.length !== 65) {
+    throw new Error('Invalid publicKey provided');
+  }
 
   return !hasBigInt || (!onlyJs && isReady())
     ? wasm(publicKey)

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

@@ -1,14 +1,16 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { assert, compactAddLength, isU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
 import { blake2AsU8a } from '../blake2/asU8a';
 
 const HDKD = compactAddLength(stringToU8a('Secp256k1HDKD'));
 
 export function secp256k1DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
-  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  }
 
   // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
   return blake2AsU8a(u8aConcat(HDKD, seed, chainCode), 256);

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

@@ -3,7 +3,7 @@
 
 import { Point } from '@noble/secp256k1';
 
-import { assert, bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
+import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Expand as wasm } from '@polkadot/wasm-crypto';
 
 import { BN_BE_256_OPTS } from '../bn';
@@ -13,7 +13,9 @@ export function secp256k1Expand (publicKey: Uint8Array, onlyJs?: boolean): Uint8
     return publicKey.subarray(1);
   }
 
-  assert(publicKey.length === 33, 'Invalid publicKey provided');
+  if (publicKey.length !== 33) {
+    throw new Error('Invalid publicKey provided');
+  }
 
   if (!hasBigInt || (!onlyJs && isReady())) {
     return wasm(publicKey).subarray(1);

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

@@ -5,7 +5,7 @@ import type { Keypair } from '../../types';
 
 import { getPublicKey } from '@noble/secp256k1';
 
-import { assert, hasBigInt, u8aEmpty } from '@polkadot/util';
+import { hasBigInt, u8aEmpty } from '@polkadot/util';
 import { isReady, secp256k1FromSeed } from '@polkadot/wasm-crypto';
 
 /**
@@ -13,7 +13,9 @@ import { isReady, secp256k1FromSeed } from '@polkadot/wasm-crypto';
  * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
  */
 export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  assert(seed.length === 32, 'Expected valid 32-byte private key as a seed');
+  if (seed.length !== 32) {
+    throw new Error('Expected valid 32-byte private key as a seed');
+  }
 
   if (!hasBigInt || (!onlyJs && isReady())) {
     const full = secp256k1FromSeed(seed);
@@ -23,7 +25,9 @@ export function secp256k1PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keyp
     // it seems that the lazy static section yields invalid results on the _first_ run.
     // If this happens, fail outright, we cannot allow invalid return values
     // https://github.com/polkadot-js/wasm/issues/307
-    assert(!u8aEmpty(publicKey), 'Invalid publicKey generated from WASM interface');
+    if (u8aEmpty(publicKey)) {
+      throw new Error('Invalid publicKey generated from WASM interface');
+    }
 
     return {
       publicKey,

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

@@ -6,7 +6,7 @@ import type { HashType } from './types';
 
 import { recoverPublicKey, Signature } from '@noble/secp256k1';
 
-import { assert, hasBigInt, u8aToU8a } from '@polkadot/util';
+import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { isReady, secp256k1Recover as wasm } from '@polkadot/wasm-crypto';
 
 import { secp256k1Compress } from './compress';
@@ -23,7 +23,9 @@ export function secp256k1Recover (msgHash: HexString | Uint8Array | string, sign
     ? wasm(msg, sig, recovery)
     : recoverPublicKey(msg, Signature.fromCompact(sig).toRawBytes(), recovery);
 
-  assert(publicKey, 'Unable to recover publicKey from signature');
+  if (!publicKey) {
+    throw new Error('Unable to recover publicKey from signature');
+  }
 
   return hashType === 'keccak'
     ? secp256k1Expand(publicKey, onlyJs)

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

@@ -6,7 +6,7 @@ import type { HashType } from './types';
 
 import { Signature, signSync } from '@noble/secp256k1';
 
-import { assert, bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
+import { bnToU8a, hasBigInt, u8aConcat } from '@polkadot/util';
 import { isReady, secp256k1Sign as wasm } from '@polkadot/wasm-crypto';
 
 import { BN_BE_256_OPTS } from '../bn';
@@ -17,7 +17,9 @@ import { hasher } from './hasher';
  * @description Returns message signature of `message`, using the supplied pair
  */
 export function secp256k1Sign (message: Uint8Array | string, { secretKey }: Partial<Keypair>, hashType: HashType = 'blake2', onlyJs?: boolean): Uint8Array {
-  assert(secretKey?.length === 32, 'Expected valid secp256k1 secretKey, 32-bytes');
+  if (secretKey?.length !== 32) {
+    throw new Error('Expected valid secp256k1 secretKey, 32-bytes');
+  }
 
   const data = hasher(hashType, message, onlyJs);
 

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _0n, assert, BN, bnToU8a, hasBigInt, isU8a, nToU8a, u8aToBigInt } from '@polkadot/util';
+import { _0n, BN, bnToU8a, hasBigInt, isU8a, nToU8a, u8aToBigInt } from '@polkadot/util';
 import { BigInt } from '@polkadot/x-bigint';
 
 import { BN_BE_256_OPTS, BN_BE_OPTS } from '../bn';
@@ -15,7 +15,9 @@ const N_BN = new BN(N, 'hex');
 function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
   let res = u8aToBigInt(tweak, BN_BE_OPTS);
 
-  assert(res < N_BI, 'Tweak parameter is out of range');
+  if (res >= N_BI) {
+    throw new Error('Tweak parameter is out of range');
+  }
 
   res += u8aToBigInt(seckey, BN_BE_OPTS);
 
@@ -23,7 +25,9 @@ function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
     res -= N_BI;
   }
 
-  assert(res !== _0n, 'Invalid resulting private key');
+  if (res === _0n) {
+    throw new Error('Invalid resulting private key');
+  }
 
   return nToU8a(res, BN_BE_256_OPTS);
 }
@@ -31,7 +35,9 @@ function addBi (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
 function addBn (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
   const res = new BN(tweak);
 
-  assert(res.cmp(N_BN) < 0, 'Tweak parameter is out of range');
+  if (res.cmp(N_BN) >= 0) {
+    throw new Error('Tweak parameter is out of range');
+  }
 
   res.iadd(new BN(seckey));
 
@@ -39,14 +45,19 @@ function addBn (seckey: Uint8Array, tweak: Uint8Array): Uint8Array {
     res.isub(N_BN);
   }
 
-  assert(!res.isZero(), 'Invalid resulting private key');
+  if (res.isZero()) {
+    throw new Error('Invalid resulting private key');
+  }
 
   return bnToU8a(res, BN_BE_256_OPTS);
 }
 
 export function secp256k1PrivateKeyTweakAdd (seckey: Uint8Array, tweak: Uint8Array, onlyBn?: boolean): Uint8Array {
-  assert(isU8a(seckey) && seckey.length === 32, 'Expected seckey to be an Uint8Array with length 32');
-  assert(isU8a(tweak) && tweak.length === 32, 'Expected tweak to be an Uint8Array with length 32');
+  if (!isU8a(seckey) || seckey.length !== 32) {
+    throw new Error('Expected seckey to be an Uint8Array with length 32');
+  } else if (!isU8a(tweak) || tweak.length !== 32) {
+    throw new Error('Expected tweak to be an Uint8Array with length 32');
+  }
 
   return !hasBigInt || onlyBn
     ? addBn(seckey, tweak)

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { HashType } from './types';
 
-import { assert, u8aEq, u8aToU8a } from '@polkadot/util';
+import { u8aEq, u8aToU8a } from '@polkadot/util';
 
 import { hasher } from './hasher';
 import { secp256k1Recover } from './recover';
@@ -16,7 +16,9 @@ import { secp256k1Recover } from './recover';
 export function secp256k1Verify (msgHash: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, address: HexString | Uint8Array | string, hashType: HashType = 'blake2', onlyJs?: boolean): boolean {
   const sig = u8aToU8a(signature);
 
-  assert(sig.length === 65, `Expected signature with 65 bytes, ${sig.length} found instead`);
+  if (sig.length !== 65) {
+    throw new Error(`Expected signature with 65 bytes, ${sig.length} found instead`);
+  }
 
   const publicKey = secp256k1Recover(hasher(hashType, msgHash), sig, sig[64], hashType, onlyJs);
   const signerAddr = hasher(hashType, publicKey, onlyJs);

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType, VerifyResult } from '../types';
 
-import { assert, u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+import { u8aIsWrapped, u8aToU8a, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
 
 import { decodeAddress } from '../address/decode';
 import { ed25519Verify } from '../ed25519/verify';
@@ -57,7 +57,9 @@ function verifyDetect (result: VerifyResult, { message, publicKey, signature }:
 }
 
 function verifyMultisig (result: VerifyResult, { message, publicKey, signature }: VerifyInput): VerifyResult {
-  assert([0, 1, 2].includes(signature[0]), () => `Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+  if (![0, 1, 2].includes(signature[0])) {
+    throw new Error(`Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+  }
 
   const type = CRYPTO_TYPES[signature[0]] || 'none';
 
@@ -88,7 +90,9 @@ function getVerifyFn (signature: Uint8Array): VerifyFn {
 export function signatureVerify (message: HexString | Uint8Array | string, signature: HexString | Uint8Array | string, addressOrPublicKey: HexString | Uint8Array | string): VerifyResult {
   const signatureU8a = u8aToU8a(signature);
 
-  assert([64, 65, 66].includes(signatureU8a.length), () => `Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+  if (![64, 65, 66].includes(signatureU8a.length)) {
+    throw new Error(`Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+  }
 
   const publicKey = decodeAddress(addressOrPublicKey);
   const input = { message: u8aToU8a(message), publicKey, signature: signatureU8a };

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

@@ -3,7 +3,7 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519Agree } from '@polkadot/wasm-crypto';
 
 /**
@@ -14,8 +14,11 @@ export function sr25519Agreement (secretKey: HexString | Uint8Array | string, pu
   const secretKeyU8a = u8aToU8a(secretKey);
   const publicKeyU8a = u8aToU8a(publicKey);
 
-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  assert(secretKeyU8a.length === 64, () => `Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  } else if (secretKeyU8a.length !== 64) {
+    throw new Error(`Invalid secretKey, received ${secretKeyU8a.length} bytes, expected 64`);
+  }
 
   return sr25519Agree(publicKeyU8a, secretKeyU8a);
 }

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

@@ -3,14 +3,16 @@
 
 import type { Keypair } from '../types';
 
-import { assert, isU8a } from '@polkadot/util';
+import { isU8a } from '@polkadot/util';
 
 import { sr25519PairFromU8a } from './pair/fromU8a';
 import { sr25519KeypairToU8a } from './pair/toU8a';
 
 export function createDeriveFn (derive: (pair: Uint8Array, cc: Uint8Array) => Uint8Array): (keypair: Keypair, chainCode: Uint8Array) => Keypair {
   return (keypair: Keypair, chainCode: Uint8Array): Keypair => {
-    assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+      throw new Error('Invalid chainCode passed to derive');
+    }
 
     return sr25519PairFromU8a(
       derive(sr25519KeypairToU8a(keypair), chainCode)

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

@@ -3,14 +3,17 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import { assert, isU8a, u8aToU8a } from '@polkadot/util';
+import { isU8a, u8aToU8a } from '@polkadot/util';
 import { sr25519DerivePublicSoft } from '@polkadot/wasm-crypto';
 
 export function sr25519DerivePublic (publicKey: HexString | Uint8Array | string, chainCode: Uint8Array): Uint8Array {
   const publicKeyU8a = u8aToU8a(publicKey);
 
-  assert(isU8a(chainCode) && chainCode.length === 32, 'Invalid chainCode passed to derive');
-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  } else if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  }
 
   return sr25519DerivePublicSoft(publicKeyU8a, chainCode);
 }

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519KeypairFromSeed } from '@polkadot/wasm-crypto';
 
 import { sr25519PairFromU8a } from './fromU8a';
@@ -16,7 +16,9 @@ import { sr25519PairFromU8a } from './fromU8a';
 export function sr25519PairFromSeed (seed: HexString | Uint8Array | string): Keypair {
   const seedU8a = u8aToU8a(seed);
 
-  assert(seedU8a.length === 32, () => `Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+  if (seedU8a.length !== 32) {
+    throw new Error(`Expected a seed matching 32 bytes, found ${seedU8a.length}`);
+  }
 
   return sr25519PairFromU8a(
     sr25519KeypairFromSeed(seedU8a)

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../../types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 
 const SEC_LEN = 64;
 const PUB_LEN = 32;
@@ -13,7 +13,9 @@ const TOT_LEN = SEC_LEN + PUB_LEN;
 export function sr25519PairFromU8a (full: HexString | Uint8Array | string): Keypair {
   const fullU8a = u8aToU8a(full);
 
-  assert(fullU8a.length === TOT_LEN, () => `Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+  if (fullU8a.length !== TOT_LEN) {
+    throw new Error(`Expected keypair with ${TOT_LEN} bytes, found ${fullU8a.length}`);
+  }
 
   return {
     publicKey: fullU8a.slice(SEC_LEN, TOT_LEN),

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519Sign as wasmSign } from '@polkadot/wasm-crypto';
 
 /**
@@ -12,8 +12,11 @@ import { sr25519Sign as wasmSign } from '@polkadot/wasm-crypto';
  * @description Returns message signature of `message`, using the supplied pair
  */
 export function sr25519Sign (message: HexString | Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
-  assert(publicKey?.length === 32, 'Expected a valid publicKey, 32-bytes');
-  assert(secretKey?.length === 64, 'Expected a valid secretKey, 64-bytes');
+  if (publicKey?.length !== 32) {
+    throw new Error('Expected a valid publicKey, 32-bytes');
+  } else if (secretKey?.length !== 64) {
+    throw new Error('Expected a valid secretKey, 64-bytes');
+  }
 
   return wasmSign(publicKey, secretKey, u8aToU8a(message));
 }

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

@@ -3,7 +3,7 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { sr25519Verify as wasmVerify } from '@polkadot/wasm-crypto';
 
 /**
@@ -14,8 +14,11 @@ export function sr25519Verify (message: HexString | Uint8Array | string, signatu
   const publicKeyU8a = u8aToU8a(publicKey);
   const signatureU8a = u8aToU8a(signature);
 
-  assert(publicKeyU8a.length === 32, () => `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
-  assert(signatureU8a.length === 64, () => `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  } else if (signatureU8a.length !== 64) {
+    throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  }
 
   return wasmVerify(signatureU8a, u8aToU8a(message), publicKeyU8a);
 }

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

@@ -4,7 +4,7 @@
 import type { HexString } from '@polkadot/util/types';
 import type { Keypair } from '../types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { vrfSign } from '@polkadot/wasm-crypto';
 
 const EMPTY_U8A = new Uint8Array();
@@ -14,7 +14,9 @@ const EMPTY_U8A = new Uint8Array();
  * @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 {
-  assert(secretKey?.length === 64, 'Invalid secretKey, expected 64-bytes');
+  if (secretKey?.length !== 64) {
+    throw new Error('Invalid secretKey, expected 64-bytes');
+  }
 
   return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
 }

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

@@ -3,7 +3,7 @@
 
 import type { HexString } from '@polkadot/util/types';
 
-import { assert, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 import { vrfVerify } from '@polkadot/wasm-crypto';
 
 const EMPTY_U8A = new Uint8Array();
@@ -16,8 +16,11 @@ export function sr25519VrfVerify (message: HexString | Uint8Array | string, sign
   const publicKeyU8a = u8aToU8a(publicKey);
   const proofU8a = u8aToU8a(signOutput);
 
-  assert(publicKeyU8a.length === 32, 'Invalid publicKey, expected 32-bytes');
-  assert(proofU8a.length === 96, 'Invalid vrfSign output, expected 96 bytes');
+  if (publicKeyU8a.length !== 32) {
+    throw new Error('Invalid publicKey, expected 32-bytes');
+  } else if (proofU8a.length !== 96) {
+    throw new Error('Invalid vrfSign output, expected 96 bytes');
+  }
 
   return vrfVerify(publicKeyU8a, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra), proofU8a);
 }

packages/util-crypto/src/test/performance.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { arrayRange } from '@polkadot/util';
-import { performance, performanceCmp } from '@polkadot/util/test/performance';
+import { perf, perfCmp } from '@polkadot/util/test/performance';
 
 import { randomAsU8a } from '..';
 
@@ -11,7 +11,7 @@ type ExecFn = (input: Uint8Array, onlyJs: boolean) => unknown;
 const GENERATED = arrayRange(256).map(() => [randomAsU8a()]);
 
 export function performanceWasm (name: string, count: number, exec: ExecFn, inputs = GENERATED): void {
-  performanceCmp(name, ['WebAssembly', 'JavaScript'], count, inputs, exec);
+  perfCmp(name, ['WebAssembly', 'JavaScript'], count, inputs, exec);
 }
 
-export { performance, performanceCmp };
+export { perf, perfCmp };

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

@@ -10,21 +10,23 @@ describe('xxhashAsHex', (): void => {
     await waitReady();
   });
 
-  it('returns a 64-bit value by default', (): void => {
-    expect(
-      xxhashAsHex('abc')
-    ).toEqual('0x990977adf52cbc44');
-  });
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value by default', (): void => {
+      expect(
+        xxhashAsHex('abc', undefined, onlyJs)
+      ).toEqual('0x990977adf52cbc44');
+    });
 
-  it('returns a 128-bit value (as specified)', (): void => {
-    expect(
-      xxhashAsHex('abc', 128)
-    ).toEqual('0x990977adf52cbc440889329981caa9be');
-  });
+    it('returns a 128-bit value (as specified)', (): void => {
+      expect(
+        xxhashAsHex('abc', 128, onlyJs)
+      ).toEqual('0x990977adf52cbc440889329981caa9be');
+    });
 
-  it('returns a 256-bit value (as specified)', (): void => {
-    expect(
-      xxhashAsHex('abc', 256)
-    ).toEqual('0x990977adf52cbc440889329981caa9bef7da5770b2b8a05303b75d95360dd62b');
+    it('returns a 256-bit value (as specified)', (): void => {
+      expect(
+        xxhashAsHex('abc', 256, onlyJs)
+      ).toEqual('0x990977adf52cbc440889329981caa9bef7da5770b2b8a05303b75d95360dd62b');
+    });
   });
 });

packages/util/package.json

@@ -34,19 +34,18 @@
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "9.5.1",
+  "version": "10.1.14",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.18.3",
-    "@polkadot/x-bigint": "9.5.1",
-    "@polkadot/x-global": "9.5.1",
-    "@polkadot/x-textdecoder": "9.5.1",
-    "@polkadot/x-textencoder": "9.5.1",
-    "@types/bn.js": "^5.1.0",
-    "bn.js": "^5.2.1",
-    "ip-regex": "^4.3.0"
+    "@babel/runtime": "^7.20.1",
+    "@polkadot/x-bigint": "10.1.14",
+    "@polkadot/x-global": "10.1.14",
+    "@polkadot/x-textdecoder": "10.1.14",
+    "@polkadot/x-textencoder": "10.1.14",
+    "@types/bn.js": "^5.1.1",
+    "bn.js": "^5.2.1"
   },
   "devDependencies": {
-    "@polkadot/x-randomvalues": "9.5.1"
+    "@polkadot/x-randomvalues": "10.1.14"
   }
 }

packages/util/src/array/chunk.spec.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { performance } from '../test/performance';
+import { perf } from '../test/performance';
 import { arrayChunk, arrayRange } from '.';
 
 describe('arrayChunk', (): void => {
@@ -11,5 +11,5 @@ describe('arrayChunk', (): void => {
     ).toEqual([[1, 2, 3], [4, 5, 6], [7]]);
   });
 
-  performance('arrayChunk', 200_000, [[arrayRange(500), 50]], arrayChunk);
+  perf('arrayChunk', 200_000, [[arrayRange(500), 50]], arrayChunk);
 });

packages/util/src/array/filter.ts

@@ -1,9 +1,6 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { isNull } from '../is/null';
-import { isUndefined } from '../is/undefined';
-
 /**
  * @name arrayFilter
  * @summary Filters undefined and (optionally) null values from an array
@@ -19,9 +16,9 @@ import { isUndefined } from '../is/undefined';
  * arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']
  * ```
  */
-export function arrayFilter <T = unknown> (array: (T | null | undefined)[], allowNulls = true): T[] {
+export function arrayFilter <T = unknown> (array: readonly (T | null | undefined)[], allowNulls = true): T[] {
   return array.filter((v): v is T =>
-    !isUndefined(v) &&
-    (allowNulls || !isNull(v))
+    v !== undefined &&
+    (allowNulls || v !== null)
   );
 }

packages/util/src/array/flatten.spec.ts

@@ -1,12 +1,31 @@
 // Copyright 2017-2022 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { perf } from '../test/performance';
 import { arrayFlatten } from '.';
 
+const PERF_ONE = [[1, 2, 3, 4, 5]];
+const PERF_MUL = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
+
 describe('arrayFlatten', (): void => {
   it('flattens arrays', (): void => {
     expect(
       arrayFlatten([[0], [1, 2, 3], [4, 5], [6], [], [7, 8]])
     ).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
   });
+
+  it('flattens a single entry', (): void => {
+    expect(
+      arrayFlatten([[1, 2, 3, 4, 5]])
+    ).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('flattens an empty', (): void => {
+    expect(
+      arrayFlatten([])
+    ).toEqual([]);
+  });
+
+  perf('arrayFlatten (single)', 10_000_000, [[PERF_ONE]], arrayFlatten);
+  perf('arrayFlatten (multi)', 700_000, [[PERF_MUL]], arrayFlatten);
 });