[CI Skip] release/stable 10.2.1

skip-checks: true

.123trigger

@@ -1,29 +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

.github/issue_template.md

@@ -0,0 +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.
+
+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 ...**
+
+<!---
+
+REQUIRED:
+
+Classify the type of report your are submitting
+
+-->
+
+  - [ ] Bug report
+  - [ ] Feature request
+  - [ ] Support request
+  - [ ] Other
+
+
+* **What is the current behavior and expected behavior?**
+
+<!---
+
+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?**
+
+<!---
+
+OPTIONAL:
+
+Suggest a motivation for the request or ideas how to implement the
+addition or change
+
+-->
+
+
+* **Please tell us about your environment:**
+
+<!---
+
+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)
+
+  - Language:
+
+    - [ ] JavaScript
+    - [ ] TypeScript (include tsc --version)
+    - [ ] Other

.github/ss58-check.md

@@ -1,10 +0,0 @@
----
-title: SS58 registry is outdated
-labels: ['ci', '@networks']
----
-
-cc @polkadot-js/notifications
-
-Discrepancies detected between https://github.com/paritytech/substrate/blob/master/ss58-registry.json and https://github.com/polkadot-js/common/blob/master/packages/networks/src/substrate.ts
-
-Check the nightly cron output (or via `yarn networks:crosscheck` locally) and run `yarn networks:sync` to update. The output as found from the test includes:

.github/workflows/auto-approve.yml

@@ -0,0 +1,16 @@
+name: bot
+
+on:
+  pull_request:
+    types: [labeled]
+
+jobs:
+  approve:
+    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@9d6ce78d26f23ad29d009d034822cf773f2cb50e
+        with:
+          authors: jacogr
+          labels: -auto
+          token: ${{ secrets.GH_PAT_BOT }}

.github/workflows/auto-merge.yml

@@ -0,0 +1,16 @@
+name: bot
+
+on:
+  pull_request:
+    types: [labeled]
+
+jobs:
+  merge:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: jacogr/action-merge@3b4b49af8a8644bf5cbb5409ee236abe04eeb1b0
+        with:
+          checks: build,lint,test
+          labels: -auto
+          strategy: squash
+          token: ${{ secrets.GH_PAT_BOT }}

.github/workflows/lock.yml

@@ -7,8 +7,10 @@ on:
 jobs:
   lock:
     runs-on: ubuntu-latest
+    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,14 +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 }}
-      env:
-        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      if: always()
       run: |
         yarn install --immutable | grep -v 'YN0013'
         yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -12,17 +12,18 @@ jobs:
         step: ['build:release']
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
+    env:
+      YARN_ENABLE_SCRIPTS: false
+      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+      GH_PAT: ${{ secrets.GH_PAT }}
+      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 }}
     - name: ${{ matrix.step }}
-      env:
-        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
-        GH_PAT: ${{ secrets.GH_PAT }}
-        GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
-        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
         yarn install --immutable | grep -v 'YN0013'
         yarn ${{ matrix.step }}

.github/workflows/semgrep.yml

@@ -9,9 +9,11 @@ jobs:
   check:
     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
+    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/ss58-check.yml

@@ -1,26 +0,0 @@
-name: SS58
-on:
-  schedule:
-    - cron:  '15 4/6 * * *'
-
-jobs:
-  ss58:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: check
-      env:
-        CI_LOG: 123
-      run: |
-        yarn install --immutable | grep -v 'YN0013'
-        yarn build
-        yarn networks:crosscheck
-
-    - name: issue
-      if: ${{ failure() }}
-      uses: JasonEtco/create-an-issue@v2
-      env:
-        GITHUB_TOKEN: ${{ secrets.GH_PAT_BOT }}
-      with:
-        filename: .github/ss58-check.md
-        update_existing: true

.github/workflows/stale.yml

@@ -6,8 +6,10 @@ on:
 jobs:
   stale:
     runs-on: ubuntu-latest
+    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,11 +1,12 @@
 --test-*
 _book/
 build/
-build-docs/
+build-*/
 coverage/
-docs/.vuepress/dist/
 node_modules/
 tmp/
+/import_map.json
+/mod.ts
 .DS_Store
 .env.local
 .env.development.local
@@ -24,6 +25,4 @@ npm-debug.log*
 package-lock.json
 yarn-debug.log*
 yarn-error.log*
-store.db
-store.db.compacted
 tsconfig.*buildinfo

.yarnrc.yml

@@ -10,4 +10,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
     spec: "@yarnpkg/plugin-version"
 
-yarnPath: .yarn/releases/yarn-3.1.1.cjs
+yarnPath: .yarn/releases/yarn-3.2.0.cjs

CHANGELOG.md

@@ -1,5 +1,348 @@
 # CHANGELOG
 
+## 10.2.1 Dec 4, 2022
+
+Contributed:
+
+- Ledger support for Ajuna (Thanks to https://github.com/carlosala)
+
+Changes:
+
+- `has{Buffer, Process}` now checks on `globalThis` (helps bundlers with auto-injection)
+- Add `/*#__PURE__*/` annotations for specific `export const something = someFunction(...)`
+- Upgrade dependencies to latest stable versions
+- Upgrade to `@polkadot/wasm-crypto` 6.4.1
+
+
+## 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:
+
+- Update Bifrost genesisHash (Thanks to https://github.com/awesomepan)
+- Add Ledger support for Composable (Thanks to https://github.com/carlosala)
+
+Changes:
+
+- Add `u8aToNumber` (limited, <= 48 bits) function
+- Use `~~` as bitwise/faster `Math.floor` replacement
+- Remove unneeded `objectSpread` option expansions
+- Optimize `hexToU8a` operations
+- Optimize `stringCamelCase` operations
+- Optimize `u8aToBn` operations
+- Additional internal/external comments (as missing)
+- Upgrade dependencies to latest stable versions
+
+
+## 9.4.1 Jun 4, 2022
+
+Changes:
+
+- Add `nextTick` to `@polkadot/util` to defer execution to the queue
+- Upgrade dependencies to latest stable versions
+
+
+## 9.3.1 May 29, 2022
+
+Contributed:
+
+- Add Ledger support for Parallel (Thanks to https://github.com/carlosala)
+- Add Ledger support for Astar & Polkadex (Thanks to https://github.com/carlosala)
+
+Changes:
+
+- Adjust `u8aToU8a` checks with better `isU8a` shortcut
+- Adjust compact conversion with unrolled loops
+- Adjust `string{Camel, Pascal}Case` with loop (no map)
+- Add `compactFromU8aLim` variant with Uint8Array-only inputs
+- Add `u8aConcatStrict` variant with Uint8Array-only inputs
+- Internal code maintainability enhancements
+- Upgrade dependencies to latest stable versions
+
+
+## 9.2.1 May 13, 2022
+
+Contributed:
+
+- Add Ledger support for Acala (Thanks to https://github.com/ntduan)
+
+Changes:
+
+- Optimize `u8aToHex` with direct (non-hex) conversion
+- Change all occurences of `.substr(...)` to `.substring(...)`
+- Sync with upstream Substrate ss58 registry
+- Mark deprecated function signatures (no removals)
+- Re-enable auto init of `cryptoWaitReady()`
+- Upgrade to `@polkadot/wasm-crypto` 6.1.1
+
+
+## 9.1.1 Apr 30, 2022
+
+Contributed:
+
+- Add Ledger support for Statemint (Thanks to https://github.com/carlosala)
+- Add Ledger support for xxnetwork (Thanks to https://github.com/xx-labs)
+
+Changes:
+
+- Adjust/dedupe output from `detectPackage`
+- Adjust `isHex` performance test
+- Add field-level comments to some `*Options` structures
+- Add new Rococo genesisHash (reset)
+
+
+## 9.0.1 Apr 9, 2022
+
+- **Breaking change** In this major version the commonjs outputs are moved to a sub-folder. Since the export map and main field in package.json does reflect this change, there should be no usage changes. However the packages here will all need to be on the same version for internal linkage.
+
+Changes:
+
+- Be explicit in `@polkadot/util-crypto` re-exports from `@polkadot/networks`
+- Output commonjs files under the `cjs/**` root
+- Upgrade to `@polkadot/wasm-crypto` 6.0.1
+
+
+## 8.7.1 Mar 27, 2022
+
+Changes:
+
+- Fix race-condition with wasm overrides, make `cryptoWaitReady` lazy
+- Additional tests for `BN` & `BigInt` negative conversions
+- Upgrade to `@polkadot/wasm-crypto` 5.1.1
+
+
+## 8.6.1 Mar 19, 2022
+
+**Important** This contains an upgraded version of `@polkadot/wasm-crypto`. For users of asm.js, e.g. React Native, there are some additional upgrade instructions in the release notes for this version https://github.com/polkadot-js/wasm/releases/tag/v5.0.1
+
+Contributed:
+
+- Add aditional Dock mainnet genesis (Thanks to https://github.com/lovesh)
+- Add Westend genesis (Thanks to https://github.com/Nick-1979)
+- Update README with ss58 links (Thanks to https://github.com/Nick-197)
+
+Changes:
+
+- Ensure invalid secp256k1 publicKeys are not returned
+- Cater for Expo v41+ in RN random value generation
+- Fixed for RN environment imports
+- Internal split of details in `@polkadot/networks`
+- Additional workaround for Vite bundling
+- Upgrade to `@polkadot/wasm-crypto` 5.0.1
+
+
+## 8.5.1 Mar 12, 2022
+
+Changes:
+
+- Adjust for bundlers where `import.meta.url` is undefined
+- Upgrade dependencies to latest stable versions
+
+
+## 8.4.1 Feb 14, 2022
+
+Changes:
+
+- Use upstream `@substrate/ss58-registry` (instead of duplicating here)
+- Swap `micro-base` to `@scure/base` (same package, audited)
+- Bump `bn.js` library to latest 5.2.0 (has impact on e.g. API)
+- Upgrade dependencies to latest stable versions
+
+
+## 8.3.3 Jan 23, 2022
+
+Changes:
+
+- Sync with upstream Substrate ss58 registry
+
+
 ## 8.3.2 Jan 15, 2022
 
 Changes:

CONTRIBUTORS

@@ -1,16 +1,19 @@
-    1241	Jaco                          	8.3.2 (#1382)
+    1492	Jaco                          	10.2.1 (#1687)
+      10	Carlo Sala                    	feat(networks): support ledger for ajuna  (#1682)
        9	Antoine Estienne              	Add eth uri keyring test (#1291)
        6	Amaury Martiny                	Add tests from Rust (#283)
+       5	Jakub Pánik                   	Add HydraDX parachain to genesis (#1583)
        5	kwingram25                    	Add BN consts and timeToString (#610)
        4	Adam Dossa                    	Update Polymesh Genesis Hash (#1193)
-       3	Jakub Pánik                   	HydraDX Snakenet Gen3-1 (#977)
+       4	pan                           	add bifrost kusama (#1626)
        3	Luke Schoen                   	docs: Fix example in readme since we use default imports (#243)
        2	AndreasGassmann               	feat(dependencies): remove moment.js (#530)
        2	Gav Wood                      	Fix stake:unstake (#182)
        2	Hyungsuk Kang                 	Add cross client Encryption/Decryption (#496)
        2	Jared Norris                  	Add Sora network (#1306)
+       2	Kami                          	Adding Westend genesis. (#1429)
+       2	Lovesh Harchandani            	Update genesis hash of Dock mainnet (#1436)
        2	Nantian                       	fix bigint type (#1079)
-       2	pan                           	add bifrost (#1296)
        2	Stefanie Doll                 	Add missing dependencies to util-crypto (#424)
        1	Agustinus Theodorus           	docs: fix typo in naclSeal docs. (#1005)
        1	Alexander Krupenkin           	Added ECDSA keypair support (#589)
@@ -18,19 +21,23 @@
        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)
        1	Hussein Ait-Lahcen            	Add Picasso Genesis Hash (#1261)
        1	Igor                          	Support genshiro network (#1148)
        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	Lovesh Harchandani            	Add Dock network id for address generation (#640)
        1	Mario Neises                  	remove redudant export (#257)
        1	Miguel Hervas                 	Add CFG Ledger Support (#1057)
        1	nahuseyoum                    	Reserving 65 for Aventus based on the new extended range (#871)
+       1	Nantian                       	add acala ledger config (#1485)
        1	qwer951123                    	Add acala genesis (#1161)
        1	Raoul Millais                 	Fix yarn add instructions in x-global README (#873)
        1	Raymond Zhong                 	Add Edgeware ledger app (#1006)
@@ -42,4 +49,5 @@
        1	Tore19                        	Add stafi genesis hash (#1096)
        1	Wei Tang                      	ss58: add Kulupu prefix to the list (#595)
        1	WoeOm                         	Handing high precision scenes (#450)
+       1	xx network                    	Add xxnetwork genesis hash and ledger app (#1463)
        1	Yuri                          	Extra check for process for browser bundles (#923)

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

@@ -2,37 +2,42 @@
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common#readme",
-  "license": "Apache-2",
-  "packageManager": "yarn@3.0.1",
+  "license": "Apache-2.0",
+  "packageManager": "yarn@3.2.0",
   "private": true,
   "repository": {
     "type": "git",
     "url": "https://github.com/polkadot-js/common.git"
   },
   "sideEffects": false,
-  "version": "8.3.2",
+  "type": "module",
+  "version": "10.2.1",
+  "versions": {
+    "git": "10.2.1",
+    "npm": "10.2.1"
+  },
   "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",
-    "networks:sync": "yarn build && node packages/networks/scripts/fromSubstrate.mjs",
     "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.16.7",
-    "@polkadot/dev": "^0.65.37",
-    "@types/jest": "^27.4.0"
+    "@babel/core": "^7.20.5",
+    "@polkadot/dev": "^0.67.167",
+    "@types/jest": "^29.2.3"
   },
   "resolutions": {
-    "typescript": "^4.5.3"
+    "typescript": "^4.9.3"
   }
 }

packages/hw-ledger-transports/package.json

@@ -16,18 +16,18 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "8.3.2",
+  "version": "10.2.1",
   "browser": "browser.js",
   "main": "node.js",
   "react-native": "react-native.js",
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "@ledgerhq/hw-transport": "^6.20.0",
-    "@ledgerhq/hw-transport-webhid": "^6.20.0",
-    "@ledgerhq/hw-transport-webusb": "^6.20.0",
-    "@polkadot/util": "8.3.2"
+    "@babel/runtime": "^7.20.6",
+    "@ledgerhq/hw-transport": "^6.27.8",
+    "@ledgerhq/hw-transport-webhid": "^6.27.8",
+    "@ledgerhq/hw-transport-webusb": "^6.27.8",
+    "@polkadot/util": "10.2.1"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.23.0"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.28.5"
   }
 }

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

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": "8.3.2",
+  "version": "10.2.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "@ledgerhq/hw-transport": "^6.20.0",
-    "@polkadot/hw-ledger-transports": "8.3.2",
-    "@polkadot/util": "8.3.2",
-    "@zondax/ledger-substrate": "^0.24.0"
+    "@babel/runtime": "^7.20.6",
+    "@ledgerhq/hw-transport": "^6.27.8",
+    "@polkadot/hw-ledger-transports": "10.2.1",
+    "@polkadot/util": "10.2.1",
+    "@zondax/ledger-substrate": "^0.40.2"
   }
 }

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,23 +1,39 @@
 // 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 { newBifrostApp, newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKusamaApp, newNodleApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStatemineApp } from '@zondax/ledger-substrate';
-
-// These match up with the keys of the knownLedger object in the @polkadot/networks/defaults.ts
-export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
-  bifrost: newBifrostApp,
-  centrifuge: newCentrifugeApp,
-  'dock-mainnet': newDockApp,
-  edgeware: newEdgewareApp,
-  equilibrium: newEquilibriumApp,
-  genshiro: newGenshiroApp,
-  kusama: newKusamaApp,
-  'nodle-chain': newNodleApp,
-  polkadot: newPolkadotApp,
-  polymesh: newPolymeshApp,
-  sora: newSoraApp,
-  statemine: newStatemineApp
+// These match up with the keys of the knownLedger object in the @polkadot/networks/defaults/ledger.ts
+// and maps to the known name in the @zondax/ledger-substrate/supported_apps package
+export const ledgerApps: Record<string, string> = {
+  acala: 'Acala',
+  ajuna: 'Ajuna',
+  '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: '8.3.2' };
+export const packageInfo = { name: '@polkadot/hw-ledger', path: 'auto', type: 'auto', version: '10.2.1' };

packages/hw-ledger/src/types.ts

@@ -6,22 +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;
-  publicKey: 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;
-  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": "8.3.2",
+  "version": "10.2.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "@polkadot/util": "8.3.2",
-    "@polkadot/util-crypto": "8.3.2"
+    "@babel/runtime": "^7.20.6",
+    "@polkadot/util": "10.2.1",
+    "@polkadot/util-crypto": "10.2.1"
   },
   "peerDependencies": {
-    "@polkadot/util": "8.3.2",
-    "@polkadot/util-crypto": "8.3.2"
+    "@polkadot/util": "10.2.1",
+    "@polkadot/util-crypto": "10.2.1"
   }
 }

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

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/testingPairs.spec.ts

@@ -65,7 +65,9 @@ describe('testingPairs', (): void => {
     delete ring.nobody;
 
     Object.keys(ring).forEach((testKeyring, i) => {
-      if (i < 6) { expect(u8aToHex(ring[testKeyring].publicKey)).toEqual(u8aToHex(keyring.createFromUri(privKeys[i]).publicKey)); }
+      if (i < 6) {
+        expect(u8aToHex(ring[testKeyring].publicKey)).toEqual(u8aToHex(keyring.createFromUri(privKeys[i]).publicKey));
+      }
     });
   });
 });

packages/keyring/src/types.ts

@@ -5,18 +5,29 @@ import type { HexString } from '@polkadot/util/types';
 import type { EncryptedJson, Keypair, KeypairType, Prefix } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
+  /**
+   * @description The ss58Format to use for address encoding (defaults to 42)
+   */
   ss58Format?: Prefix;
+  /**
+   * @description The type of keyring to create (defaults to ed25519)
+   */
   type?: KeypairType;
 }
 
 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;
 }
 
 export interface SignOptions {
+  /**
+   * @description Create a MultiSignature-compatible output with an indicator type
+   **/
   withType?: boolean;
 }
 

packages/networks/README.md

@@ -2,4 +2,4 @@
 
 A list of all available Substrate networks and their applicable prefixes.
 
-This list is periodically checked against the master list available at https://github.com/paritytech/substrate/blob/master/ss58-registry.json
+This list is periodically checked against the master list available at https://github.com/paritytech/ss58-registry/blob/main/ss58-registry.json

packages/networks/package.json

@@ -17,14 +17,14 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "8.3.2",
+  "version": "10.2.1",
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "@polkadot/util": "8.3.2"
+    "@babel/runtime": "^7.20.6",
+    "@polkadot/util": "10.2.1",
+    "@substrate/ss58-registry": "^1.35.0"
   },
   "devDependencies": {
-    "@polkadot/hw-ledger": "8.3.2",
-    "@polkadot/x-fetch": "8.3.2"
+    "@polkadot/hw-ledger": "10.2.1"
   }
 }

packages/networks/scripts/fromSubstrate.mjs

@@ -1,72 +0,0 @@
-// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import fs from 'fs';
-import fetch from 'node-fetch';
-
-import { substrateRegistry } from '../build/defaults.js';
-
-const substrateRegistryRepo = substrateRegistry
-  .replace('raw.githubusercontent.com', 'github.com')
-  .split('main')[0];
-
-function outputField (k, v) {
-  if (typeof v === 'string') {
-    return `'${v}'`;
-  } else if (Array.isArray(v)) {
-    // new format is [] to indicate optionality
-    return (['decimals', 'symbols'].includes(k) && !v.length)
-      ? null
-      : `[${v.map((v) => outputField(k, v)).join(', ')}]`;
-  }
-
-  return v;
-}
-
-async function getSubstrateRegistry () {
-  const original = await fetch(substrateRegistry);
-  const json = await original.json();
-
-  return json.registry
-    .map((e) =>
-      `  {\n${Object
-        .entries(e)
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `    ${k}: ${outputField(k, v)}`)
-        .join(',\n')}\n  }`
-    )
-    .join(',\n');
-}
-
-getSubstrateRegistry()
-  .then((entries) => {
-    fs.writeFileSync('packages/networks/src/substrate.ts', `// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-//
-// Auto-generated by yarn networks:sync (via scripts/fromSubstrate.mjs)
-//
-// This file should never be edited manually. Rather the process is as follow -
-//
-//   - make a PR to the upstream registry found at ${substrateRegistryRepo}
-//   - ensure the PR gets merged
-//   - yarn networks:sync in this repo to sync
-//
-// Any manual changes to this file will make CI cron checks fail and will be
-// lost when the registry is updated alongside the above sync.
-//
-
-import type { KnownSubstrate } from './types';
-
-export const knownSubstrate: KnownSubstrate[] = [\n${entries}\n];
-`);
-
-    console.log('Completed.');
-
-    process.exit(0);
-  })
-  .catch((error) => {
-    console.error('Error:', error.message);
-
-    process.exit(-1);
-  });

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 { substrateRegistry } from './defaults';
-import { allNetworks } from './';
-
-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(substrateRegistry)).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.ts

@@ -1,48 +0,0 @@
-// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { KnownIcon, KnownLedger, KnownTestnet } from './types';
-
-export { knownGenesis } from './genesis';
-
-export const substrateRegistry = 'https://raw.githubusercontent.com/paritytech/ss58-registry/main/ss58-registry.json';
-
-// these are icon overrides
-export const knownIcon: KnownIcon = {
-  centrifuge: 'polkadot',
-  kusama: 'polkadot',
-  polkadot: 'polkadot',
-  sora: 'polkadot',
-  statemine: 'polkadot',
-  statemint: 'polkadot',
-  westmint: 'polkadot'
-};
-
-// These match up with the keys of the ledgerApps object in the @polkadot/hw-ledger/defaults.ts
-// and maps to the known slip44 (minus the `0x8` hard derivation flag)
-// NOTE: Any network here needs to have a genesisHash attached in the config above
-export const knownLedger: KnownLedger = {
-  bifrost: 0x00000314,
-  centrifuge: 0x000002eb,
-  'dock-mainnet': 0x00000252,
-  edgeware: 0x0000020b,
-  equilibrium: 0x05f5e0fd,
-  genshiro: 0x05f5e0fc,
-  kusama: 0x000001b2,
-  'nodle-chain': 0x000003eb,
-  polkadot: 0x00000162,
-  polymesh: 0x00000253,
-  sora: 0x00000269,
-  statemine: 0x000001b2 // common-good on Kusama, shares derivation
-};
-
-// testnets should not allow selection
-export const knownTestnet: KnownTestnet = {
-  '': true, // this is the default non-network entry
-  'cess-testnet': true,
-  'dock-testnet': true,
-  jupiter: true,
-  'mathchain-testnet': true,
-  subspace_testnet: true,
-  'zero-alphaville': true
-};

packages/networks/src/defaults/genesis.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { KnownGenesis } from './types';
+import type { KnownGenesis } from '../types';
 
 // NOTE: In the case where the network was hard-spooned and multiple genesisHashes
 // are provided, it needs to be in reverse order, i.e. most-recent first, oldest
@@ -11,13 +11,36 @@ export const knownGenesis: KnownGenesis = {
   acala: [
     '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
   ],
+  ajuna: [
+    '0xe358eb1d11b31255a286c12e44fe6780b7edb171d657905a97e39f71d9c6c3ee'
+  ],
+  'aleph-node': [
+    '0x70255b4d28de0fc4e1a193d7e175ad1ccef431598211c55538f1018651a0344e'
+  ],
+  astar: [
+    '0x9eb76c5184c4ab8679d2d5d819fdf90b9c001403e9e17da2e14b6d8aec4029c6'
+  ],
+  basilisk: [
+    '0xa85cfb9b9fd4d622a5b28289a02347af987d8f73fa3108450e2b4a11c1ce5755'
+  ],
   bifrost: [
+    '0x262e1b2ad728475fd6fe88e62d34c200abe6fd693931ddad144059b1eb884e5b'
+  ],
+  'bifrost-kusama': [
     '0x9f28c6a68e0fc9646eff64935684f6eeeece527e37bbe1f213d22caa1d9d6bed'
   ],
   centrifuge: [
+    '0xb3db41421702df9a7fcac62b53ffeac85f7853cc4e689e0b93aeb3db18c09d82',
     '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
   ],
+  composable: [
+    '0xdaab8df776eb52ec604a5df5d388bb62a050a0aaec4556a64265b9d42755552d'
+  ],
+  darwinia: [
+    '0xe71578b37a7c799b0ab4ee87ffa6f059a6b98f71f06fb8c84a8d88013a548ad6'
+  ],
   'dock-mainnet': [
+    '0x6bfe24dca2a3be10f22212678ac13a6446ec764103c0f3471c71609eac384aae',
     '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
   ],
   edgeware: [
@@ -30,14 +53,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'
   ],
@@ -46,14 +76,23 @@ export const knownGenesis: KnownGenesis = {
     '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
     '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
   ],
-  'nodle-chain': [
-    '0xa3d114c2b8d0627c1aa9b134eafcf7d05ca561fdc19fb388bb9457f81809fb23'
+  'nodle-para': [
+    '0x97da7ede98d7bad4e36b4d734b6055425a3be036da2a332ea5a7037656427a21'
+  ],
+  origintrail: [
+    '0xe7e0962324a3b86c83404dbea483f25fb5dab4c224791c81b756cfc948006174'
+  ],
+  parallel: [
+    '0xe61a41c53f5dcd0beb09df93b34402aada44cb05117b71059cce40a2723a4e97'
+  ],
+  phala: [
+    '0x1bb969d85965e4bb5a651abbedf21a54b6b31a21f66b5401cc3f1e286268d736'
   ],
   picasso: [
     '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
   ],
-  plasm: [
-    '0x3e86364d4b4894021cb2a0390bcf2feb5517d5292f2de2bb9404227e908b0b8b'
+  polkadex: [
+    '0x3920bcb4960a1eef5580cd5367ff3f430eef052774f78468852f7b9cb39f8a3c'
   ],
   polkadot: [
     '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
@@ -62,6 +101,8 @@ export const knownGenesis: KnownGenesis = {
     '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
   ],
   rococo: [
+    '0x6408de7737c59c238890533af25896a2c20608d8b380bb01029acb392781063e',
+    '0xaaf2cd1b74b5f726895921259421b534124726263982522174147046b8827897',
     '0x037f5f3c8e67b314062025fc886fcd6238ea25a4a9b45dce8d246815c9ebe770',
     '0xc196f81260cf1686172b47a79cf002120735d7cb0eb1474e8adce56618456fff',
     '0xf6e9983c37baf68846fedafe21e56718790e39fb1c582abc408b81bc7b208f9a',
@@ -82,7 +123,23 @@ export const knownGenesis: KnownGenesis = {
   statemine: [
     '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
   ],
+  statemint: [
+    '0x68d56f15f85d3136970ec16946040bc1752654e906147f7e43e9d539d7c3de2f'
+  ],
   subsocial: [
     '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
+  ],
+  unique: [
+    '0x84322d9cddbf35088f1e54e9a85c967a41a56a4f43445768125e61af166c7d31'
+  ],
+  vtb: [
+    '0x286bc8414c7000ce1d6ee6a834e29a54c1784814b76243eb77ed0b2c5573c60f',
+    '0x7483b89572fb2bd687c7b9a93b242d0b237f9aba463aba07ec24503931038aaa'
+  ],
+  westend: [
+    '0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e'
+  ],
+  xxnetwork: [
+    '0x50dd5d206917bf10502c68fb4d18a59fc8aa31586f4e8856b493e43544aa82aa'
   ]
 };

packages/networks/src/defaults/icons.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KnownIcon } from '../types';
+
+// these are icon overrides
+export const knownIcon: KnownIcon = {
+  centrifuge: 'polkadot',
+  kusama: 'polkadot',
+  polkadot: 'polkadot',
+  sora: 'polkadot',
+  statemine: 'polkadot',
+  statemint: 'polkadot',
+  westmint: 'polkadot'
+};

packages/networks/src/defaults/index.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { knownGenesis } from './genesis';
+export { knownIcon } from './icons';
+export { knownLedger } from './ledger';
+export { knownTestnet } from './testnets';

packages/networks/src/defaults/ledger.ts

@@ -0,0 +1,43 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KnownLedger } from '../types';
+
+// These match up with the keys of the ledgerApps object in the @polkadot/hw-ledger/defaults.ts
+// and maps to the known slip44 (minus the `0x8` hard derivation flag)
+//
+// NOTE: Any network here needs to have a genesisHash attached in the ./genesis.ts config
+export const knownLedger: KnownLedger = {
+  acala: 0x00000313,
+  ajuna: 0x00000162,
+  '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

@@ -0,0 +1,16 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KnownTestnet } from '../types';
+
+// testnets should not allow selection
+export const knownTestnet: KnownTestnet = {
+  '': true, // this is the default non-network entry
+  'cess-testnet': true,
+  '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');
   });
@@ -67,6 +67,26 @@ describe('availableNetworks', (): void => {
       )
     ).toEqual([]);
   });
+
+  it('has all the correct fields', (): void => {
+    expect(availableNetworks[0]).toEqual({
+      decimals: [10],
+      displayName: 'Polkadot Relay Chain',
+      genesisHash: [
+        '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+      ],
+      hasLedgerSupport: true,
+      icon: 'polkadot',
+      isIgnored: false,
+      isTestnet: false,
+      network: 'polkadot',
+      prefix: 0,
+      slip44: 354,
+      standardAccount: '*25519',
+      symbols: ['DOT'],
+      website: 'https://polkadot.network'
+    });
+  });
 });
 
 describe('allNetworks', (): void => {
@@ -93,6 +113,6 @@ describe('selectableNetworks', (): void => {
 
   it('has a sorted list (first external, last external)', (): void => {
     expect(selectableNetworks[3].displayName).toEqual('Acala');
-    expect(selectableNetworks[selectableNetworks.length - 1].displayName).toEqual('Stafi');
+    expect(selectableNetworks[selectableNetworks.length - 1].displayName).toEqual('xx network');
   });
 });

packages/networks/src/index.ts

@@ -1,5 +1,9 @@
 // Copyright 2017-2022 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+// TODO: This was removed, really cannot recall the reason...
+// ... put it back, but keep it removed
+// import './detectPackage';
+
 export * from './interfaces';
 export { packageInfo } from './packageInfo';

packages/networks/src/interfaces.ts

@@ -3,8 +3,9 @@
 
 import type { KnownSubstrate, Network, SubstrateNetwork } from './types';
 
+import knownSubstrate from '@substrate/ss58-registry';
+
 import { knownGenesis, knownIcon, knownLedger, knownTestnet } from './defaults';
-import { knownSubstrate } from './substrate';
 
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
@@ -25,7 +26,14 @@ function toExpanded (o: KnownSubstrate): SubstrateNetwork {
 
   // filtering
   n.isTestnet = !!knownTestnet[network] || TESTNETS.includes(nameParts[nameParts.length - 1]);
-  n.isIgnored = n.isTestnet || (!(o.standardAccount && o.decimals && o.symbols) && o.prefix !== 42);
+  n.isIgnored = n.isTestnet || (
+    !(
+      o.standardAccount &&
+      o.decimals && o.decimals.length &&
+      o.symbols && o.symbols.length
+    ) &&
+    o.prefix !== 42
+  );
 
   return n;
 }

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

packages/networks/src/ss58registry.spec.ts

@@ -0,0 +1,26 @@
+// Copyright 2017-2022 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import known from '@substrate/ss58-registry';
+import fs from 'fs';
+import path from 'path';
+
+import other from './test/ss58registry.test.json';
+
+describe('@substrate/ss58-registry', (): void => {
+  it('has known values', (): void => {
+    const json = JSON.stringify(known, null, 2);
+
+    try {
+      expect(JSON.parse(json)).toEqual(other);
+    } catch (error) {
+      if (process.env.GITHUB_REPOSITORY) {
+        console.error(json);
+
+        throw error;
+      }
+
+      fs.writeFileSync(path.join(__dirname, './test/ss58registry.test.json'), json, { flag: 'w' });
+    }
+  });
+});

packages/networks/src/substrate.ts

@@ -1,794 +0,0 @@
-// Copyright 2017-2022 @polkadot/networks authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-//
-// Auto-generated by yarn networks:sync (via scripts/fromSubstrate.mjs)
-//
-// This file should never be edited manually. Rather the process is as follow -
-//
-//   - make a PR to the upstream registry found at https://github.com/paritytech/ss58-registry/
-//   - ensure the PR gets merged
-//   - yarn networks:sync in this repo to sync
-//
-// Any manual changes to this file will make CI cron checks fail and will be
-// lost when the registry is updated alongside the above sync.
-//
-
-import type { KnownSubstrate } from './types';
-
-export const knownSubstrate: KnownSubstrate[] = [
-  {
-    decimals: [10],
-    displayName: 'Polkadot Relay Chain',
-    network: 'polkadot',
-    prefix: 0,
-    standardAccount: '*25519',
-    symbols: ['DOT'],
-    website: 'https://polkadot.network'
-  },
-  {
-    decimals: null,
-    displayName: 'Bare 32-bit Schnorr/Ristretto (S/R 25519) public key.',
-    network: 'BareSr25519',
-    prefix: 1,
-    standardAccount: 'Sr25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [12],
-    displayName: 'Kusama Relay Chain',
-    network: 'kusama',
-    prefix: 2,
-    standardAccount: '*25519',
-    symbols: ['KSM'],
-    website: 'https://kusama.network'
-  },
-  {
-    decimals: null,
-    displayName: 'Bare 32-bit Ed25519 public key.',
-    network: 'BareEd25519',
-    prefix: 3,
-    standardAccount: 'Ed25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: null,
-    displayName: 'Katal Chain',
-    network: 'katalchain',
-    prefix: 4,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [18],
-    displayName: 'Astar Network',
-    network: 'astar',
-    prefix: 5,
-    standardAccount: '*25519',
-    symbols: ['ASTR'],
-    website: 'https://astar.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Bifrost',
-    network: 'bifrost',
-    prefix: 6,
-    standardAccount: '*25519',
-    symbols: ['BNC'],
-    website: 'https://bifrost.finance/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Edgeware',
-    network: 'edgeware',
-    prefix: 7,
-    standardAccount: '*25519',
-    symbols: ['EDG'],
-    website: 'https://edgewa.re'
-  },
-  {
-    decimals: [12],
-    displayName: 'Karura',
-    network: 'karura',
-    prefix: 8,
-    standardAccount: '*25519',
-    symbols: ['KAR'],
-    website: 'https://karura.network/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Laminar Reynolds Canary',
-    network: 'reynolds',
-    prefix: 9,
-    standardAccount: '*25519',
-    symbols: ['REY'],
-    website: 'http://laminar.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Acala',
-    network: 'acala',
-    prefix: 10,
-    standardAccount: '*25519',
-    symbols: ['ACA'],
-    website: 'https://acala.network/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Laminar',
-    network: 'laminar',
-    prefix: 11,
-    standardAccount: '*25519',
-    symbols: ['LAMI'],
-    website: 'http://laminar.network/'
-  },
-  {
-    decimals: [6],
-    displayName: 'Polymesh',
-    network: 'polymesh',
-    prefix: 12,
-    standardAccount: '*25519',
-    symbols: ['POLYX'],
-    website: 'https://polymath.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Integritee',
-    network: 'integritee',
-    prefix: 13,
-    standardAccount: '*25519',
-    symbols: ['TEER'],
-    website: 'https://integritee.network'
-  },
-  {
-    decimals: [0],
-    displayName: 'Totem',
-    network: 'totem',
-    prefix: 14,
-    standardAccount: '*25519',
-    symbols: ['TOTEM'],
-    website: 'https://totemaccounting.com'
-  },
-  {
-    decimals: [12],
-    displayName: 'Synesthesia',
-    network: 'synesthesia',
-    prefix: 15,
-    standardAccount: '*25519',
-    symbols: ['SYN'],
-    website: 'https://synesthesia.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Kulupu',
-    network: 'kulupu',
-    prefix: 16,
-    standardAccount: '*25519',
-    symbols: ['KLP'],
-    website: 'https://kulupu.network/'
-  },
-  {
-    decimals: null,
-    displayName: 'Dark Mainnet',
-    network: 'dark',
-    prefix: 17,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [9, 9],
-    displayName: 'Darwinia Network',
-    network: 'darwinia',
-    prefix: 18,
-    standardAccount: '*25519',
-    symbols: ['RING', 'KTON'],
-    website: 'https://darwinia.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'GeekCash',
-    network: 'geek',
-    prefix: 19,
-    standardAccount: '*25519',
-    symbols: ['GEEK'],
-    website: 'https://geekcash.org'
-  },
-  {
-    decimals: [12],
-    displayName: 'Stafi',
-    network: 'stafi',
-    prefix: 20,
-    standardAccount: '*25519',
-    symbols: ['FIS'],
-    website: 'https://stafi.io'
-  },
-  {
-    decimals: [6],
-    displayName: 'Dock Testnet',
-    network: 'dock-testnet',
-    prefix: 21,
-    standardAccount: '*25519',
-    symbols: ['DCK'],
-    website: 'https://dock.io'
-  },
-  {
-    decimals: [6],
-    displayName: 'Dock Mainnet',
-    network: 'dock-mainnet',
-    prefix: 22,
-    standardAccount: '*25519',
-    symbols: ['DCK'],
-    website: 'https://dock.io'
-  },
-  {
-    decimals: null,
-    displayName: 'ShiftNrg',
-    network: 'shift',
-    prefix: 23,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [18],
-    displayName: 'ZERO',
-    network: 'zero',
-    prefix: 24,
-    standardAccount: '*25519',
-    symbols: ['PLAY'],
-    website: 'https://zero.io'
-  },
-  {
-    decimals: [18],
-    displayName: 'ZERO Alphaville',
-    network: 'zero-alphaville',
-    prefix: 25,
-    standardAccount: '*25519',
-    symbols: ['PLAY'],
-    website: 'https://zero.io'
-  },
-  {
-    decimals: [10],
-    displayName: 'Jupiter',
-    network: 'jupiter',
-    prefix: 26,
-    standardAccount: '*25519',
-    symbols: ['jDOT'],
-    website: 'https://jupiter.patract.io'
-  },
-  {
-    decimals: null,
-    displayName: 'Subsocial',
-    network: 'subsocial',
-    prefix: 28,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [12, 12],
-    displayName: 'CORD Network',
-    network: 'cord',
-    prefix: 29,
-    standardAccount: '*25519',
-    symbols: ['DHI', 'WAY'],
-    website: 'https://cord.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Phala Network',
-    network: 'phala',
-    prefix: 30,
-    standardAccount: '*25519',
-    symbols: ['PHA'],
-    website: 'https://phala.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Litentry Network',
-    network: 'litentry',
-    prefix: 31,
-    standardAccount: '*25519',
-    symbols: ['LIT'],
-    website: 'https://litentry.com/'
-  },
-  {
-    decimals: [9],
-    displayName: 'Robonomics',
-    network: 'robonomics',
-    prefix: 32,
-    standardAccount: '*25519',
-    symbols: ['XRT'],
-    website: 'https://robonomics.network'
-  },
-  {
-    decimals: null,
-    displayName: 'DataHighway',
-    network: 'datahighway',
-    prefix: 33,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [12],
-    displayName: 'Ares Protocol',
-    network: 'ares',
-    prefix: 34,
-    standardAccount: '*25519',
-    symbols: ['ARES'],
-    website: 'https://www.aresprotocol.com/'
-  },
-  {
-    decimals: [15],
-    displayName: 'Valiu Liquidity Network',
-    network: 'vln',
-    prefix: 35,
-    standardAccount: '*25519',
-    symbols: ['USDv'],
-    website: 'https://valiu.com/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Centrifuge Chain',
-    network: 'centrifuge',
-    prefix: 36,
-    standardAccount: '*25519',
-    symbols: ['CFG'],
-    website: 'https://centrifuge.io/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Nodle Chain',
-    network: 'nodle',
-    prefix: 37,
-    standardAccount: '*25519',
-    symbols: ['NODL'],
-    website: 'https://nodle.io/'
-  },
-  {
-    decimals: [18],
-    displayName: 'KILT Chain',
-    network: 'kilt',
-    prefix: 38,
-    standardAccount: '*25519',
-    symbols: ['KILT'],
-    website: 'https://kilt.io/'
-  },
-  {
-    decimals: [18],
-    displayName: 'MathChain mainnet',
-    network: 'mathchain',
-    prefix: 39,
-    standardAccount: '*25519',
-    symbols: ['MATH'],
-    website: 'https://mathwallet.org'
-  },
-  {
-    decimals: [18],
-    displayName: 'MathChain testnet',
-    network: 'mathchain-testnet',
-    prefix: 40,
-    standardAccount: '*25519',
-    symbols: ['MATH'],
-    website: 'https://mathwallet.org'
-  },
-  {
-    decimals: null,
-    displayName: 'Polimec Chain',
-    network: 'poli',
-    prefix: 41,
-    standardAccount: '*25519',
-    symbols: null,
-    website: 'https://polimec.io/'
-  },
-  {
-    decimals: null,
-    displayName: 'Substrate',
-    network: 'substrate',
-    prefix: 42,
-    standardAccount: '*25519',
-    symbols: null,
-    website: 'https://substrate.io/'
-  },
-  {
-    decimals: null,
-    displayName: 'Bare 32-bit ECDSA SECP-256k1 public key.',
-    network: 'BareSecp256k1',
-    prefix: 43,
-    standardAccount: 'secp256k1',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [8],
-    displayName: 'ChainX',
-    network: 'chainx',
-    prefix: 44,
-    standardAccount: '*25519',
-    symbols: ['PCX'],
-    website: 'https://chainx.org/'
-  },
-  {
-    decimals: [12, 12],
-    displayName: 'UniArts Network',
-    network: 'uniarts',
-    prefix: 45,
-    standardAccount: '*25519',
-    symbols: ['UART', 'UINK'],
-    website: 'https://uniarts.me'
-  },
-  {
-    decimals: null,
-    displayName: 'This prefix is reserved.',
-    network: 'reserved46',
-    prefix: 46,
-    standardAccount: null,
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: null,
-    displayName: 'This prefix is reserved.',
-    network: 'reserved47',
-    prefix: 47,
-    standardAccount: null,
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [12],
-    displayName: 'Neatcoin Mainnet',
-    network: 'neatcoin',
-    prefix: 48,
-    standardAccount: '*25519',
-    symbols: ['NEAT'],
-    website: 'https://neatcoin.org'
-  },
-  {
-    decimals: [12],
-    displayName: 'Picasso',
-    network: 'picasso',
-    prefix: 49,
-    standardAccount: '*25519',
-    symbols: ['PICA'],
-    website: 'https://picasso.composable.finance'
-  },
-  {
-    decimals: [12],
-    displayName: 'Composable',
-    network: 'composable',
-    prefix: 50,
-    standardAccount: '*25519',
-    symbols: ['LAYR'],
-    website: 'https://composable.finance'
-  },
-  {
-    decimals: [9],
-    displayName: 'xx network',
-    network: 'xxnetwork',
-    prefix: 55,
-    standardAccount: '*25519',
-    symbols: ['XX'],
-    website: 'https://xx.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'HydraDX',
-    network: 'hydradx',
-    prefix: 63,
-    standardAccount: '*25519',
-    symbols: ['HDX'],
-    website: 'https://hydradx.io'
-  },
-  {
-    decimals: [18],
-    displayName: 'AvN Mainnet',
-    network: 'aventus',
-    prefix: 65,
-    standardAccount: '*25519',
-    symbols: ['AVT'],
-    website: 'https://aventus.io'
-  },
-  {
-    decimals: [12],
-    displayName: 'Crust Network',
-    network: 'crust',
-    prefix: 66,
-    standardAccount: '*25519',
-    symbols: ['CRU'],
-    website: 'https://crust.network'
-  },
-  {
-    decimals: [9, 9, 9],
-    displayName: 'Genshiro Network',
-    network: 'genshiro',
-    prefix: 67,
-    standardAccount: '*25519',
-    symbols: ['GENS', 'EQD', 'LPT0'],
-    website: 'https://genshiro.equilibrium.io'
-  },
-  {
-    decimals: [9],
-    displayName: 'Equilibrium Network',
-    network: 'equilibrium',
-    prefix: 68,
-    standardAccount: '*25519',
-    symbols: ['EQ'],
-    website: 'https://equilibrium.io'
-  },
-  {
-    decimals: [18],
-    displayName: 'SORA Network',
-    network: 'sora',
-    prefix: 69,
-    standardAccount: '*25519',
-    symbols: ['XOR'],
-    website: 'https://sora.org'
-  },
-  {
-    decimals: [10],
-    displayName: 'Zeitgeist',
-    network: 'zeitgeist',
-    prefix: 73,
-    standardAccount: '*25519',
-    symbols: ['ZTG'],
-    website: 'https://zeitgeist.pm'
-  },
-  {
-    decimals: [18],
-    displayName: 'Manta network',
-    network: 'manta',
-    prefix: 77,
-    standardAccount: '*25519',
-    symbols: ['MANTA'],
-    website: 'https://manta.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Calamari: Manta Canary Network',
-    network: 'calamari',
-    prefix: 78,
-    standardAccount: '*25519',
-    symbols: ['KMA'],
-    website: 'https://manta.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Polkadex Mainnet',
-    network: 'polkadex',
-    prefix: 88,
-    standardAccount: '*25519',
-    symbols: ['PDEX'],
-    website: 'https://polkadex.trade'
-  },
-  {
-    decimals: [18],
-    displayName: 'PolkaSmith Canary Network',
-    network: 'polkasmith',
-    prefix: 98,
-    standardAccount: '*25519',
-    symbols: ['PKS'],
-    website: 'https://polkafoundry.com'
-  },
-  {
-    decimals: [18],
-    displayName: 'PolkaFoundry Network',
-    network: 'polkafoundry',
-    prefix: 99,
-    standardAccount: '*25519',
-    symbols: ['PKF'],
-    website: 'https://polkafoundry.com'
-  },
-  {
-    decimals: [18],
-    displayName: 'OriginTrail Parachain',
-    network: 'origintrail-parachain',
-    prefix: 101,
-    standardAccount: 'secp256k1',
-    symbols: ['TRAC'],
-    website: 'https://origintrail.io'
-  },
-  {
-    decimals: [10],
-    displayName: 'Pontem Network',
-    network: 'pontem-network',
-    prefix: 105,
-    standardAccount: '*25519',
-    symbols: ['PONT'],
-    website: 'https://pontem.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Heiko',
-    network: 'heiko',
-    prefix: 110,
-    standardAccount: '*25519',
-    symbols: ['HKO'],
-    website: 'https://parallel.fi/'
-  },
-  {
-    decimals: null,
-    displayName: 'Integritee Incognito',
-    network: 'integritee-incognito',
-    prefix: 113,
-    standardAccount: '*25519',
-    symbols: null,
-    website: 'https://integritee.network'
-  },
-  {
-    decimals: [18],
-    displayName: 'Clover Finance',
-    network: 'clover',
-    prefix: 128,
-    standardAccount: '*25519',
-    symbols: ['CLV'],
-    website: 'https://clover.finance'
-  },
-  {
-    decimals: [18],
-    displayName: 'Altair',
-    network: 'altair',
-    prefix: 136,
-    standardAccount: '*25519',
-    symbols: ['AIR'],
-    website: 'https://centrifuge.io/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Parallel',
-    network: 'parallel',
-    prefix: 172,
-    standardAccount: '*25519',
-    symbols: ['PARA'],
-    website: 'https://parallel.fi/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Social Network',
-    network: 'social-network',
-    prefix: 252,
-    standardAccount: '*25519',
-    symbols: ['NET'],
-    website: 'https://social.network'
-  },
-  {
-    decimals: [15],
-    displayName: 'QUARTZ by UNIQUE',
-    network: 'quartz_mainnet',
-    prefix: 255,
-    standardAccount: '*25519',
-    symbols: ['QTZ'],
-    website: 'https://unique.network'
-  },
-  {
-    decimals: [18],
-    displayName: 'Pioneer Network by Bit.Country',
-    network: 'pioneer_network',
-    prefix: 268,
-    standardAccount: '*25519',
-    symbols: ['NEER'],
-    website: 'https://bit.country'
-  },
-  {
-    decimals: [18],
-    displayName: 'SORA Kusama Parachain',
-    network: 'sora_kusama_para',
-    prefix: 420,
-    standardAccount: '*25519',
-    symbols: ['XOR'],
-    website: 'https://sora.org'
-  },
-  {
-    decimals: [18],
-    displayName: 'Efinity',
-    network: 'efinity',
-    prefix: 1110,
-    standardAccount: 'Sr25519',
-    symbols: ['EFI'],
-    website: 'https://efinity.io/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Moonbeam',
-    network: 'moonbeam',
-    prefix: 1284,
-    standardAccount: 'secp256k1',
-    symbols: ['GLMR'],
-    website: 'https://moonbeam.network'
-  },
-  {
-    decimals: [18],
-    displayName: 'Moonriver',
-    network: 'moonriver',
-    prefix: 1285,
-    standardAccount: 'secp256k1',
-    symbols: ['MOVR'],
-    website: 'https://moonbeam.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Kapex',
-    network: 'kapex',
-    prefix: 2007,
-    standardAccount: '*25519',
-    symbols: ['KAPEX'],
-    website: 'https://totemaccounting.com'
-  },
-  {
-    decimals: [10],
-    displayName: 'Interlay',
-    network: 'interlay',
-    prefix: 2032,
-    standardAccount: '*25519',
-    symbols: ['INTR'],
-    website: 'https://interlay.io/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Kintsugi',
-    network: 'kintsugi',
-    prefix: 2092,
-    standardAccount: '*25519',
-    symbols: ['KINT'],
-    website: 'https://interlay.io/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Subspace testnet',
-    network: 'subspace_testnet',
-    prefix: 2254,
-    standardAccount: '*25519',
-    symbols: ['tSSC'],
-    website: 'https://subspace.network'
-  },
-  {
-    decimals: [18],
-    displayName: 'Subspace',
-    network: 'subspace',
-    prefix: 6094,
-    standardAccount: '*25519',
-    symbols: ['SSC'],
-    website: 'https://subspace.network'
-  },
-  {
-    decimals: [12],
-    displayName: 'Basilisk',
-    network: 'basilisk',
-    prefix: 10041,
-    standardAccount: '*25519',
-    symbols: ['BSX'],
-    website: 'https://bsx.fi'
-  },
-  {
-    decimals: [12],
-    displayName: 'CESS Testnet',
-    network: 'cess-testnet',
-    prefix: 11330,
-    standardAccount: '*25519',
-    symbols: ['TCESS'],
-    website: 'https://cess.cloud'
-  },
-  {
-    decimals: [12],
-    displayName: 'CESS',
-    network: 'cess',
-    prefix: 11331,
-    standardAccount: '*25519',
-    symbols: ['CESS'],
-    website: 'https://cess.cloud'
-  },
-  {
-    decimals: [18],
-    displayName: 'Automata ContextFree',
-    network: 'contextfree',
-    prefix: 11820,
-    standardAccount: '*25519',
-    symbols: ['CTX'],
-    website: 'https://ata.network'
-  }
-];

packages/networks/src/types.ts

@@ -1,17 +1,9 @@
 // Copyright 2017-2022 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate';
+import type { RegistryEntry } from '@substrate/ss58-registry';
 
-export interface KnownSubstrate {
-  decimals: number[] | null,
-  displayName: string;
-  network: string | null;
-  prefix: number;
-  standardAccount: '*25519' | 'Ed25519' | 'Sr25519' | 'secp256k1' | null;
-  symbols: string[] | null;
-  website: string | null;
-}
+export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate';
 
 export type KnownIcon = Record<string, Icon>;
 
@@ -19,6 +11,8 @@ export type KnownLedger = Record<string, number>;
 
 export type KnownGenesis = Record<string, string[]>;
 
+export type KnownSubstrate = RegistryEntry;
+
 export type KnownTestnet = Record<string, true>;
 
 export interface SubstrateNetwork extends KnownSubstrate {

packages/networks/tsconfig.build.json

@@ -3,11 +3,15 @@
   "compilerOptions": {
     "baseUrl": "..",
     "outDir": "./build",
+    "resolveJsonModule": true,
     "rootDir": "./src"
   },
+  "include": [
+    "**/src/**/*.ts",
+    "**/test/*.json"
+  ],
   "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

@@ -16,35 +16,35 @@
     "url": "https://github.com/polkadot-js/common.git"
   },
   "sideEffects": [
-    "./cryptoInit.js",
-    "./cryptoInit.cjs",
+    "./bundleInit.js",
+    "./bundleInit.cjs",
     "./detectPackage.js",
     "./detectPackage.cjs"
   ],
   "type": "module",
-  "version": "8.3.2",
+  "version": "10.2.1",
   "browser": {
     "crypto": false,
     "stream": false
   },
   "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "@noble/hashes": "0.5.7",
-    "@noble/secp256k1": "1.3.4",
-    "@polkadot/networks": "8.3.2",
-    "@polkadot/util": "8.3.2",
-    "@polkadot/wasm-crypto": "^4.5.1",
-    "@polkadot/x-bigint": "8.3.2",
-    "@polkadot/x-randomvalues": "8.3.2",
+    "@babel/runtime": "^7.20.6",
+    "@noble/hashes": "1.1.3",
+    "@noble/secp256k1": "1.7.0",
+    "@polkadot/networks": "10.2.1",
+    "@polkadot/util": "10.2.1",
+    "@polkadot/wasm-crypto": "^6.4.1",
+    "@polkadot/x-bigint": "10.2.1",
+    "@polkadot/x-randomvalues": "10.2.1",
+    "@scure/base": "1.1.1",
     "ed2curve": "^0.3.0",
-    "micro-base": "^0.10.2",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
     "@types/ed2curve": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "8.3.2"
+    "@polkadot/util": "10.2.1"
   }
 }

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

@@ -10,7 +10,5 @@ import { decodeAddress } from './decode';
  * @summary Converts an SS58 address to its corresponding EVM address.
  */
 export function addressToEvm (address: HexString | string | Uint8Array, ignoreChecksum?: boolean): Uint8Array {
-  const decoded = decodeAddress(address, ignoreChecksum);
-
-  return decoded.subarray(0, 20);
+  return decodeAddress(address, ignoreChecksum).subarray(0, 20);
 }

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/defaults.ts

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

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/address/setSS58Format.ts

@@ -14,7 +14,7 @@ const l = logger('setSS58Format');
  * @deprecated Use keyring.setSS58Format
  */
 export function setSS58Format (prefix: Prefix): void {
-  l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as pat of the address encode function');
+  l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as part of the address encode function');
 
   defaults.prefix = prefix;
 }

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { utils } from 'micro-base';
+import { utils } from '@scure/base';
 
 import { createDecode, createEncode, createIs, createValidate } from './helpers';
 
@@ -28,13 +28,13 @@ const config = {
  * @description
  * Validates that the supplied value is valid base32, throwing exceptions if not
  */
-export const base32Validate = createValidate(config);
+export const base32Validate = /*#__PURE__*/ createValidate(config);
 
 /**
 * @name isBase32
 * @description Checks if the input is in base32, returning true/false
 */
-export const isBase32 = createIs(base32Validate);
+export const isBase32 = /*#__PURE__*/ createIs(base32Validate);
 
 /**
  * @name base32Decode
@@ -42,7 +42,7 @@ export const isBase32 = createIs(base32Validate);
  * @description
  * From the provided input, decode the base32 and return the result as an `Uint8Array`.
  */
-export const base32Decode = createDecode(config, base32Validate);
+export const base32Decode = /*#__PURE__*/ createDecode(config, base32Validate);
 
 /**
 * @name base32Encode
@@ -50,4 +50,4 @@ export const base32Decode = createDecode(config, base32Validate);
 * @description
 * From the provided input, create the base32 and return the result as a string.
 */
-export const base32Encode = createEncode(config);
+export const base32Encode = /*#__PURE__*/ createEncode(config);

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';
@@ -27,18 +27,20 @@ type EncodeFn = (value: U8aLike, ipfsCompat?: boolean) => string;
 
 type ValidateFn = (value?: unknown, ipfsCompat?: boolean) => value is string;
 
+/** @internal */
 export function createDecode ({ coder, ipfs }: Config, validate: ValidateFn): DecodeFn {
   return (value: string, ipfsCompat?: boolean): Uint8Array => {
     validate(value, ipfsCompat);
 
     return coder.decode(
       ipfs && ipfsCompat
-        ? value.substr(1)
+        ? value.substring(1)
         : value
     );
   };
 }
 
+/** @internal */
 export function createEncode ({ coder, ipfs }: Config): EncodeFn {
   return (value: U8aLike, ipfsCompat?: boolean): string => {
     const out = coder.encode(u8aToU8a(value));
@@ -49,6 +51,7 @@ export function createEncode ({ coder, ipfs }: Config): EncodeFn {
   };
 }
 
+/** @internal */
 export function createIs (validate: ValidateFn): ValidateFn {
   return (value?: unknown, ipfsCompat?: boolean): value is string => {
     try {
@@ -59,24 +62,26 @@ 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/base58/bs58.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { base58 } from 'micro-base';
+import { base58 } from '@scure/base';
 
 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';
 
@@ -18,7 +18,7 @@ const config = {
  * @description
  * Validates that the supplied value is valid base58, throwing exceptions if not
  */
-export const base58Validate = createValidate(config);
+export const base58Validate = /*#__PURE__*/ createValidate(config);
 
 /**
  * @name base58Decode
@@ -26,7 +26,7 @@ export const base58Validate = createValidate(config);
  * @description
  * From the provided input, decode the base58 and return the result as an `Uint8Array`.
  */
-export const base58Decode = createDecode(config, base58Validate);
+export const base58Decode = /*#__PURE__*/ createDecode(config, base58Validate);
 
 /**
 * @name base58Encode
@@ -34,10 +34,10 @@ export const base58Decode = createDecode(config, base58Validate);
 * @description
 * From the provided input, create the base58 and return the result as a string.
 */
-export const base58Encode = createEncode(config);
+export const base58Encode = /*#__PURE__*/ createEncode(config);
 
 /**
 * @name isBase58
 * @description Checks if the input is in base58, returning true/false
 */
-export const isBase58 = createIs(base58Validate);
+export const isBase58 = /*#__PURE__*/ createIs(base58Validate);

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { base64 } from 'micro-base';
+import { base64 } from '@scure/base';
 
 import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';
 
@@ -17,13 +17,13 @@ const config = {
  * @description
  * Validates that the supplied value is valid base64
  */
-export const base64Validate = createValidate(config);
+export const base64Validate = /*#__PURE__*/ createValidate(config);
 
 /**
  * @name isBase64
  * @description Checks if the input is in base64, returning true/false
  */
-export const isBase64 = createIs(base64Validate);
+export const isBase64 = /*#__PURE__*/ createIs(base64Validate);
 
 /**
  * @name base64Decode
@@ -31,7 +31,7 @@ export const isBase64 = createIs(base64Validate);
  * @description
  * From the provided input, decode the base64 and return the result as an `Uint8Array`.
  */
-export const base64Decode = createDecode(config, base64Validate);
+export const base64Decode = /*#__PURE__*/ createDecode(config, base64Validate);
 
 /**
  * @name base64Encode
@@ -39,4 +39,4 @@ export const base64Decode = createDecode(config, base64Validate);
  * @description
  * From the provided input, create the base64 and return the result as a string.
  */
-export const base64Encode = createEncode(config);
+export const base64Encode = /*#__PURE__*/ createEncode(config);

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

@@ -10,8 +10,6 @@ import { blake2b, isReady } from '@polkadot/wasm-crypto';
 
 import { createAsHex } from '../helpers';
 
-type BitLength = 64 | 128 | 256 | 384 | 512;
-
 /**
  * @name blake2AsU8a
  * @summary Creates a blake2b u8a from the input.
@@ -26,7 +24,7 @@ type BitLength = 64 | 128 | 256 | 384 | 512;
  * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
  * ```
  */
-export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength: BitLength = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
+export function blake2AsU8a (data: HexString | Uint8Array | string, bitLength: 64 | 128 | 256 | 384 | 512 = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
   const byteLength = Math.ceil(bitLength / 8);
   const u8a = u8aToU8a(data);
 

packages/util-crypto/src/bundle.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2022 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import './cryptoInit';
+import './bundleInit';
 
 export { packageInfo } from './packageInfo';
 

packages/util-crypto/src/bundleInit.ts

@@ -17,5 +17,5 @@ utilsNobleSecp256k1.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]
 
 // start init process immediately
 cryptoWaitReady().catch((): void => {
-  // shouldn't happen, logged above
+  // shouldn't happen, logged and caught inside cryptoWaitReady
 });

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/helpers.ts

@@ -14,17 +14,19 @@ interface DualHash {
   512: (u8a: Uint8Array) => Uint8Array;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function createAsHex <T extends (...args: any[]) => Uint8Array> (fn: T): (...args: Parameters<T>) => HexString {
+/** @internal */
+export function createAsHex <T extends (...args: never[]) => Uint8Array> (fn: T): (...args: Parameters<T>) => HexString {
   return (...args: Parameters<T>): HexString =>
     u8aToHex(fn(...args));
 }
 
-export function createBitHasher <T> (bitLength: T, fn: (data: HexString | Buffer | Uint8Array | string, bitLength: T, onlyJs?: boolean) => Uint8Array): (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
+/** @internal */
+export function createBitHasher (bitLength: 256 | 512, fn: (data: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean) => Uint8Array {
   return (data: HexString | Buffer | Uint8Array | string, onlyJs?: boolean): Uint8Array =>
     fn(data, bitLength, onlyJs);
 }
 
+/** @internal */
 export function createDualHasher (wa: DualHash, js: DualHash): (value: HexString | Buffer | Uint8Array | string, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
   return (value: HexString | Buffer | Uint8Array | string, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
     const u8a = u8aToU8a(value);

packages/util-crypto/src/hmac/shaAsU8a.ts

@@ -8,8 +8,6 @@ import { sha512 } from '@noble/hashes/sha512';
 import { hasBigInt, u8aToU8a } from '@polkadot/util';
 import { hmacSha256, hmacSha512, isReady } from '@polkadot/wasm-crypto';
 
-type BitLength = 256 | 512;
-
 const JS_HASH = {
   256: sha256,
   512: sha512
@@ -20,7 +18,7 @@ const WA_MHAC = {
   512: hmacSha512
 };
 
-function createSha (bitLength: BitLength): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
+function createSha (bitLength: 256 | 512): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
   return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
     hmacShaAsU8a(key, data, bitLength, onlyJs);
 }
@@ -29,7 +27,7 @@ function createSha (bitLength: BitLength): (key: Uint8Array | string, data: Uint
  * @name hmacShaAsU8a
  * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
  */
-export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: BitLength = 256, onlyJs?: boolean): Uint8Array {
+export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array {
   const u8aKey = u8aToU8a(key);
 
   return !hasBigInt || (!onlyJs && isReady())

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/keccak/asU8a.ts

@@ -21,8 +21,7 @@ import { createAsHex, createBitHasher, createDualHasher } from '../helpers';
  * keccakAsU8a('123'); // => Uint8Array
  * ```
  */
-
-export const keccakAsU8a = createDualHasher(
+export const keccakAsU8a = /*#__PURE__*/ createDualHasher(
   { 256: keccak256, 512: keccak512 },
   { 256: keccak256Js, 512: keccak512Js }
 );
@@ -31,13 +30,13 @@ export const keccakAsU8a = createDualHasher(
  * @name keccak256AsU8a
  * @description Creates a keccak256 Uint8Array from the input.
  */
-export const keccak256AsU8a = createBitHasher(256, keccakAsU8a);
+export const keccak256AsU8a = /*#__PURE__*/ createBitHasher(256, keccakAsU8a);
 
 /**
  * @name keccak512AsU8a
  * @description Creates a keccak512 Uint8Array from the input.
  */
-export const keccak512AsU8a = createBitHasher(512, keccakAsU8a);
+export const keccak512AsU8a = /*#__PURE__*/ createBitHasher(512, keccakAsU8a);
 
 /**
  * @name keccakAsHex

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

@@ -20,7 +20,7 @@ export class DeriveJunction {
   public static from (value: string): DeriveJunction {
     const result = new DeriveJunction();
     const [code, isHard] = value.startsWith('/')
-      ? [value.substr(1), true]
+      ? [value.substring(1), true]
       : [value, false];
 
     result.soft(

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;
@@ -24,11 +22,13 @@ export function keyExtractPath (derivePath: string): ExtractResult {
     constructed = parts.join('');
 
     for (const p of parts) {
-      path.push(DeriveJunction.from(p.substr(1)));
+      path.push(DeriveJunction.from(p.substring(1)));
     }
   }
 
-  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

@@ -12,8 +12,9 @@
 //   - Use util-crypto randomAsU8a (instead of randombytes)
 //   - Remove setting of wordlist passing of wordlist in functions
 //   - 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';
@@ -52,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');
     })
@@ -71,38 +76,40 @@ 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 (strength?: number): string {
-  strength = strength || 128;
-
-  assert(strength % 32 === 0, INVALID_ENTROPY);
-
-  return entropyToMnemonic(randomAsU8a(strength / 8));
+export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24): string {
+  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4));
 }
 
 export function validateMnemonic (mnemonic: string): boolean {