[CI Skip] release/stable 7.0.2

skip-checks: true

.123trigger

@@ -1,12 +1,18 @@
-6
+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.6.3
+5.9.2
+6.0.2
+6.0.3
+6.0.4
+6.0.5
+
+7.0.2

.codeclimate.yml

@@ -1,5 +1,5 @@
 exclude_patterns:
 - "**/*.spec.js"
 - "**/*.spec.ts"
-- "packages/networks/src/index.ts"
+- "packages/networks/src/substrate.ts"
 - "packages/util/src/is/utf8.ts"

.github/ss58-check.md

@@ -5,6 +5,6 @@ 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/index.ts
+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 run `yarn networks:crosscheck` locally. The output as found from the test includes:
+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/lock.yml

@@ -0,0 +1,23 @@
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '30 1/2 * * *'
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v2
+        with:
+          github-token: ${{ secrets.GH_PAT_BOT }}
+          issue-lock-inactive-days: '7'
+          issue-lock-comment: >
+            This thread has been automatically locked since there has not been
+            any recent activity after it was closed. Please open a new issue
+            if you think you have a related problem or query.
+          pr-lock-inactive-days: '2'
+          pr-lock-comment: >
+            This pull request has been automatically locked since there
+            has not been any recent activity after it was closed.
+            Please open a new issue for related bugs.

.github/workflows/pr-any.yml

@@ -5,7 +5,7 @@ jobs:
   pr:
     strategy:
       matrix:
-        step: ['lint', 'test', 'build', 'networks:crosscheck']
+        step: ['lint', 'test', 'build']
     name: ${{ matrix.step }}
     runs-on: ubuntu-latest
     steps:

.github/workflows/push-master.yml

@@ -6,11 +6,11 @@ on:
 
 jobs:
   master:
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]')"
     strategy:
       matrix:
         step: ['build:release']
     name: ${{ matrix.step }}
-    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/common'"
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
@@ -25,10 +25,3 @@ jobs:
       run: |
         yarn install --immutable | grep -v 'YN0013'
         yarn ${{ matrix.step }}
-
-  dummy:
-    runs-on: ubuntu-latest
-    steps:
-    - name: dummy
-      run: |
-        echo "Dummy skip step"

.github/workflows/semgrep.yml

@@ -0,0 +1,18 @@
+name: Semgrep
+on:
+  pull_request: {}
+  push:
+    branches:
+      - master
+
+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
+    steps:
+      - uses: actions/checkout@v2
+      - uses: returntocorp/semgrep-action@v1
+        with:
+          auditOn: push
+          publishToken: ${{ secrets.SEMGREP_APP_TOKEN }}
+          publishDeployment: 1395

.github/workflows/ss58-check.yml

@@ -1,7 +1,7 @@
 name: SS58
 on:
   schedule:
-    - cron:  '45 3 * * *'
+    - cron:  '15 4/6 * * *'
 
 jobs:
   ss58:
@@ -22,3 +22,4 @@ jobs:
         GITHUB_TOKEN: ${{ secrets.GH_PAT_BOT }}
       with:
         filename: .github/ss58-check.md
+        update_existing: true

.github/workflows/stale.yml

@@ -0,0 +1,17 @@
+name: 'Close stale issues and PRs'
+on:
+  schedule:
+    - cron: '30 2/2 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        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.'
+          stale-issue-label: 'stale'
+          exempt-issue-labels: '-size-l,-size-m,-size-s,-size-xl,-size-xs,[bug],ci'
+          days-before-stale: 21
+          days-before-close: 7

.nvmrc

@@ -1 +0,0 @@
-12

.prettierignore

@@ -0,0 +1,3 @@
+build
+coverage
+packages

.prettierrc.cjs

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

.yarnrc.yml

@@ -10,4 +10,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
     spec: "@yarnpkg/plugin-version"
 
-yarnPath: .yarn/releases/yarn-2.4.0.cjs
+yarnPath: .yarn/releases/yarn-3.0.0-rc.2.cjs

CHANGELOG.md

@@ -1,5 +1,238 @@
 # CHANGELOG
 
+## 7.0.2 Jul 19, 2021
+
+Changes:
+
+- Added `isCompact` utility for check on compact-like types
+- Sync with upstream Substrate ss58 registry
+
+
+## 7.0.1 Jul 11, 2021
+
+- **Breaking change** The `@polkadot/x-rxjs` package has been removed. In `rxjs` 7.2.0 the compatibility issues at the base layer has been solved.
+- **Breaking change** The named exports in `@polkadot/networks` has been changed
+
+Contributed:
+
+- Add Ledger config for Centrifuge (Thanks to https://github.com/mikiquantum)
+
+Changes:
+
+- Adjust `@polkadot/networks` to fully-descriptive exports
+- Remove `@polkadot/x-rxjs`, direct import from `rxjs >= 7.2.0` required
+- Allow building as a completely stand-alone browser bundle (experimental)
+- Sync with upstream Substrate ss58 registry
+
+
+## 6.11.1 Jul 5, 2021
+
+Changes:
+
+- Cleanup unneeded dependencies for `@polkadot/x-global`
+- Sync with upstream Substrate ss58 registry
+- Bump Zondax dependencies (Statemine slip44 fix)
+
+
+## 6.10.1 Jun 26, 2021
+
+Contributed:
+
+- Add Karura genesisHash (Thanks to https://github.com/ntduan)
+
+Changes:
+
+- `isHex(value)` will now check for only `string` types (No `String` classes)
+- Added `arrayShuffle(array)` to shuffle an array into a new output
+- Added Statemine Ledger app information
+- Simplify tests to use `{describe|it}.each` where applicable
+- Sync with upstream Substrate ss58 registry
+
+
+## 6.9.1 Jun 19, 2021
+
+Changes:
+
+- Added `u8aCmp(a, b)` to do sorting compares
+- Added `arrayRange(size, startAt = 0)` to create a range of numbers
+- Added extensive mnemonic compare test (optional, skipped)
+
+
+## 6.8.1 Jun 14, 2021
+
+Contributed:
+
+- Add Ledger support for Edgeware (Thanks to https://github.com/raykyri)
+- Fix `naclSeal` doc types (Thanks to https://github.com/agustinustheo)
+
+Changes:
+
+- Export `BN` in `@polkadot/util`
+- Sync with upstream Substrate ss58 registry
+
+
+## 6.7.1 Jun 6, 2021
+
+Changes:
+
+- Add WebHID transport for Ledger
+- Update to latest Ledger transport packages
+- Remove old `Gerald` key for Moonbeam
+- Cleanup testing keyring semgrep recommendations
+
+
+## 6.6.1 May 29, 2021
+
+Changes:
+
+- Adjust HD path validation & replacement
+- Sync with Substrate ss58 registry
+
+
+## 6.5.1 May 22, 2021
+
+Changes:
+
+- Allow hdLedger derivation with optional 25th word password
+- Sync with Substrate ss58 registry
+
+
+## 6.4.1 May 15, 2021
+
+Contributed:
+
+- Update genesis for HydraDx gen-3 (Thanks to https://github.com/jak-pan)
+- Allow Ethereum pair in keyring addAddress (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Added additional double-byte ss58 tests
+- Aligned ss58 registry with Substrate
+- Add explicit log for deprecation of `setSS58Format`
+
+
+## 6.3.1 Apr 25, 2021
+
+Changes:
+
+- Added `stringify` util to correctly handle `JSON.stringify` with `BigInt` values
+- Additional input asserts for non-convertible values in `u8aToU8a`
+- Adapt `@polkadot/x-global` to return `globalThis` as available
+- Minor readability cleanups
+- BN manipulation via in-place shifts (as applicable)
+- Add explicit `engines` config to `package.json`
+
+
+## 6.2.1 Apr 18, 2021
+
+Contributed:
+
+- Added HydraDx genesis (Thanks to https://github.com/jak-pan)
+
+Changes:
+
+- Add `isAddress` and `validateAddress` functions (the latter will throw if invalid)
+- Check `@polkadot/hw-ledger` against `@polkadot/networks` for discrepancies (test-only)
+- Align ss58 registry with upstream Substrate
+
+
+## 6.1.1 Apr 11, 2021
+
+Contributed:
+
+- Adjust Polymath genesis in `@polkadot/networks` (Thanks to https://github.com/adamdossa)
+- Adjust `@polkadot/util` logger for +/-/* compat (Thanks to https://github.com/Lezek123)
+- Fix typo in `@polkadot/util` detect messaging (Thanks to https://github.com/amphineko)
+
+Changes:
+
+- Remove `@polkadot/networks` code duplication, manages data via script from upstream
+- Align ss58 registry with upstream Substrate
+
+
+## 6.0.5 Mar 8, 2021
+
+Changes:
+
+- Fix for `@polkadot/x-rxjs` in Node CJS environments (no Node-specific import)
+
+
+## 6.0.4 Mar 7, 2021
+
+Contributed:
+
+- Enhance check for global process existence (Thanks to https://github.com/Yuripetusko)
+
+Changes:
+
+- Dedupe & optimize logger process.env checks
+
+
+## 6.0.3 Mar 5, 2021
+
+Changes:
+
+- Add import indirection for both CJS & ESM (where generated source file is commonjs)
+
+
+## 6.0.2 Mar 5, 2021
+
+Changes:
+
+- Fix `@polkadot/x-rxjs` ESM exports for Node environments (now different due to the ESM conversion)
+
+
+## 6.0.1 Mar 5, 2021
+
+**Important** In the 6.0 version the default package type has been changed to ESM modules by default. This should not affect usage, however since the output formats changed, a new major version is required.
+
+Contributed:
+
+- Add dev addresses for Frontier-based chains (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Build to ESM by default (with cjs versions via export map)
+- Allow addition or raw pairs on the keyring via `{add, create}FromPair`
+- Extract re-usable json encryption/decryption functions
+
+
+## 5.9.2 Feb 28, 2021
+
+Changes:
+
+- Fix package detection for `@polkadot/networks` (no dependencies)
+
+
+## 5.9.1 Feb 28, 2021
+
+Changes:
+
+- Expand `detectPackage` with optional param allowing checks for monorepo versions
+- Export logger `format` function directly as `loggerFormat`
+- Expand tests and checks for `hdValidatePath`
+- Remove `hdEthereum` class-based approach, simplify
+- Cleanup formatting on nested conditionals in the `@polkadot/x-` packages
+- All packages now export `packageInfo` from the root
+
+
+## 5.8.1 Feb 26, 2021
+
+Contributed:
+
+- Add ss58 information for HydraDX (Thanks to https://github.com/jak-pan)
+- HD derivation for Ethereum (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Adjust base64 encoding/decoding to not rely on Buffer being available
+- Rework Ethereum derivation to only use Uint8Array internally
+- Shared HD path validation for Ledger & Ethereum
+- Additional derivation, encoding and decoding tests on keyring
+- Align networks with upstream ss58 registry
+- `@polkadot/wasm-crypto` 3.2.4
+
+
 ## 5.7.1 Feb 21, 2021
 
 **Breaking change** The signature of `pair.verify` now requires the signer public key as a parameter. If using `pair.verify` pass the publicKey (hex or Uint8Array) of the signer.

jest.config.cjs

@@ -32,5 +32,5 @@ module.exports = Object.assign({}, config, {
     '<rootDir>/packages/x-textencoder/build',
     '<rootDir>/packages/x-ws/build'
   ],
-  resolver: '@polkadot/dev/config/jest-resolver.cjs'
+  transformIgnorePatterns: ['/node_modules/(?!@polkadot)']
 });

package.json

@@ -7,23 +7,26 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^4.1.5"
+    "typescript": "^4.3.5"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
     "build:release": "polkadot-ci-ghact-build",
+    "build:rollup": "polkadot-exec-rollup --config",
     "lint": "polkadot-dev-run-lint",
     "clean": "polkadot-dev-clean-build",
     "networks:crosscheck": "polkadot-dev-run-test packages/networks/src/crosscheck",
+    "networks:sync": "node packages/networks/scripts/fromSubstrate.mjs",
     "postinstall": "polkadot-dev-yarn-only",
-    "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck",
-    "test:one": "polkadot-dev-run-test"
+    "test": "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.12.16",
-    "@polkadot/dev": "^0.61.26",
-    "@polkadot/ts": "^0.3.59",
-    "@types/jest": "^26.0.20"
+    "@babel/core": "^7.14.6",
+    "@polkadot/dev": "^0.62.57",
+    "@polkadot/ts": "^0.4.4",
+    "@types/jest": "^26.0.24"
   },
-  "version": "5.7.1"
+  "version": "7.0.2"
 }

packages/hw-ledger-transports/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@polkadot/hw-ledger-transports",
-  "version": "5.7.1",
+  "version": "7.0.2",
+  "type": "module",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -10,15 +11,16 @@
   "browser": "browser.js",
   "react-native": "react-native.js",
   "sideEffects": false,
-  "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@ledgerhq/hw-transport-webusb": "^5.43.0"
+  "engines": {
+    "node": ">=14.0.0"
   },
-  "devDependencies": {
-    "@types/ledgerhq__hw-transport-node-hid": "^4.22.2",
-    "@types/ledgerhq__hw-transport-webusb": "^4.70.1"
+  "dependencies": {
+    "@babel/runtime": "^7.14.6",
+    "@ledgerhq/hw-transport": "^6.1.0",
+    "@ledgerhq/hw-transport-webhid": "^6.1.0",
+    "@ledgerhq/hw-transport-webusb": "^6.1.0"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^5.43.0"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.1.0"
   }
 }

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

@@ -4,9 +4,12 @@
 import type Transport from '@ledgerhq/hw-transport';
 import type { TransportDef } from './types';
 
-import LedgerWebUSB from '@ledgerhq/hw-transport-webusb';
+import LedgerWebHid from '@ledgerhq/hw-transport-webhid';
+import LedgerWebUsb from '@ledgerhq/hw-transport-webusb';
 
-const transports: TransportDef[] = [
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [
   // deprecated
   // import LedgerU2F from '@ledgerhq/hw-transport-u2f';
   // {
@@ -16,9 +19,12 @@ const transports: TransportDef[] = [
   // },
   {
     create: (): Promise<Transport> =>
-      LedgerWebUSB.create(),
+      LedgerWebUsb.create(),
     type: 'webusb'
+  },
+  {
+    create: (): Promise<Transport> =>
+      LedgerWebHid.create(),
+    type: 'hid'
   }
 ];
-
-export { transports };

packages/hw-ledger-transports/src/ledgerhq.d.ts

@@ -1,15 +0,0 @@
-// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-declare module '@ledgerhq/hw-transport-node-hid-noevents' {
-  import Transport from '@ledgerhq/hw-transport';
-
-  export default class TransportNodeHidNoEvents extends Transport<string> {}
-  export function getDevices(): Array<unknown>
-}
-
-declare module '@ledgerhq/hw-transport-node-hid-singleton' {
-  import TransportNodeHidNoEvents from '@ledgerhq/hw-transport-node-hid-noevents';
-
-  export default class TransportNodeHid extends TransportNodeHidNoEvents { }
-}

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

@@ -6,12 +6,12 @@ import type { TransportDef } from './types';
 
 import LedgerHid from '@ledgerhq/hw-transport-node-hid-singleton';
 
-const transports: TransportDef[] = [
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [
   {
     create: (): Promise<Transport> =>
       LedgerHid.create(),
     type: 'hid'
   }
 ];
-
-export { transports };

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

@@ -1,6 +1,6 @@
-// Copyright 2017-2021 @polkadot/dev authors & contributors
+// Copyright 2017-2021 @polkadot/hw-ledger-transports authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '5.7.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '7.0.2' };

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

@@ -3,6 +3,6 @@
 
 import type { TransportDef } from './types';
 
-const transports: TransportDef[] = [];
+export { packageInfo } from './packageInfo';
 
-export { transports };
+export const transports: TransportDef[] = [];

packages/hw-ledger/package.json

@@ -1,17 +1,24 @@
 {
   "name": "@polkadot/hw-ledger",
-  "version": "5.7.1",
+  "version": "7.0.2",
+  "type": "module",
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
   "main": "index.js",
-  "sideEffects": false,
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/hw-ledger-transports": "5.7.1",
-    "@polkadot/util": "^5.7.1",
-    "@zondax/ledger-polkadot": "^0.13.1"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/hw-ledger-transports": "7.0.2",
+    "@polkadot/util": "^7.0.2",
+    "@zondax/ledger-substrate": "^0.16.2"
   }
 }

packages/hw-ledger/src/bundle.ts

@@ -0,0 +1,103 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ResponseBase, SubstrateApp } from '@zondax/ledger-substrate';
+import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';
+
+import { transports } from '@polkadot/hw-ledger-transports';
+import { assert, u8aToBuffer } from '@polkadot/util';
+
+import { LEDGER_DEFAULT_ACCOUNT, LEDGER_DEFAULT_CHANGE, LEDGER_DEFAULT_INDEX, LEDGER_SUCCESS_CODE } from './constants';
+import { ledgerApps } from './defaults';
+
+export { packageInfo } from './packageInfo';
+
+type Chain = keyof typeof ledgerApps;
+
+// A very basic wrapper for a ledger app -
+//  - it connects automatically, creating an app as required
+//  - Promises return errors (instead of wrapper errors)
+export class Ledger {
+  #app: SubstrateApp | null = null;
+
+  #chain: Chain;
+
+  #transport: LedgerTypes;
+
+  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}`);
+
+    this.#chain = chain;
+    this.#transport = transport;
+  }
+
+  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));
+
+      return {
+        address,
+        publicKey: `0x${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());
+
+      return {
+        isLocked,
+        isTestMode,
+        version: [major, minor, patch]
+      };
+    });
+  }
+
+  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));
+
+      return {
+        signature: `0x${signature.toString('hex')}`
+      };
+    });
+  }
+
+  #getApp = async (): Promise<SubstrateApp> => {
+    if (!this.#app) {
+      const def = transports.find(({ type }) => type === this.#transport);
+
+      assert(def, () => `Unable to find a transport for ${this.#transport}`);
+
+      const transport = await def.create();
+
+      this.#app = ledgerApps[this.#chain](transport);
+    }
+
+    return this.#app;
+  };
+
+  #withApp = async <T> (fn: (app: SubstrateApp) => Promise<T>): Promise<T> => {
+    try {
+      const app = await this.#getApp();
+
+      return await fn(app);
+    } catch (error) {
+      this.#app = null;
+
+      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/constants.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const LEDGER_DEFAULT_ACCOUNT = 0x80000000;
+
+export const LEDGER_DEFAULT_CHANGE = 0x80000000;
+
+export const LEDGER_DEFAULT_INDEX = 0x80000000;
+
+export const LEDGER_SUCCESS_CODE = 0x9000;

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

@@ -0,0 +1,24 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { knownLedger } from '@polkadot/networks/defaults';
+
+import { ledgerApps } from './defaults';
+
+describe('defaults', (): void => {
+  it('has entries for each of the apps (hwledger -> networks)', (): void => {
+    expect(
+      Object.keys(knownLedger).filter((network) =>
+        !ledgerApps[network]
+      )
+    ).toEqual([]);
+  });
+
+  it('has entries for each of the apps (networks -> hwledger)', (): void => {
+    expect(
+      Object.keys(ledgerApps).filter((network) =>
+        !knownLedger[network]
+      )
+    ).toEqual([]);
+  });
+});

packages/hw-ledger/src/defaults.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2021 @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 { newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newKusamaApp, newPolkadotApp, newPolymeshApp, 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> = {
+  centrifuge: newCentrifugeApp,
+  'dock-mainnet': newDockApp,
+  edgeware: newEdgewareApp,
+  equilibrium: newEquilibriumApp,
+  kusama: newKusamaApp,
+  polkadot: newPolkadotApp,
+  polymesh: newPolymeshApp,
+  statemine: newStatemineApp
+};

packages/hw-ledger/src/detectPackage.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { packageInfo as transportInfo } from '@polkadot/hw-ledger-transports/packageInfo';
+import { detectPackage, packageInfo as utilInfo } from '@polkadot/util';
+
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [transportInfo, utilInfo]);

packages/hw-ledger/src/index.ts

@@ -1,118 +1,6 @@
 // Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type Transport from '@ledgerhq/hw-transport';
-import type { AccountOptions, LedgerAddress, LedgerSignature, LedgerTypes, LedgerVersion } from './types';
+import './detectPackage';
 
-import { newDockApp, newKusamaApp, newPolkadotApp, newPolymeshApp, ResponseBase, SubstrateApp } from '@zondax/ledger-polkadot';
-
-import { transports } from '@polkadot/hw-ledger-transports';
-import { assert, bufferToU8a, u8aToBuffer, u8aToHex } from '@polkadot/util';
-
-export const LEDGER_DEFAULT_ACCOUNT = 0x80000000;
-
-export const LEDGER_DEFAULT_CHANGE = 0x80000000;
-
-export const LEDGER_DEFAULT_INDEX = 0x80000000;
-
-const SUCCESS_CODE = 0x9000;
-
-// These match up with the network keys in the @polkadot/networks package
-// (which is turn aligns with the substrate/ss58-registry.json as the single
-// source of truth)
-const APPS: Record<string, (transport: Transport) => SubstrateApp> = {
-  dock: newDockApp,
-  kusama: newKusamaApp,
-  polkadot: newPolkadotApp,
-  polymesh: newPolymeshApp
-};
-
-type Chain = keyof typeof APPS;
-
-// A very basic wrapper for a ledger app -
-//  - it connects automatically, creating an app as required
-//  - Promises return errors (instead of wrapper errors)
-export class Ledger {
-  #app: SubstrateApp | null = null;
-
-  #chain: Chain;
-
-  #transport: LedgerTypes;
-
-  constructor (transport: LedgerTypes, chain: Chain) {
-    // u2f is deprecated
-    assert(['hid', 'webusb'].includes(transport), `Unsupported transport ${transport}`);
-    assert(Object.keys(APPS).includes(chain), `Unsupported chain ${chain}`);
-
-    this.#chain = chain;
-    this.#transport = transport;
-  }
-
-  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));
-
-      return {
-        address,
-        publicKey: `0x${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());
-
-      return {
-        isLocked,
-        isTestMode,
-        version: [major, minor, patch]
-      };
-    });
-  }
-
-  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));
-
-      return {
-        signature: u8aToHex(bufferToU8a(signature))
-      };
-    });
-  }
-
-  #getApp = async (): Promise<SubstrateApp> => {
-    if (!this.#app) {
-      const def = transports.find(({ type }) => type === this.#transport);
-
-      assert(def, `Unable to find a transport for ${this.#transport}`);
-
-      const transport = await def.create();
-
-      this.#app = APPS[this.#chain](transport);
-    }
-
-    return this.#app;
-  };
-
-  #withApp = async <T> (fn: (app: SubstrateApp) => Promise<T>): Promise<T> => {
-    try {
-      const app = await this.#getApp();
-
-      return await fn(app);
-    } catch (error) {
-      this.#app = null;
-
-      throw error;
-    }
-  };
-
-  #wrapError = async <T extends ResponseBase> (promise: Promise<T>): Promise<T> => {
-    const result = await promise;
-
-    assert(result.return_code === SUCCESS_CODE, result.error_message);
-
-    return result;
-  };
-}
+export * from './bundle';

packages/hw-ledger/src/packageInfo.ts

@@ -1,6 +1,6 @@
-// Copyright 2017-2021 @polkadot/dev authors & contributors
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger', version: '5.7.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', version: '7.0.2' };

packages/keyring/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@polkadot/keyring",
-  "version": "5.7.1",
+  "version": "7.0.2",
+  "type": "module",
   "description": "Keyring management",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -9,18 +10,21 @@
   "main": "index.js",
   "sideEffects": [
     "./detectPackage.js",
-    "./detectPackage.mjs"
+    "./detectPackage.cjs"
   ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "repository": "github:polkadot-js/common",
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/util": "5.7.1",
-    "@polkadot/util-crypto": "5.7.1"
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/util": "7.0.2",
+    "@polkadot/util-crypto": "7.0.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.7.1",
-    "@polkadot/util-crypto": "5.7.1"
+    "@polkadot/util": "7.0.2",
+    "@polkadot/util-crypto": "7.0.2"
   }
 }

packages/keyring/src/bundle.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Keyring } from './keyring';
+
+export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+
+export * from './defaults';
+export { createPair } from './pair';
+export { packageInfo } from './packageInfo';
+export { createTestKeyring } from './testing';
+export { createTestPairs } from './testingPairs';
+
+export { Keyring };

packages/keyring/src/defaults.ts

@@ -2,12 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // default substrate dev phrase
-const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
+export const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
 
 // seed from the above phrase
-const DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';
-
-export {
-  DEV_PHRASE,
-  DEV_SEED
-};
+export const DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';

packages/keyring/src/detectPackage.ts

@@ -1,25 +1,9 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// For esm, this should be import.meta.url or to get the same behavior as __dirname, we can use
-//
-//   new URL(import.meta.url).pathname)
-//
-// The issue is the WP4 has "some" issues with import.meta.url. So because of bundlers, we can't have
-// nice things... In this case it is even worse since import.meta.url won't even make it compile, so
-// there is a complete dead end with usage thereof
-//
-// When that is fixed, a solution is to have both .js & .mjs files, with the following content -
-//
-// cjs: util.detectPackage(packageInfo, () => __dirname);
-// esm: detectPackage(packageInfo, () => import.meta.url);
-//
-// With the above we additionally need a .d.ts to just export the packageInfo
-
-import { detectPackage } from '@polkadot/util';
+import { detectPackage, packageInfo as utilInfo } from '@polkadot/util';
+import { packageInfo as cryptoInfo } from '@polkadot/util-crypto/packageInfo';
 
 import { packageInfo } from './packageInfo';
 
-detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
-
-export { packageInfo };
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [utilInfo, cryptoInfo]);

packages/keyring/src/index.spec.ts

@@ -1,9 +1,12 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { hexToU8a, stringToU8a } from '@polkadot/util';
-import { cryptoWaitReady, encodeAddress, randomAsU8a, setSS58Format } from '@polkadot/util-crypto';
+import type { KeyringPair$Json } from './types';
 
+import { hexToU8a, stringToU8a } from '@polkadot/util';
+import { base64Decode, cryptoWaitReady, encodeAddress, randomAsU8a, setSS58Format } from '@polkadot/util-crypto';
+
+import { decodePair } from './pair/decode';
 import Keyring from '.';
 
 describe('keypair', (): void => {
@@ -118,6 +121,14 @@ describe('keypair', (): void => {
       ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
     });
 
+    it('creates via dev seed (2-byte encoding)', (): void => {
+      keyring.setSS58Format(252);
+
+      expect(
+        keyring.addFromUri('//Alice').address
+      ).toEqual('xw8P6urbSAronL3zZFB7dg8p7LLSgKCUFDUgjohnf1iP434ic');
+    });
+
     it('adds the pair', (): void => {
       expect(
         keyring.addFromSeed(seedTwo, {}).publicKey
@@ -263,6 +274,25 @@ describe('keypair', (): void => {
       ).not.toThrow();
     });
 
+    it('encodes a pair toJSON (and decodes)', (): void => {
+      const pair = keyring.createFromUri('moral movie very draw assault whisper awful rebuild speed purity repeat card');
+      const json = pair.toJson('password');
+
+      expect(json.address).toEqual('0x03ddca309bd5fedd01f914d6fb76f23aa848a2a520802159215dba5085d7863619');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ecdsa'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
     it('signs and verifies', (): void => {
       const MESSAGE = stringToU8a('this is a message');
       const pair = keyring.getPair(addressKeyOne);
@@ -285,30 +315,80 @@ describe('keypair', (): void => {
   });
 
   describe('ethereum', (): void => {
-    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+    // combine mnemonic with derivation path
+    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy' + '/m/44\'/60\'/0\'/0/0';
+    const PRIV_KEY_ONE = '0x070dc3117300011918e26b02176945cc15c3d548cf49fd8418d97f93af699e46';
+    const ETH_ADDRESS_ONE = '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d';
+    const ETH_ADDRESS_TWO = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887';
+
     let keyring: Keyring;
 
     beforeEach((): void => {
       keyring = new Keyring({ type: 'ethereum' });
     });
 
-    it('adds a pair with the correct address', (): void => {
-      const pair = keyring.createFromUri(PHRASE);
+    it('creates with dev phrase from the private key', (): void => {
+      const pair = keyring.addFromSeed(hexToU8a(PRIV_KEY_ONE));
 
-      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
-      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
     });
 
-    it('encodes a pair toJSON', (): void => {
+    it('creates with dev phrase from the private key in createFromUri', (): void => {
+      const pair = keyring.createFromUri(PRIV_KEY_ONE);
+
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('creates with dev phrase with derivation path specified', (): void => {
+      const pair = keyring.createFromUri(PHRASE);
+
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('creates with dev phrase with derivation path specified - addFromUri', (): void => {
+      expect(
+        keyring.addFromUri(PHRASE).address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('encodes a pair toJSON (and decodes)', (): void => {
       const pair = keyring.createFromUri(PHRASE);
       const json = pair.toJson('password');
 
-      expect(json.address).toEqual('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077');
+      expect(json.address).toEqual('0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b'); // this is the public key (different from address for ethereum)
       expect(json.encoding).toEqual({
         content: ['pkcs8', 'ethereum'],
         type: ['scrypt', 'xsalsa20-poly1305'],
         version: '3'
       });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
+    it('encodes a pair toJSON and back', (): void => {
+      const pairOriginal = keyring.createFromUri(PHRASE);
+      const json = pairOriginal.toJson('password');
+      const pair = keyring.addFromJson(
+        json
+      );
+
+      expect(pair.address).toEqual(ETH_ADDRESS_ONE);
+
+      pair.decodePkcs8('password');
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe(ETH_ADDRESS_ONE);
     });
 
     it('allows adding from JSON', (): void => {
@@ -317,13 +397,13 @@ describe('keypair', (): void => {
       );
 
       expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
-      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(pair.address).toEqual(ETH_ADDRESS_TWO);
 
       pair.decodePkcs8('password');
 
       expect(pair.isLocked).toBe(false);
       expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
-      expect(pair.address).toBe('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(pair.address).toBe(ETH_ADDRESS_TWO);
     });
 
     it('allows for signing/verification', (): void => {
@@ -361,6 +441,30 @@ describe('keypair', (): void => {
     });
   });
 
+  describe('raw pair add/create', (): void => {
+    const json = JSON.parse('{"address":"5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H","encoded":"JQUl8ZpoXv2OMkL9TPylLmcIye2cYhaS9INICbFgZTsAgAAAAQAAAAgAAAAr/0hJOOzokIdBG71TstigLABX9D5xGD7L37ySxtjDrVRg26LL90jLQ47quT9o3bq6ppXMVL6USk7Q4p3WU66bojTFuCDyhpYRhNbUqU6s0rD3S4bhv9lG+pG9vQ4eD5PVQUvxdANmJpYuDg45nrTmsMC5AHGdFGkHW/LHnkmbFid1cvPYkdiBoef5CIEdoly512pxMupVxnJWF1NT","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"name":"hello"}}') as KeyringPair$Json;
+    const decoded = decodePair('1', base64Decode(json.encoded), json.encoding.type);
+    const keyring = new Keyring({ ss58Format: 44 });
+
+    it('creates a pair from a private/public combo', (): void => {
+      const pair = keyring.createFromPair(decoded, json.meta, 'sr25519');
+
+      expect(pair.address).toEqual('5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H');
+      expect(pair.isLocked).toEqual(false);
+      expect(pair.meta.name).toEqual('hello');
+    });
+
+    it('adds a pair from a private/public combo', (): void => {
+      keyring.addFromPair(decoded, json.meta, 'sr25519');
+
+      const pair = keyring.getPairs()[0];
+
+      expect(pair.address).toEqual('5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H');
+      expect(pair.isLocked).toEqual(false);
+      expect(pair.meta.name).toEqual('hello');
+    });
+  });
+
   describe('util', (): void => {
     let keyring: Keyring;
 

packages/keyring/src/index.ts

@@ -3,10 +3,8 @@
 
 import './detectPackage';
 
-import { Keyring } from './keyring';
+import { Keyring } from './bundle';
 
-export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+export * from './bundle';
 
 export default Keyring;
-
-export { Keyring };

packages/keyring/src/keyring.ts

@@ -1,11 +1,12 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/json/types';
 import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from './types';
+import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types';
 
 import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
-import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
+import { base64Decode, decodeAddress, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import { createPair } from './pair';
@@ -46,7 +47,7 @@ export class Keyring implements KeyringInstance {
   constructor (options: KeyringOptions = {}) {
     options.type = options.type || 'ed25519';
 
-    assert(options && ['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);
+    assert(['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), () => `Expected a keyring type of either 'ed25519', 'sr25519', 'ethereum' or 'ecdsa', found '${options.type || 'unknown'}`);
 
     this.#pairs = new Pairs();
     this.#ss58 = options.ss58Format;
@@ -85,12 +86,12 @@ export class Keyring implements KeyringInstance {
   /**
    * @name addFromAddress
    * @summary Stores an account, given an account address, as a Key/Value (public key, pair) in Keyring Pair Dictionary
-   * @description Allows user to explicitely provide separate inputs including account address or public key, and optionally
+   * @description Allows user to explicitly provide separate inputs including account address or public key, and optionally
    * the associated account metadata, and the default encoded value as arguments (that may be obtained from the json file
    * of an account backup), and then generates a keyring pair from them that it passes to
    * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
    */
-  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean, encType?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean, encType?: EncryptedJsonEncoding[]): KeyringPair {
     const publicKey = this.decodeAddress(address, ignoreChecksum);
 
     return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded, encType));
@@ -119,6 +120,16 @@ export class Keyring implements KeyringInstance {
     return this.addFromUri(mnemonic, meta, type);
   }
 
+  /**
+   * @name addFromPair
+   * @summary Stores an account created from an explicit publicKey/secreteKey combination
+   */
+  public addFromPair (pair: Keypair, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
+    return this.addPair(
+      this.createFromPair(pair, meta, type)
+    );
+  }
+
   /**
    * @name addFromSeed
    * @summary Stores an account, given seed data, as a Key/Value (public key, pair) in Keyring Pair Dictionary
@@ -127,7 +138,9 @@ export class Keyring implements KeyringInstance {
    * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
    */
   public addFromSeed (seed: Uint8Array, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, keypairFromSeed[type](seed), meta, null));
+    return this.addPair(
+      createPair({ toSS58: this.encodeAddress, type }, keypairFromSeed[type](seed), meta, null)
+    );
   }
 
   /**
@@ -146,12 +159,18 @@ 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}`);
+
     const cryptoType = version === '0' || !Array.isArray(content)
       ? this.type
       : content[1];
     const encType = !Array.isArray(type)
       ? [type]
       : type;
+
+    assert(['ed25519', 'sr25519', 'ecdsa', 'ethereum'].includes(cryptoType), () => `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)
       ? hexToU8a(address)
       : this.decodeAddress(address, ignoreChecksum);
@@ -159,7 +178,15 @@ export class Keyring implements KeyringInstance {
       ? hexToU8a(encoded)
       : base64Decode(encoded);
 
-    return createPair({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
+    return createPair({ toSS58: this.encodeAddress, type: cryptoType as KeypairType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
+  }
+
+  /**
+   * @name createFromPair
+   * @summary Creates a pair from an explicit publicKey/secreteKey combination
+   */
+  public createFromPair (pair: Keypair, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
+    return createPair({ toSS58: this.encodeAddress, type }, pair, meta, null);
   }
 
   /**
@@ -172,18 +199,19 @@ export class Keyring implements KeyringInstance {
     const suri = _suri.startsWith('//')
       ? `${DEV_PHRASE}${_suri}`
       : _suri;
-    const { password, path, phrase } = keyExtractSuri(suri);
+    const { derivePath, password, path, phrase } = keyExtractSuri(suri);
     let seed: Uint8Array;
+    const isPhraseHex = isHex(phrase, 256);
 
-    if (isHex(phrase, 256)) {
+    if (isPhraseHex) {
       seed = hexToU8a(phrase);
     } else {
-      const str = phrase as string;
+      const str = phrase;
       const parts = str.split(' ');
 
       if ([12, 15, 18, 21, 24].includes(parts.length)) {
         seed = type === 'ethereum'
-          ? mnemonicToLegacySeed(phrase)
+          ? mnemonicToLegacySeed(phrase, '', false, 64)
           : mnemonicToMiniSecret(phrase, password);
       } else {
         assert(str.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
@@ -192,8 +220,11 @@ export class Keyring implements KeyringInstance {
       }
     }
 
-    // FIXME Need to support Ethereum-type derivation paths
-    const derived = keyFromPath(keypairFromSeed[type](seed), path, type);
+    const derived = type === 'ethereum'
+      ? isPhraseHex
+        ? keypairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
+        : hdEthereum(seed, derivePath.substring(1))
+      : keyFromPath(keypairFromSeed[type](seed), path, type);
 
     return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
   }
@@ -203,7 +234,9 @@ export class Keyring implements KeyringInstance {
    * @description Encodes the input into an ss58 representation
    */
   public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
-    return encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
+    return this.type === 'ethereum'
+      ? ethereumEncode(address)
+      : encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
   }
 
   /**

packages/keyring/src/packageInfo.ts

@@ -1,6 +1,6 @@
-// Copyright 2017-2021 @polkadot/dev authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/keyring', version: '5.7.1' };
+export const packageInfo = { name: '@polkadot/keyring', version: '7.0.2' };

packages/keyring/src/pair/decode.ts

@@ -1,13 +1,13 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { KeyringPair$JsonEncodingTypes } from '../types';
+import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/json/types';
 import type { PairInfo } from './types';
 
-import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
-import { naclDecrypt, scryptEncode, scryptFromU8a } from '@polkadot/util-crypto';
+import { assert, isUndefined, u8aEq } from '@polkadot/util';
+import { jsonDecryptData } from '@polkadot/util-crypto';
 
-import { ENCODING, NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
+import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
 
 const SEED_OFFSET = PKCS8_HEADER.length;
 
@@ -15,59 +15,33 @@ type DecodeResult = PairInfo & {
   secretKey: Uint8Array;
 };
 
-function decodePkcs8 (encoded: Uint8Array): DecodeResult {
-  const header = encoded.subarray(0, PKCS8_HEADER.length);
+export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, _encType?: EncryptedJsonEncoding | EncryptedJsonEncoding[]): DecodeResult {
+  const encType = Array.isArray(_encType) || isUndefined(_encType)
+    ? _encType
+    : [_encType];
+  const decrypted = jsonDecryptData(encrypted, passphrase, encType);
+  const header = decrypted.subarray(0, PKCS8_HEADER.length);
 
-  assert(header.toString() === PKCS8_HEADER.toString(), 'Invalid Pkcs8 header found in body');
+  assert(u8aEq(header, PKCS8_HEADER), 'Invalid Pkcs8 header found in body');
 
-  let secretKey = encoded.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
+  let secretKey = decrypted.subarray(SEED_OFFSET, SEED_OFFSET + SEC_LENGTH);
   let divOffset = SEED_OFFSET + SEC_LENGTH;
-  let divider = encoded.subarray(divOffset, divOffset + PKCS8_DIVIDER.length);
+  let divider = decrypted.subarray(divOffset, divOffset + PKCS8_DIVIDER.length);
 
   // old-style, we have the seed here
-  if (divider.toString() !== PKCS8_DIVIDER.toString()) {
+  if (!u8aEq(divider, PKCS8_DIVIDER)) {
     divOffset = SEED_OFFSET + SEED_LENGTH;
-    secretKey = encoded.subarray(SEED_OFFSET, divOffset);
-    divider = encoded.subarray(divOffset, divOffset + PKCS8_DIVIDER.length);
+    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');
   }
 
-  assert(divider.toString() === PKCS8_DIVIDER.toString(), 'Invalid Pkcs8 divider found in body');
-
   const pubOffset = divOffset + PKCS8_DIVIDER.length;
-  const publicKey = encoded.subarray(pubOffset, pubOffset + PUB_LENGTH);
+  const publicKey = decrypted.subarray(pubOffset, pubOffset + PUB_LENGTH);
 
   return {
     publicKey,
     secretKey
   };
 }
-
-export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, encType: KeyringPair$JsonEncodingTypes[] = ENCODING): DecodeResult {
-  assert(encrypted, 'No encrypted data available to decode');
-  assert(passphrase || !encType.includes('xsalsa20-poly1305'), 'Password required to decode encypted data');
-
-  let encoded: Uint8Array | null = encrypted;
-
-  if (passphrase) {
-    let password: Uint8Array;
-
-    if (encType.includes('scrypt')) {
-      const { params, salt } = scryptFromU8a(encrypted);
-
-      password = scryptEncode(passphrase, salt, params).password;
-      encrypted = encrypted.subarray(SCRYPT_LENGTH);
-    } else {
-      password = stringToU8a(passphrase);
-    }
-
-    encoded = naclDecrypt(
-      encrypted.subarray(NONCE_LENGTH),
-      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(password, 256, true)
-    );
-  }
-
-  assert(encoded, 'Unable to decode using the supplied passphrase');
-
-  return decodePkcs8(encoded);
-}

packages/keyring/src/pair/defaults.ts

@@ -1,26 +1,9 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { KeyringPair$JsonEncodingTypes } from '../types';
-
-const ENCODING: KeyringPair$JsonEncodingTypes[] = ['scrypt', 'xsalsa20-poly1305'];
-const NONCE_LENGTH = 24;
-const PKCS8_DIVIDER = new Uint8Array([161, 35, 3, 33, 0]);
-const PKCS8_HEADER = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
-const PUB_LENGTH = 32;
-const SALT_LENGTH = 32;
-const SEC_LENGTH = 64;
-const SEED_LENGTH = 32;
-const SCRYPT_LENGTH = SALT_LENGTH + (3 * 4);
-
-export {
-  ENCODING,
-  NONCE_LENGTH,
-  PKCS8_DIVIDER,
-  PKCS8_HEADER,
-  PUB_LENGTH,
-  SALT_LENGTH,
-  SEC_LENGTH,
-  SEED_LENGTH,
-  SCRYPT_LENGTH
-};
+export const PKCS8_DIVIDER = new Uint8Array([161, 35, 3, 33, 0]);
+export const PKCS8_HEADER = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
+export const PUB_LENGTH = 32;
+export const SALT_LENGTH = 32;
+export const SEC_LENGTH = 64;
+export const SEED_LENGTH = 32;

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

@@ -1,8 +1,10 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { NONCE_LENGTH, SCRYPT_LENGTH } from '@polkadot/util-crypto/json/constants';
+
 import { createTestPairs } from '../testingPairs';
-import { NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH } from './defaults';
+import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH } from './defaults';
 
 const PKCS8_LENGTH = PKCS8_DIVIDER.length + PKCS8_HEADER.length + PUB_LENGTH + SEC_LENGTH;
 const ENCODED_LENGTH = 16 + PKCS8_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;

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

@@ -1,15 +1,17 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { hexToU8a } from '@polkadot/util';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
 import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';
 
-import { PAIRS } from '../testing';
+import { PAIRSSR25519 } from '../testing';
 import { createTestPairs } from '../testingPairs';
 import { createPair } from '.';
 
 const keyring = createTestPairs({ type: 'ed25519' }, false);
 
+const TEST_ADDRESS = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887';
+
 describe('pair', (): void => {
   beforeEach(async (): Promise<void> => {
     await cryptoWaitReady();
@@ -124,11 +126,11 @@ describe('pair', (): void => {
   });
 
   it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRS[0].publicKey, secretKey: PAIRS[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRSSR25519[0].publicKey, secretKey: PAIRSSR25519[0].secretKey }, {});
     const stash = alice.derive('//stash');
     const soft = alice.derive('//funding/0');
 
-    expect(stash.publicKey).toEqual(PAIRS[1].publicKey);
+    expect(stash.publicKey).toEqual(PAIRSSR25519[1].publicKey);
     expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
   });
 
@@ -142,11 +144,44 @@ describe('pair', (): void => {
   });
 
   describe('ethereum', (): void => {
+    const PUBLICDERIVED = new Uint8Array([
+      3, 129, 53, 27, 27, 70, 210, 96,
+      43, 9, 146, 187, 93, 85, 49, 249,
+      193, 105, 107, 8, 18, 254, 178, 83,
+      75, 104, 132, 173, 196, 126, 46, 29,
+      139
+    ]);
+    const SECRETDERIVED = new Uint8Array([
+      7, 13, 195, 17, 115, 0, 1, 25,
+      24, 226, 107, 2, 23, 105, 69, 204,
+      21, 195, 213, 72, 207, 73, 253, 132,
+      24, 217, 127, 147, 175, 105, 158, 70
+    ]);
+
     it('has a valid address from a known public', (): void => {
       const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') });
 
-      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
-      expect(pair.addressRaw).toEqual(hexToU8a('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'));
+      expect(pair.address).toEqual(TEST_ADDRESS);
+      expect(pair.addressRaw).toEqual(hexToU8a(TEST_ADDRESS));
+    });
+
+    it('has a valid address from a known ethereum address (20 length)', (): void => {
+      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: new Uint8Array([75, 32, 205, 127, 248, 119, 52, 31, 46, 171, 170, 23, 158, 23, 46, 108, 95, 180, 186, 168]), secretKey: new Uint8Array([]) });
+
+      expect(pair.address.toLowerCase()).toEqual('0x4b20cd7ff877341f2eabaa179e172e6c5fb4baa8');
+      expect(pair.addressRaw).toEqual(hexToU8a('0x4b20cd7ff877341f2eabaa179e172e6c5fb4baa8'));
+    });
+
+    it('converts to json', (): void => {
+      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: PUBLICDERIVED, secretKey: SECRETDERIVED });
+      const json = pair.toJson('password');
+
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ethereum'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+      expect(json.address).toEqual(u8aToHex(PUBLICDERIVED));
     });
   });
 });

packages/keyring/src/pair/index.ts

@@ -1,8 +1,9 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/json/types';
 import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import type { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import type { PairInfo } from './types';
 
 import { assert, u8aConcat, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
@@ -43,7 +44,7 @@ const TYPE_SIGNATURE = {
 const TYPE_ADDRESS = {
   ecdsa: (p: Uint8Array) => p.length > 32 ? blake2AsU8a(p) : p,
   ed25519: (p: Uint8Array) => p,
-  ethereum: (p: Uint8Array) => keccakAsU8a(secp256k1Expand(p)),
+  ethereum: (p: Uint8Array) => p.length === 20 ? p : keccakAsU8a(secp256k1Expand(p)),
   sr25519: (p: Uint8Array) => p
 };
 
@@ -87,7 +88,7 @@ function vrfHash (proof: Uint8Array, context?: string | Uint8Array, extra?: stri
  * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
  * property that indicates whether the public key value of the `encoded` property is encoded or not.
  */
-export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: EncryptedJsonEncoding[]): KeyringPair {
   const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
     const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
 
@@ -145,6 +146,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     // eslint-disable-next-line sort-keys
     decodePkcs8,
     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');
 
       const { path } = keyExtractPath(suri);
@@ -172,8 +174,13 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       );
     },
     toJson: (passphrase?: string): KeyringPair$Json => {
+      // NOTE: For ecdsa and ethereum, the publicKey cannot be extracted from the address. For these
+      // pass the hex-encoded publicKey through to the address portion of the JSON (before decoding)
+      // unless the publicKey is already an address
       const address = ['ecdsa', 'ethereum'].includes(type)
-        ? u8aToHex(secp256k1Compress(publicKey))
+        ? publicKey.length === 20
+          ? u8aToHex(publicKey)
+          : u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
       return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);

packages/keyring/src/pair/toJson.ts

@@ -2,34 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { KeypairType } from '@polkadot/util-crypto/types';
-import type { KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from '../types';
+import type { KeyringPair$Json, KeyringPair$Meta } from '../types';
 
-import { base64Encode } from '@polkadot/util-crypto';
-
-import { ENCODING } from './defaults';
+import { jsonEncryptFormat } from '@polkadot/util-crypto';
 
 interface PairStateJson {
   address: string;
   meta: KeyringPair$Meta;
 }
 
-// version 2 - nonce, encoded (previous)
-// version 3 - salt, nonce, encoded
-const VERSION = '3';
-
-const ENC_NONE: KeyringPair$JsonEncodingTypes[] = ['none'];
-
 export function pairToJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
   return {
+    ...jsonEncryptFormat(encoded, ['pkcs8', type], isEncrypted),
     address,
-    encoded: base64Encode(encoded),
-    encoding: {
-      content: ['pkcs8', type],
-      type: isEncrypted
-        ? ENCODING
-        : ENC_NONE,
-      version: VERSION
-    },
     meta
   };
 }

packages/keyring/src/pairs.ts

@@ -24,13 +24,11 @@ export class Pairs implements KeyringPairs {
   public get (address: string | Uint8Array): KeyringPair {
     const pair = this.#map[decodeAddress(address).toString()];
 
-    assert(pair, (): string => {
-      const formatted: string = isU8a(address) || isHex(address)
+    assert(pair, () => `Unable to retrieve keypair '${
+      isU8a(address) || isHex(address)
         ? u8aToHex(u8aToU8a(address))
-        : address;
-
-      return `Unable to retrieve keypair '${formatted}'`;
-    });
+        : address
+    }'`);
 
     return pair;
   }

packages/keyring/src/suri.spec.ts

@@ -18,6 +18,13 @@ const TESTS = {
       uri: `${PHRASE}//Alice`
     }
   ],
+  ethereum: [
+    {
+      pk: '0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b',
+      ss: '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d',
+      uri: "seed sock milk update focus rotate barely fade car face mechanic mercy/m/44'/60'/0'/0/0"
+    }
+  ],
   sr25519: [
     {
       pk: '0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a',

packages/keyring/src/testing.ts

@@ -4,6 +4,7 @@
 import type { KeyringInstance, KeyringOptions } from './types';
 
 import { hexToU8a } from '@polkadot/util';
+import { KeypairType } from '@polkadot/util-crypto/types';
 
 import { createPair } from './pair';
 import Keyring from '.';
@@ -13,53 +14,106 @@ interface PairDef {
   publicKey: Uint8Array;
   seed: string;
   secretKey?: Uint8Array;
-  type?: 'ed25519' | 'sr25519';
+  type: KeypairType
 }
 
 // NOTE This is not great since we have the secretKey here explicitly, but a testing
 // keyring is for testing - what happens is that in most cases the keyring is initialises
 // before anything else. Since the sr25519 crypto is async, this creates problems with
 // adding the keys when only the keyring is used.
-export const PAIRS: PairDef[] = [
+export const PAIRSSR25519: PairDef[] = [
   {
     publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
-    secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'),
-    seed: 'Alice'
+    secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'), // nosemgrep
+    seed: 'Alice',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
-    secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'),
-    seed: 'Alice//stash'
+    secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'), // nosemgrep
+    seed: 'Alice//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
-    secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'),
-    seed: 'Bob'
+    secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'), // nosemgrep
+    seed: 'Bob',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
-    secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'),
-    seed: 'Bob//stash'
+    secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'), // nosemgrep
+    seed: 'Bob//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
-    secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'),
-    seed: 'Charlie'
+    secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'), // nosemgrep
+    seed: 'Charlie',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
-    secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'),
-    seed: 'Dave'
+    secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'), // nosemgrep
+    seed: 'Dave',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
-    secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'),
-    seed: 'Eve'
+    secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'), // nosemgrep
+    seed: 'Eve',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
-    secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'),
-    seed: 'Ferdie'
+    secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'), // nosemgrep
+    seed: 'Ferdie',
+    type: 'sr25519'
+  }
+];
+
+export const PAIRSETHEREUM: PairDef[] = [
+  {
+    name: 'Alith',
+    publicKey: hexToU8a('0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f'),
+    secretKey: hexToU8a('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Baltathar',
+    publicKey: hexToU8a('0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518'),
+    secretKey: hexToU8a('0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Charleth',
+    publicKey: hexToU8a('0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e'),
+    secretKey: hexToU8a('0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Dorothy',
+    publicKey: hexToU8a('0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c'),
+    secretKey: hexToU8a('0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Ethan',
+    publicKey: hexToU8a('0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa'),
+    secretKey: hexToU8a('0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Faith',
+    publicKey: hexToU8a('0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74'),
+    secretKey: hexToU8a('0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df'), // nosemgrep
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
   }
 ];
 
@@ -71,13 +125,13 @@ export const PAIRS: PairDef[] = [
  */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
+  const pairs: PairDef[] = (options.type && options.type === 'ethereum') ? PAIRSETHEREUM : PAIRSSR25519;
 
-  PAIRS.forEach(({ name, publicKey, secretKey, seed, type = 'sr25519' }): void => {
+  pairs.forEach(({ name, publicKey, secretKey, seed, type }): void => {
     const meta = {
       isTesting: true,
       name: name || seed.replace('//', '_').toLowerCase()
     };
-
     const pair = !isDerived && !name
       ? keyring.addFromUri(seed, meta, options.type)
       : keyring.addPair(

packages/keyring/src/testingPairs.spec.ts

@@ -1,9 +1,13 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { u8aToHex } from '@polkadot/util';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 
 import { createTestPairs } from './testingPairs';
+import Keyring from '.';
+
+const TEST_ADD = '0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac';
 
 describe('testingPairs', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -27,4 +31,41 @@ describe('testingPairs', (): void => {
       createTestPairs({ type: 'ed25519' }).alice.address
     ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
   });
+
+  it('has the correct address for Alith (Eth)', (): void => {
+    expect(
+      createTestPairs({ type: 'ethereum' }).Alith.address
+    ).toEqual(TEST_ADD);
+  });
+
+  it('has the correct address for Alith (Eth), same as obtained by createFromUri', (): void => {
+    const keyring = new Keyring({ type: 'ethereum' });
+    const pair = keyring.createFromUri('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133');
+
+    expect(
+      pair && pair.address
+    ).toEqual(TEST_ADD);
+  });
+
+  it('checks eth test addresses', (): void => {
+    const ring = createTestPairs({ type: 'ethereum' });
+    const keyring = new Keyring({ type: 'ethereum' });
+    // priv keys generated by  ganache-cli --mnemonic "bottom drive obey lake curtain smoke basket hold race lonely fit walk"
+    const privKeys: string[] = ['0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133',
+      '0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b',
+      '0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b',
+      '0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68',
+      '0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4',
+      '0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df',
+      '0x96b8a38e12e1a31dee1eab2fffdf9d9990045f5b37e44d8cc27766ef294acf18',
+      '0x0d6dcaaef49272a5411896be8ad16c01c35d6f8c18873387b71fbc734759b0ab',
+      '0x4c42532034540267bf568198ccec4cb822a025da542861fcb146a5fab6433ff8',
+      '0x94c49300a58d576011096bcb006aa06f5a91b34b4383891e8029c21dc39fbb8b'];
+
+    delete ring.nobody;
+
+    Object.keys(ring).forEach((testKeyring, i) => {
+      if (i < 6) { expect(u8aToHex(ring[testKeyring].publicKey)).toEqual(u8aToHex(keyring.createFromUri(privKeys[i]).publicKey)); }
+    });
+  });
 });

packages/keyring/src/types.ts

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Prefix } from '@polkadot/util-crypto/address/types';
-import type { KeypairType } from '@polkadot/util-crypto/types';
+import type { EncryptedJson } from '@polkadot/util-crypto/json/types';
+import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
   ss58Format?: Prefix;
@@ -11,20 +12,8 @@ export interface KeyringOptions {
 
 export type KeyringPair$Meta = Record<string, unknown>;
 
-export type KeyringPair$JsonVersion = '0' | '1' | '2' | '3';
-
-export type KeyringPair$JsonEncodingTypes = 'none' | 'scrypt' | 'xsalsa20-poly1305';
-
-export interface KeyringPair$JsonEncoding {
-  content: ['pkcs8', KeypairType];
-  type: KeyringPair$JsonEncodingTypes | KeyringPair$JsonEncodingTypes[];
-  version: KeyringPair$JsonVersion;
-}
-
-export interface KeyringPair$Json {
+export interface KeyringPair$Json extends EncryptedJson {
   address: string;
-  encoded: string;
-  encoding: KeyringPair$JsonEncoding;
   meta: KeyringPair$Meta;
 }
 
@@ -73,9 +62,11 @@ export interface KeyringInstance {
   addFromAddress (address: string | Uint8Array, meta?: KeyringPair$Meta, encoded?: Uint8Array | null, type?: KeypairType, ignoreChecksum?: boolean): KeyringPair;
   addFromJson (pair: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
   addFromMnemonic (mnemonic: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+  addFromPair (pair: Keypair, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair
   addFromSeed (seed: Uint8Array, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   addFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   createFromJson (json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
+  createFromPair (pair: Keypair, meta: KeyringPair$Meta, type: KeypairType): KeyringPair
   createFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   getPair (address: string | Uint8Array): KeyringPair;
   getPairs (): KeyringPair[];

packages/networks/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@polkadot/networks",
-  "version": "5.7.1",
+  "version": "7.0.2",
+  "type": "module",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "main": "index.js",
   "sideEffects": false,
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -12,10 +16,10 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13"
+    "@babel/runtime": "^7.14.6"
   },
   "devDependencies": {
-    "@polkadot/util": "5.7.1",
-    "@polkadot/x-fetch": "5.7.1"
+    "@polkadot/util": "7.0.2",
+    "@polkadot/x-fetch": "7.0.2"
   }
 }

packages/networks/scripts/fromSubstrate.mjs

@@ -0,0 +1,59 @@
+// Copyright 2017-2021 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import fs from 'fs';
+import fetch from 'node-fetch';
+
+const SUBSTRATE_REGISTRY = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
+
+function outputField (v) {
+  if (typeof v === 'string') {
+    return `'${v}'`;
+  } else if (Array.isArray(v)) {
+    return `[${v.map((v) => outputField(v)).join(', ')}]`;
+  }
+
+  return v;
+}
+
+async function getSubstrateRegistry () {
+  const original = await fetch(SUBSTRATE_REGISTRY);
+  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(v)}`)
+        .join(',\n')}\n  }`
+    )
+    .join(',\n');
+}
+
+getSubstrateRegistry()
+  .then((entries) => {
+    fs.writeFileSync('packages/networks/src/substrate.ts', `// Copyright 2017-2021 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by yarn networks:sync (via scripts/fromSubstrate.mjs)
+//
+// Do not edit, rather
+//   - make a PR to the upstream registry as per ${SUBSTRATE_REGISTRY}
+//   - yarn networks: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,16 +1,17 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Ss58Registry } from './types';
+import type { KnownSubstrate, Ss58Registry } from './types';
 
 import fs from 'fs';
 
+import { stringify } from '@polkadot/util';
 import { fetch } from '@polkadot/x-fetch';
 
-import { all } from './';
+import { allNetworks } from './';
 
-const ORIGINAL = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
 const OUTPUT = './.github/ss58-check.md';
+const SUBSTRATE_REGISTRY = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
 
 function assertAndLog (check: boolean, error: string): void {
   if (!check) {
@@ -27,46 +28,44 @@ describe('check latest Substrate ss58 registry', (): void => {
   let original: Ss58Registry;
 
   beforeAll(async (): Promise<void> => {
-    original = (await (await fetch(ORIGINAL)).json()) as Ss58Registry;
+    original = (await (await fetch(SUBSTRATE_REGISTRY)).json()) as Ss58Registry;
   });
 
   it('has the same number as the original', (): void => {
-    assertAndLog(all.length === original.registry.length, `Number of entries mismatched:: Expected ${original.registry.length} found ${all.length}`);
+    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 }) => !all.some((n) => n.prefix === prefix))
+      .filter(({ prefix }) => !allNetworks.some((n) => n.prefix === prefix))
       .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
 
-    assertAndLog(!missing.length, `Missing entries found: ${JSON.stringify(missing, null, 2)}`);
+    assertAndLog(!missing.length, `Missing entries found: ${stringify(missing, 2)}`);
   });
 
   it('has no extra entries', (): void => {
-    const missing = all
+    const missing = allNetworks
       .filter(({ prefix }) => !original.registry.some((n) => n.prefix === prefix))
       .map(({ displayName, prefix }) => `${displayName} (${prefix})`);
 
-    assertAndLog(!missing.length, `Extra entries found: ${JSON.stringify(missing, null, 2)}`);
+    assertAndLog(!missing.length, `Extra entries found: ${stringify(missing, 2)}`);
   });
 
   it('has the same values as the original', (): void => {
-    const fields = Object.keys(original.schema);
+    const fields = Object.keys(original.schema) as (keyof KnownSubstrate)[];
     const errors = original.registry
       .map((n): [string, string[]] => {
-        const other = all.find(({ prefix }) => prefix === n.prefix);
+        const other = allNetworks.find(({ prefix }) => prefix === n.prefix);
 
         return [
           `${n.displayName} (${n.prefix})`,
           other
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            ? fields.filter((f) => JSON.stringify(n[f]) !== JSON.stringify(other[f]))
+            ? fields.filter((f) => stringify(n[f]) !== stringify(other[f]))
             : []
         ];
       })
       .filter(([, fields]) => fields.length);
 
-    assertAndLog(!errors.length, `Mismatches found: ${JSON.stringify(errors.map(([name, m]) => `${name}:: ${m.join(', ')}`), null, 2)}`);
+    assertAndLog(!errors.length, `Mismatches found: ${stringify(errors.map(([n, m]) => `${n}:: ${m.join(', ')}`), 2)}`);
   });
 });

packages/networks/src/defaults.spec.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2021 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isHex } from '@polkadot/util';
+
+import { knownGenesis, knownLedger } from './defaults';
+
+describe('defaults', (): void => {
+  it('has hex values for all genesis chains', (): void => {
+    expect(
+      Object.keys(knownGenesis).filter((network) =>
+        !knownGenesis[network].length ||
+        knownGenesis[network].some((g) => !isHex(g, 256))
+      )
+    ).toEqual([]);
+  });
+
+  it('has genesis for all Ledger chains', (): void => {
+    expect(
+      Object.keys(knownLedger).filter((network) =>
+        !knownGenesis[network]
+      )
+    ).toEqual([]);
+  });
+});

packages/networks/src/defaults.ts

@@ -0,0 +1,87 @@
+// Copyright 2017-2021 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KnownGenesis, KnownIcon, KnownLedger, KnownTestnet } 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
+// last. This make lookups for the current a simple genesisHash[0]
+// (See Kusama as an example)
+export const knownGenesis: KnownGenesis = {
+  centrifuge: [
+    '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
+  ],
+  'dock-mainnet': [
+    '0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'
+  ],
+  edgeware: [
+    '0x742a2ca70c2fda6cee4f8df98d64c4c670a052d9568058982dad9d5a7a135c5b'
+  ],
+  equilibrium: [
+    '0x6f1a800de3daff7f5e037ddf66ab22ce03ab91874debeddb1086f5f7dbd48925'
+  ],
+  hydradx: [
+    '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc', // Snakenet Gen3-1
+    '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9', // Snakenet Gen3
+    '0x3d75507dd46301767e601265791da1d9cb47b6ebc94e87347b635e5bf58bd047', // Snakenet Gen2
+    '0x0ed32bfcab4a83517fac88f2aa7cbc2f88d3ab93be9a12b6188a036bf8a943c2' // Snakenet Gen1
+  ],
+  karura: [
+    '0xbaf5aabe40646d11f0ee8abbdc64f4a4b7674925cba08e4a05ff9ebed6e2126b'
+  ],
+  kulupu: [
+    '0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'
+  ],
+  kusama: [
+    '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe', // Kusama CC3,
+    '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
+    '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
+  ],
+  plasm: [
+    '0x3e86364d4b4894021cb2a0390bcf2feb5517d5292f2de2bb9404227e908b0b8b'
+  ],
+  polkadot: [
+    '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
+  ],
+  polymesh: [
+    '0x9deeb940c92ae02111c3bd5baca89970384f4c9849f02a1b2e53e66414d30f9f'
+  ],
+  statemine: [
+    '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
+  ],
+  subsocial: [
+    '0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'
+  ]
+};
+
+// these are icon overrides
+export const knownIcon: KnownIcon = {
+  centrifuge: 'polkadot',
+  kusama: 'polkadot',
+  polkadot: '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 = {
+  centrifuge: 0x000002eb,
+  'dock-mainnet': 0x00000252,
+  edgeware: 0x0000020b,
+  equilibrium: 0x05f5e0fd,
+  kusama: 0x000001b2,
+  polkadot: 0x00000162,
+  polymesh: 0x00000253,
+  statemine: 0x000001b2 // common-good on Kusama, shares derivation
+};
+
+// testnets should not allow selection
+export const knownTestnet: KnownTestnet = {
+  'dock-testnet': true,
+  jupiter: true,
+  'mathchain-testnet': true,
+  'zero-alphaville': true
+};

packages/networks/src/index.spec.ts

@@ -1,14 +1,80 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import filtered, { available } from '.';
+import type { SubstrateNetwork } from './types';
 
-describe('filtered', (): void => {
+import { knownGenesis, knownIcon, knownLedger, knownTestnet } from './defaults';
+import { allNetworks, availableNetworks, selectableNetworks } from '.';
+
+describe('selectableNetworks', (): void => {
   it('has the correct starting order', (): void => {
-    expect(filtered.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
+    expect(selectableNetworks.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
   });
 
   it('has no ignored networks', (): void => {
-    expect(available.some(({ isIgnored }) => isIgnored)).toEqual(false);
+    expect(availableNetworks.some(({ isIgnored }) => isIgnored)).toEqual(false);
+  });
+
+  it('has no reserved networks', (): void => {
+    expect(availableNetworks.some(({ prefix }) => prefix === 47)).toEqual(false);
+  });
+
+  it('has allNetworks genesis information', (): void => {
+    expect(
+      Object.entries(knownGenesis).filter(([network, genesisHash]) =>
+        availableNetworks.some((a) =>
+          a.network === network &&
+          genesisHash.some((g, index) => a.genesisHash[index] !== g)
+        )
+      )
+    ).toEqual([]);
+  });
+
+  it('has allNetworks ledger details', (): void => {
+    expect(
+      Object.entries(knownLedger).filter(([network, slip44]) =>
+        availableNetworks.some((a) =>
+          a.network === network && (
+            a.slip44 !== slip44 ||
+            !a.hasLedgerSupport ||
+            !a.genesisHash.length
+          )
+        )
+      )
+    ).toEqual([]);
+  });
+
+  it('has no testnets exposed', (): void => {
+    expect(
+      Object.keys(knownTestnet).filter((network) =>
+        availableNetworks.some((a) =>
+          a.network === network
+        )
+      )
+    ).toEqual([]);
+  });
+
+  it('has allNetworks icons, except for overrides', (): void => {
+    expect(
+      availableNetworks.filter(({ icon, network }) =>
+        icon !== 'substrate' &&
+        knownIcon[network] !== icon
+      )
+    ).toEqual([]);
+  });
+
+  it('has no ss58 duplicates', (): void => {
+    const dupes: SubstrateNetwork[] = [];
+    const uniques: SubstrateNetwork[] = [];
+
+    allNetworks.forEach((a): void => {
+      if (uniques.some((u) => u.prefix === a.prefix)) {
+        dupes.push(a);
+      } else {
+        uniques.push(a);
+      }
+    });
+
+    expect(dupes).toEqual([]);
   });
 });

packages/networks/src/index.ts

@@ -1,482 +1,39 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// This contains exactly the same information as available in (with some extensions)
-// https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json
-//
-// Once the above is published as a package, the duplication here can be removed
+import type { Network, SubstrateNetwork } from './types';
 
-import type { Network, NetworkFromSubstrate, NetworkFromSubstrateNamed } from './types';
+import { knownGenesis, knownIcon, knownLedger, knownTestnet } from './defaults';
+import { knownSubstrate } from './substrate';
+
+export { packageInfo } from './packageInfo';
 
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
 
-// NOTE: In the case where the network was hard-spooned and multiple genesisHashes
-// are provided, it needs to be in reverse order, i.e. most-recent first, oldest
-// last. This make lookups for the current a simple genesisHash[0]
-// (See Kusama as an example)
+export const allNetworks = knownSubstrate.map((o): SubstrateNetwork => {
+  const network = o.network || '';
+  const n = o as SubstrateNetwork;
 
-const createReserved = (prefix: number, displayName: string, network: string | null = null): NetworkFromSubstrate => ({
-  decimals: null,
-  displayName,
-  isIgnored: true,
-  network,
-  prefix,
-  standardAccount: null,
-  symbols: null,
-  website: null
+  n.slip44 = knownLedger[network];
+  n.hasLedgerSupport = !!n.slip44;
+
+  n.genesisHash = knownGenesis[network] || [];
+  n.icon = knownIcon[network] || 'substrate';
+  n.isIgnored = !network || !!knownTestnet[network] || network.startsWith('reserved');
+
+  return n;
 });
 
-const all: NetworkFromSubstrate[] = [
-  {
-    decimals: [10],
-    displayName: 'Polkadot Relay Chain',
-    genesisHash: ['0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'],
-    hasLedgerSupport: true,
-    icon: 'polkadot',
-    network: 'polkadot',
-    prefix: 0,
-    slip44: 0x00000162,
-    standardAccount: '*25519',
-    symbols: ['DOT'],
-    website: 'https://polkadot.network'
-  },
-  createReserved(1, 'Bare 32-bit Schnorr/Ristretto (S/R 25519) public key.'),
-  {
-    decimals: [12],
-    displayName: 'Kusama Relay Chain',
-    genesisHash: [
-      '0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe', // Kusama CC3,
-      '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
-      '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
-    ],
-    hasLedgerSupport: true,
-    icon: 'polkadot',
-    network: 'kusama',
-    prefix: 2,
-    slip44: 0x000001b2,
-    standardAccount: '*25519',
-    symbols: ['KSM'],
-    website: 'https://kusama.network'
-  },
-  createReserved(3, 'Bare 32-bit Ed25519 public key.'),
-  {
-    decimals: null,
-    displayName: 'Katal Chain',
-    network: 'katalchain',
-    prefix: 4,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: null,
-    displayName: 'Plasm Network',
-    genesisHash: ['0x3e86364d4b4894021cb2a0390bcf2feb5517d5292f2de2bb9404227e908b0b8b'],
-    network: 'plasm',
-    prefix: 5,
-    standardAccount: '*25519',
-    symbols: ['PLM'],
-    website: null
-  },
-  {
-    decimals: [12],
-    displayName: 'Bifrost',
-    network: 'bifrost',
-    prefix: 6,
-    standardAccount: '*25519',
-    symbols: ['BNC'],
-    website: 'https://bifrost.finance/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Edgeware',
-    genesisHash: ['0x742a2ca70c2fda6cee4f8df98d64c4c670a052d9568058982dad9d5a7a135c5b'],
-    network: 'edgeware',
-    prefix: 7,
-    standardAccount: '*25519',
-    symbols: ['EDG'],
-    website: 'https://edgewa.re'
-  },
-  {
-    decimals: [18],
-    displayName: 'Acala Karura Canary',
-    network: 'karura',
-    prefix: 8,
-    standardAccount: '*25519',
-    symbols: ['KAR'],
-    website: 'https://acala.network/'
-  },
-  {
-    decimals: [18],
-    displayName: 'Laminar Reynolds Canary',
-    network: 'reynolds',
-    prefix: 9,
-    standardAccount: '*25519',
-    symbols: ['REY'],
-    website: 'http://laminar.network/'
-  },
-  {
-    decimals: [18],
-    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',
-    genesisHash: ['0x12fddc9e2128b3fe571e4e5427addcb87fcaf08493867a68dd6ae44b406b39c7'],
-    hasLedgerSupport: true,
-    network: 'polymesh',
-    prefix: 12,
-    slip44: 0x00000253,
-    standardAccount: '*25519',
-    symbols: ['POLYX'],
-    website: 'https://polymath.network/'
-  },
-  {
-    decimals: null,
-    displayName: 'SubstraTEE',
-    network: 'substratee',
-    prefix: 13,
-    standardAccount: '*25519',
-    symbols: null,
-    website: 'https://www.substratee.com'
-  },
-  {
-    decimals: [0],
-    displayName: 'Totem',
-    network: 'totem',
-    prefix: 14,
-    standardAccount: '*25519',
-    symbols: ['XTX'],
-    website: 'https://totemaccounting.com'
-  },
-  {
-    decimals: [12],
-    displayName: 'Synesthesia',
-    network: 'synesthesia',
-    prefix: 15,
-    standardAccount: '*25519',
-    symbols: ['SYN'],
-    website: 'https://synesthesia.network/'
-  },
-  {
-    decimals: [12],
-    displayName: 'Kulupu',
-    genesisHash: ['0xf7a99d3cb92853d00d5275c971c132c074636256583fee53b3bbe60d7b8769ba'],
-    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',
-    genesisHash: ['0x290a4149f09ea0e402c74c1c7e96ae4239588577fe78932f94f5404c68243d80'],
-    network: 'stafi',
-    prefix: 20,
-    standardAccount: '*25519',
-    symbols: ['FIS'],
-    website: 'https://stafi.io'
-  },
-  {
-    decimals: [6],
-    displayName: 'Dock Testnet',
-    isIgnored: true, // testnet
-    network: 'dock-testnet',
-    prefix: 21,
-    standardAccount: '*25519',
-    symbols: ['DCK'],
-    website: 'https://dock.io'
-  },
-  {
-    decimals: [6],
-    displayName: 'Dock Mainnet',
-    genesisHash: ['0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'],
-    hasLedgerSupport: true,
-    network: 'dock-mainnet',
-    prefix: 22,
-    slip44: 0x00000252,
-    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',
-    isIgnored: true, // testnet
-    network: 'zero-alphaville',
-    prefix: 25,
-    standardAccount: '*25519',
-    symbols: ['PLAY'],
-    website: 'https://zero.io'
-  },
-  {
-    decimals: [10],
-    displayName: 'Jupiter',
-    isIgnored: true, // testnet
-    network: 'jupiter',
-    prefix: 26,
-    standardAccount: '*25519',
-    symbols: ['jDOT'],
-    website: 'https://jupiter.patract.io'
-  },
-  {
-    decimals: [10, 12],
-    displayName: 'Patract',
-    network: 'patract',
-    prefix: 27,
-    standardAccount: '*25519',
-    symbols: ['pDOT', 'pKSM'],
-    website: 'https://patract.network'
-  },
-  {
-    decimals: null,
-    displayName: 'Subsocial',
-    genesisHash: ['0x0bd72c1c305172e1275278aaeb3f161e02eccb7a819e63f62d47bd53a28189f8'],
-    network: 'subsocial',
-    prefix: 28,
-    standardAccount: '*25519',
-    symbols: null,
-    website: null
-  },
-  {
-    decimals: [18],
-    displayName: 'Dhiway CORD Network',
-    network: 'cord',
-    prefix: 29,
-    standardAccount: '*25519',
-    symbols: ['DCU'],
-    website: 'https://dhiway.com/'
-  },
-  {
-    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: ['RAD'],
-    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',
-    isIgnored: true, // 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.dev/'
-  },
-  createReserved(43, 'Bare 32-bit ECDSA SECP-256k1 public key.'),
-  {
-    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'
-  },
-  createReserved(46, 'This prefix is reserved.', 'reserved46'),
-  createReserved(47, 'This prefix is reserved.', 'reserved47'),
-  {
-    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'
-  }
-];
-
 // The list of available/claimed prefixes
 //   - no testnets
 //   - we only include those where we have a standardAccount
 //   - when no icon has been specified, default to substrate
 //   - sort by name, however we keep 0, 2, 42 first in the list
-const available: Network[] = all
-  .filter((n): n is NetworkFromSubstrateNamed => !n.isIgnored && !!n.network)
-  .map((n) => ({ ...n, genesisHash: n.genesisHash || [], icon: n.icon || 'substrate' }))
+export const availableNetworks = allNetworks
+  .filter((n): n is Network => !n.isIgnored && !!n.network)
   .sort((a, b) =>
-    UNSORTED.includes(a.prefix) && UNSORTED.includes(b.prefix)
+    UNSORTED.includes(a.prefix) === UNSORTED.includes(b.prefix)
       ? 0
       : UNSORTED.includes(a.prefix)
         ? -1
@@ -486,8 +43,4 @@ const available: Network[] = all
   );
 
 // A filtered list of those chains we have details about (genesisHashes)
-const filtered: Network[] = available.filter((n) => n.genesisHash.length || n.prefix === 42);
-
-export { all, available };
-
-export default filtered;
+export const selectableNetworks = availableNetworks.filter((n) => n.genesisHash.length || n.prefix === 42);

packages/networks/src/packageInfo.ts

@@ -1,6 +1,6 @@
-// Copyright 2017-2021 @polkadot/dev authors & contributors
+// Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/networks', version: '5.7.1' };
+export const packageInfo = { name: '@polkadot/networks', version: '7.0.2' };

packages/networks/src/substrate.ts

@@ -0,0 +1,599 @@
+// Copyright 2017-2021 @polkadot/networks authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Auto-generated by yarn networks:sync (via scripts/fromSubstrate.mjs)
+//
+// Do not edit, rather
+//   - make a PR to the upstream registry as per https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json
+//   - yarn networks: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: null,
+    prefix: 1,
+    standardAccount: null,
+    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: null,
+    prefix: 3,
+    standardAccount: null,
+    symbols: null,
+    website: null
+  },
+  {
+    decimals: null,
+    displayName: 'Katal Chain',
+    network: 'katalchain',
+    prefix: 4,
+    standardAccount: '*25519',
+    symbols: null,
+    website: null
+  },
+  {
+    decimals: [15],
+    displayName: 'Plasm Network',
+    network: 'plasm',
+    prefix: 5,
+    standardAccount: '*25519',
+    symbols: ['PLM'],
+    website: 'https://plasmnet.io'
+  },
+  {
+    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: null,
+    displayName: 'SubstraTEE',
+    network: 'substratee',
+    prefix: 13,
+    standardAccount: '*25519',
+    symbols: null,
+    website: 'https://www.substratee.com'
+  },
+  {
+    decimals: [0],
+    displayName: 'Totem',
+    network: 'totem',
+    prefix: 14,
+    standardAccount: '*25519',
+    symbols: ['XTX'],
+    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: [18],
+    displayName: 'Dhiway CORD Network',
+    network: 'cord',
+    prefix: 29,
+    standardAccount: '*25519',
+    symbols: ['DCU'],
+    website: 'https://dhiway.com/'
+  },
+  {
+    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.dev/'
+  },
+  {
+    decimals: null,
+    displayName: 'Bare 32-bit ECDSA SECP-256k1 public key.',
+    network: null,
+    prefix: 43,
+    standardAccount: null,
+    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: '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: [0, 9, 9, 9, 9, 9, 9, 9],
+    displayName: 'Equilibrium Network',
+    network: 'equilibrium',
+    prefix: 67,
+    standardAccount: '*25519',
+    symbols: ['Unknown', 'USD', 'EQ', 'ETH', 'BTC', 'EOS', 'DOT', 'CRV'],
+    website: 'https://equilibrium.io'
+  },
+  {
+    decimals: [18],
+    displayName: 'SORA Network',
+    network: 'sora',
+    prefix: 69,
+    standardAccount: '*25519',
+    symbols: ['XOR'],
+    website: 'https://sora.org'
+  },
+  {
+    decimals: [12],
+    displayName: 'Manta network',
+    network: 'manta',
+    prefix: 77,
+    standardAccount: '*25519',
+    symbols: ['MA'],
+    website: 'https://manta.network'
+  },
+  {
+    decimals: [12],
+    displayName: 'Calamari: Manta Canary Network',
+    network: 'calamari',
+    prefix: 78,
+    standardAccount: '*25519',
+    symbols: ['KMA'],
+    website: 'https://manta.network'
+  },
+  {
+    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: [12],
+    displayName: 'Heiko',
+    network: 'heiko',
+    prefix: 110,
+    standardAccount: '*25519',
+    symbols: ['HKO'],
+    website: 'https://parallel.fi/'
+  },
+  {
+    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: [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: 'Basilisk',
+    network: 'basilisk',
+    prefix: 10041,
+    standardAccount: '*25519',
+    symbols: ['BSX'],
+    website: 'https://bsx.fi'
+  }
+];

packages/networks/src/types.ts

@@ -3,32 +3,38 @@
 
 export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate';
 
-export interface NetworkFromSubstrate {
+export interface KnownSubstrate {
   decimals: number[] | null,
   displayName: string;
   network: string | null;
   prefix: number;
-  genesisHash?: string[] | null;
-  hasLedgerSupport?: boolean;
-  icon?: Icon | null;
-  isIgnored?: boolean;
-  slip44?: number;
-  standardAccount: '*25519' | null;
+  standardAccount: '*25519' | 'secp256k1' | null;
   symbols: string[] | null;
   website: string | null;
 }
 
-export interface NetworkFromSubstrateNamed extends NetworkFromSubstrate {
+export type KnownIcon = Record<string, Icon>;
+
+export type KnownLedger = Record<string, number>;
+
+export type KnownGenesis = Record<string, string[]>;
+
+export type KnownTestnet = Record<string, true>;
+
+export interface SubstrateNetwork extends KnownSubstrate {
+  genesisHash: string[];
+  hasLedgerSupport: boolean;
+  icon: Icon;
+  isIgnored: boolean;
+  slip44?: number | null;
+}
+
+export interface Network extends SubstrateNetwork {
   network: string;
 }
 
-export interface Network extends NetworkFromSubstrateNamed {
-  genesisHash: string[];
-  icon: Icon;
-}
-
 export interface Ss58Registry {
-  registry: NetworkFromSubstrate[];
+  registry: KnownSubstrate[];
   specification: string;
   schema: Record<string, string>;
 }

packages/util-crypto/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "5.7.1",
+  "version": "7.0.2",
+  "type": "module",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "sideEffects": [
+    "./cryptoInit.js",
+    "./cryptoInit.cjs",
     "./detectPackage.js",
-    "./detectPackage.mjs"
+    "./detectPackage.cjs"
   ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
@@ -15,13 +21,14 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.13",
-    "@polkadot/networks": "5.7.1",
-    "@polkadot/util": "5.7.1",
-    "@polkadot/wasm-crypto": "^3.2.3",
-    "@polkadot/x-randomvalues": "5.7.1",
+    "@babel/runtime": "^7.14.6",
+    "@polkadot/networks": "7.0.2",
+    "@polkadot/util": "7.0.2",
+    "@polkadot/wasm-crypto": "^4.1.2",
+    "@polkadot/x-randomvalues": "7.0.2",
     "base-x": "^3.0.8",
-    "blakejs": "^1.1.0",
+    "base64-js": "^1.5.1",
+    "blakejs": "^1.1.1",
     "bn.js": "^4.11.9",
     "create-hash": "^1.2.0",
     "elliptic": "^6.5.4",
@@ -34,11 +41,11 @@
   "devDependencies": {
     "@types/bn.js": "^4.11.6",
     "@types/create-hash": "^1.2.2",
-    "@types/elliptic": "^6.4.12",
+    "@types/elliptic": "^6.4.13",
     "@types/scryptsy": "^2.0.0",
     "@types/xxhashjs": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.7.1"
+    "@polkadot/util": "7.0.2"
   }
 }

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

@@ -17,6 +17,18 @@ describe('checkAddressChecksum', (): void => {
     ).toEqual([true, 34, 2, 66]);
   });
 
+  it('correctly extracts the info from a 2-byte-prefix address (69)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('cnVvyMzRdqjwejTFuByQQ4w2yu78V2hpFixjHQz5zr6NSYsxA'))
+    ).toEqual([true, 34, 2, 69]);
+  });
+
+  it('correctly extracts the info from a 2-byte-prefix address (252)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('xw8Ffc2SZtDqUJKd9Ky4vc7PRz2D2asuVkEEzf3WGAbw9cnfq'))
+    ).toEqual([true, 34, 2, 252]);
+  });
+
   it('correctly extracts the info from a 2-byte-prefix address (255)', (): void => {
     expect(
       checkAddressChecksum(base58Decode('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k'))

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

@@ -89,6 +89,22 @@ describe('decodeAddress', (): void => {
     );
   });
 
+  it('decodes a 2-byte prefix (69)', (): void => {
+    expect(
+      decodeAddress('cnUaoo5wodnTVA4bnr4woSweto8hWZADUvLFXkR9Q6U7BRsbF')
+    ).toEqual(
+      hexToU8a('0x88eafe0305d460d1695cf34c2f786050df8e40d215e488790cc70929c9e8316d')
+    );
+  });
+
+  it('decodes a 2-byte prefix (252)', (): void => {
+    expect(
+      decodeAddress('xw9Hca4RJTmBRgzJT4ieJBh7XCK9gE3NXBDSEmgGHd4TCrbnG')
+    ).toEqual(
+      hexToU8a('0xfc422da6c3bc6dfa2a436a506428072941662f816987baaa8914e02ff5947f4b')
+    );
+  });
+
   it('decodes a 2-byte prefix (255)', (): void => {
     expect(
       decodeAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
@@ -103,12 +119,6 @@ describe('decodeAddress', (): void => {
     ).toEqual('0x035676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba9');
   });
 
-  it.skip('allows invalid prefix (in list)', (): void => {
-    expect(
-      (): Uint8Array => decodeAddress('6GfvWUvHvU8otbZ7sFhXH4eYeMcKdUkL61P3nFy52efEPVUx')
-    ).toThrow(/address prefix/);
-  });
-
   it('fails when length is invalid', (): void => {
     expect(
       (): Uint8Array => decodeAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')

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

@@ -10,7 +10,9 @@ import { base58Decode } from '../base58/decode';
 import { checkAddressChecksum } from './checksum';
 import { defaults } from './defaults';
 
-export function decodeAddress (encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
+export function decodeAddress (encoded?: string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
+  assert(encoded, 'Invalid empty address passed');
+
   if (isU8a(encoded) || isHex(encoded)) {
     return u8aToU8a(encoded);
   }
@@ -23,7 +25,7 @@ export function decodeAddress (encoded: string | Uint8Array, ignoreChecksum?: bo
     const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
 
     assert(ignoreChecksum || isValid, 'Invalid decoded address checksum');
-    assert([-1, ss58Decoded].includes(ss58Format), `Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+    assert([-1, ss58Decoded].includes(ss58Format), () => `Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
 
     return decoded.slice(ss58Length, endPos);
   } catch (error) {

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

@@ -1,12 +1,12 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { available } from '@polkadot/networks';
+import { availableNetworks } from '../networks';
 
 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: available.map(({ prefix }) => prefix),
+  allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
   prefix: 42
 };

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

@@ -26,12 +26,24 @@ const SUBKEY = [
     publicKey: '0x04a047d52fe542484c69bc528990cfeaf3a663dded0638ee1b51cf78bacd1072',
     ss58Format: 66
   },
+  {
+    // sora
+    address: 'cnVRwXfAnz3RSVQyBUC8f8McrK3YBX2QYd4WoctpeSC6VTJYm',
+    publicKey: '0xae640d53cfa815f4a6a50ae70235cd7d9d134d0f1c3a4ccd118e321dfb6ab51f',
+    ss58Format: 69
+  },
   {
     // ecdsa
     address: '4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV',
     publicKey: '0x035676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba9',
     ss58Format: 200
   },
+  {
+    // social-network
+    address: 'xw5g1Eec8LT99pZLZMaTWwrwvNtfM6vrSuZeVbtEszCDUwByg',
+    publicKey: '0x5c64f1151f0ce4358c27238fb20c88e7c899825436f565410724c8c2c5add869',
+    ss58Format: 252
+  },
   {
     address: 'yGF4JP7q5AK46d1FPCEm9sYQ4KooSjHMpyVAjLnsCSWVafPnf',
     publicKey: '0x66cd6cf085627d6c85af1aaf2bd10cf843033e929b4e3b1c2ba8e4aa46fe111b',

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

@@ -11,27 +11,27 @@ import { decodeAddress } from './decode';
 import { defaults } from './defaults';
 import { sshash } from './sshash';
 
-export function encodeAddress (_key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
+export function encodeAddress (key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
   // decode it, this means we can re-encode an address
-  const key = decodeAddress(_key);
+  const u8a = decodeAddress(key);
 
   assert(ss58Format >= 0 && ss58Format <= 16383 && ![46, 47].includes(ss58Format), 'Out of range ss58Format specified');
-  assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
+  assert(defaults.allowedDecodedLengths.includes(u8a.length), () => `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
 
-  const isPublicKey = [32, 33].includes(key.length);
   const input = u8aConcat(
-    new Uint8Array(
-      ss58Format < 64
-        ? [ss58Format]
-        : [
-          ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
-          (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
-        ]
-    ),
-    key
+    ss58Format < 64
+      ? [ss58Format]
+      : [
+        ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
+        (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
+      ],
+    u8a
   );
 
   return base58Encode(
-    u8aConcat(input, sshash(input).subarray(0, isPublicKey ? 2 : 1))
+    u8aConcat(
+      input,
+      sshash(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)
+    )
   );
 }

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type BN from 'bn.js';
+import type { BN } from '@polkadot/util';
 import type { Prefix } from './types';
 
 import { decodeAddress } from './decode';

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type BN from 'bn.js';
+import type { BN } from '@polkadot/util';
 import type { Prefix } from './types';
 
 import { encodeAddress } from './encode';

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

@@ -13,5 +13,7 @@ export { encodeDerivedAddress } from './encodeDerived';
 export { encodeMultiAddress } from './encodeMulti';
 export { evmToAddress } from './evmToAddress';
 export { addressEq } from './eq';
+export { isAddress } from './is';
 export { setSS58Format } from './setSS58Format';
 export { sortAddresses } from './sort';
+export { validateAddress } from './validate';

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

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

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type BN from 'bn.js';
+import type { BN } from '@polkadot/util';
 
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type BN from 'bn.js';
+import type { BN } from '@polkadot/util';
 
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
 

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

@@ -3,12 +3,18 @@
 
 import type { Prefix } from './types';
 
+import { logger } from '@polkadot/util';
+
 import { defaults } from './defaults';
 
+const l = logger('setSS58Format');
+
 /**
  * @description Sets the global SS58 format to use for address encoding
  * @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');
+
   defaults.prefix = prefix;
 }

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

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

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

@@ -2,10 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // https://github.com/multiformats/js-multibase/blob/master/src/constants.js
-const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
-const BITS_PER_CHAR = 5;
-
-export {
-  BASE32_ALPHABET,
-  BITS_PER_CHAR
-};
+export const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+export const BITS_PER_CHAR = 5;

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

@@ -11,6 +11,6 @@ export function testValidator (validate: (value?: string | null, ipfsCompat?: bo
   }
 }
 
-export function isBase32 (value?: string | null, ipfsCompat?: boolean): boolean {
+export function isBase32 (value?: string | null, ipfsCompat?: boolean): value is string {
   return testValidator(base32Validate, value, ipfsCompat);
 }

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

@@ -10,8 +10,8 @@ const BASE_CONFIG = { alphabet: BASE32_ALPHABET, ipfsChar: 'b', type: 'base32' }
  * @name base32Validate
  * @summary Validates a base32 value.
  * @description
- * Validates the the supplied value is valid base32
+ * Validates that the supplied value is valid base32
  */
-export function base32Validate (value?: string | null, ipfsCompat?: boolean): true {
+export function base32Validate (value?: string | null, ipfsCompat?: boolean): value is string {
   return validateChars(BASE_CONFIG, value, ipfsCompat);
 }

packages/util-crypto/src/base58/bs58.ts

@@ -4,11 +4,6 @@
 import baseX from 'base-x';
 
 // https://github.com/cryptocoinjs/base-x#alphabets
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+export const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
-const bs58 = baseX(BASE58_ALPHABET);
-
-export {
-  BASE58_ALPHABET,
-  bs58
-};
+export const bs58 = baseX(BASE58_ALPHABET);

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+import { u8aToU8a } from '@polkadot/util';
 
 import { bs58 } from './bs58';
 
@@ -12,9 +12,7 @@ import { bs58 } from './bs58';
  * From the provided input, create the base58 and return the result as a string.
  */
 export function base58Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat?: boolean): string {
-  const out = bs58.encode(
-    u8aToBuffer(u8aToU8a(value))
-  );
+  const out = bs58.encode(u8aToU8a(value));
 
   return ipfsCompat
     ? `z${out}`

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

@@ -4,6 +4,6 @@
 import { testValidator } from '../base32/is';
 import { base58Validate } from './validate';
 
-export function isBase58 (value?: string | null, ipfsCompat?: boolean): boolean {
+export function isBase58 (value?: string | null, ipfsCompat?: boolean): value is string {
   return testValidator(base58Validate, value, ipfsCompat);
 }

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

@@ -13,12 +13,12 @@ interface CheckConfig {
 
 const BASE_CONFIG = { alphabet: BASE58_ALPHABET, ipfsChar: 'z', type: 'base58' };
 
-export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?: string | null, ipfsCompat?: boolean): true {
-  assert(value, `Expected non-null, non-empty ${type} input`);
-  assert(!ipfsCompat || value[0] === ipfsChar, `Expected ${type} to start with '${ipfsChar}'`);
+export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?: unknown, ipfsCompat?: boolean): true {
+  assert(value && typeof value === 'string', () => `Expected non-null, non-empty ${type} string input`);
+  assert(!ipfsCompat || value[0] === ipfsChar, () => `Expected ${type} to start with '${ipfsChar}'`);
 
   for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
-    assert(alphabet.includes(value[i]), `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+    assert(alphabet.includes(value[i]), () => `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
   }
 
   return true;
@@ -28,8 +28,8 @@ export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?
  * @name base58Validate
  * @summary Validates a base58 value.
  * @description
- * Validates the the supplied value is valid base58
+ * Validates that the supplied value is valid base58
  */
-export function base58Validate (value?: string | null, ipfsCompat?: boolean): true {
+export function base58Validate (value?: string | null, ipfsCompat?: boolean): value is string {
   return validateChars(BASE_CONFIG, value, ipfsCompat);
 }

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { bufferToU8a } from '@polkadot/util';
+import base64 from 'base64-js';
 
 import { base64Validate } from './validate';
 
@@ -14,5 +14,5 @@ import { base64Validate } from './validate';
 export function base64Decode (value: string): Uint8Array {
   base64Validate(value);
 
-  return bufferToU8a(Buffer.from(value, 'base64'));
+  return base64.toByteArray(value);
 }

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

@@ -1,7 +1,9 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+import base64 from 'base64-js';
+
+import { u8aToU8a } from '@polkadot/util';
 
 /**
  * @name base64Encode
@@ -10,5 +12,5 @@ import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
  * From the provided input, create the base64 and return the result as a string.
  */
 export function base64Encode (value: Uint8Array | string | Buffer | number[]): string {
-  return u8aToBuffer(u8aToU8a(value)).toString('base64');
+  return base64.fromByteArray(u8aToU8a(value));
 }

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

@@ -3,7 +3,7 @@
 
 import { base64Validate } from './validate';
 
-export function isBase64 (value?: string | null): boolean {
+export function isBase64 (value?: string | null): value is string {
   try {
     return base64Validate(value);
   } catch (error) {

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

@@ -7,10 +7,10 @@ import { assert } from '@polkadot/util';
  * @name base64Validate
  * @summary Validates a base64 value.
  * @description
- * Validates the the supplied value is valid base64
+ * Validates that the supplied value is valid base64
  */
-export function base64Validate (value?: string | null): true {
-  assert(value, 'Expected non-null, non-empty base64 input');
+export function base64Validate (value?: string | null): value is string {
+  assert(value && typeof value === 'string', 'Expected non-null, non-empty base64 string input');
   assert(/^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value), 'Invalid base64 encoding');
 
   return true;

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

@@ -11,35 +11,43 @@ describe('blake2AsHex', (): void => {
     await waitReady();
   });
 
-  it('returns a 64-bit value (specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 64)
-    ).toEqual('0xd8bb14d833d59559');
-  });
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value (specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 64, null, onlyJs)
+      ).toEqual('0xd8bb14d833d59559');
+    });
 
-  it('returns a 128-bit value (as specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 128)
-    ).toEqual('0xcf4ab791c62b8d2b2109c90275287816');
-  });
+    it('returns a 128-bit value (as specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 128, null, onlyJs)
+      ).toEqual('0xcf4ab791c62b8d2b2109c90275287816');
+    });
 
-  it('returns a 256-bit value (default)', (): void => {
-    expect(
-      blake2AsHex('abc')
-    ).toEqual('0xbddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319');
-  });
+    it('returns a 128-bit value (as specified, with key)', (): void => {
+      expect(
+        blake2AsHex('abc', 128, new Uint8Array([1, 2]), onlyJs)
+      ).toEqual('0x36f3d08cda72a00ddf2be103eb5770d9');
+    });
 
-  it('returns a 512-bit value (as specified)', (): void => {
-    expect(
-      blake2AsHex('abc', 512)
-    ).toEqual('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923');
-  });
+    it('returns a 256-bit value (default)', (): void => {
+      expect(
+        blake2AsHex('abc', undefined, null, onlyJs)
+      ).toEqual('0xbddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319');
+    });
 
-  it('matches with the Rust implementation', (): void => {
-    expect(
-      blake2AsHex(
-        hexToU8a('0x454545454545454545454545454545454545454545454545454545454545454501000000000000002481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29dbdbf025dd4a69a6f4ee6e1577b251b655097e298b692cb34c18d3182cac3de0dc00000000'), 256
-      )
-    ).toEqual('0x1025e5db74fdaf4d2818822dccf0e1604ae9ccc62f26cecfde23448ff0248abf');
+    it('returns a 512-bit value (as specified)', (): void => {
+      expect(
+        blake2AsHex('abc', 512, null, onlyJs)
+      ).toEqual('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923');
+    });
+
+    it('matches with the Rust implementation', (): void => {
+      expect(
+        blake2AsHex(
+          hexToU8a('0x454545454545454545454545454545454545454545454545454545454545454501000000000000002481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29dbdbf025dd4a69a6f4ee6e1577b251b655097e298b692cb34c18d3182cac3de0dc00000000'), 256, undefined, onlyJs
+        )
+      ).toEqual('0x1025e5db74fdaf4d2818822dccf0e1604ae9ccc62f26cecfde23448ff0248abf');
+    });
   });
 });

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

@@ -19,8 +19,8 @@ import { blake2AsU8a } from './asU8a';
  * blake2AsHex('abc'); // => 0xba80a53f981c4d0d
  * ```
  */
-export function blake2AsHex (data: Uint8Array | string, bitLength = 256): string {
+export function blake2AsHex (data: Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): string {
   return u8aToHex(
-    blake2AsU8a(data, bitLength)
+    blake2AsU8a(data, bitLength, key, onlyJs)
   );
 }

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

@@ -11,38 +11,32 @@ describe('blake2AsU8a', (): void => {
     await waitReady();
   });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 64-bit value by default (onlyJs=${onlyJs.toString()})`, (): void => {
+  describe.each([false, true])('onlyJs=%p', (onlyJs): void => {
+    it('returns a 64-bit value by default', (): void => {
       expect(
         blake2AsU8a('abc', undefined, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 128-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 128-bit value (as specified,)', (): void => {
       expect(
         blake2AsU8a('abc', 128, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([207, 74, 183, 145, 198, 43, 141, 43, 33, 9, 201, 2, 117, 40, 120, 22])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 256-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 256-bit value (as specified)', (): void => {
       expect(
         blake2AsU8a('abc', 256, undefined, onlyJs)
       ).toEqual(
         new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
       );
     });
-  });
 
-  [false, true].forEach((onlyJs): void => {
-    it(`returns a 512-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+    it('returns a 512-bit value (as specified)', (): void => {
       expect(
         blake2AsU8a('abc', 512, undefined, onlyJs)
       ).toEqual(

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

@@ -20,10 +20,10 @@ import { blake2b, isReady } from '@polkadot/wasm-crypto';
  * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa53, 0xf98, 0x1c, 0x4d, 0x0d]
  * ```
  */
-export function blake2AsU8a (data: Uint8Array | string, bitLength = 256, key: Uint8Array | null = null, onlyJs = false): Uint8Array {
+export function blake2AsU8a (data: Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): Uint8Array {
   const byteLength = Math.ceil(bitLength / 8);
 
   return isReady() && !onlyJs
     ? blake2b(u8aToU8a(data), u8aToU8a(key), byteLength)
-    : js.blake2b(u8aToU8a(data), key, byteLength);
+    : js.blake2b(u8aToU8a(data), key || undefined, byteLength);
 }

packages/util-crypto/src/bundle.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './cryptoInit';
+
+export { packageInfo } from './packageInfo';
+
+// all internal exports
+export * from './address';
+export * from './base32';
+export * from './base58';
+export * from './base64';
+export * from './blake2';
+export * from './crypto';
+export * from './ethereum';
+export * from './hd';
+export * from './hmac';
+export * from './json';
+export * from './keccak';
+export * from './key';
+export * from './mnemonic';
+export * from './networks';
+export * from './nacl';
+export * from './pbkdf2';
+export * from './random';
+export * from './schnorrkel';
+export * from './scrypt';
+export * from './secp256k1';
+export * from './sha512';
+export * from './signature';
+export * from './xxhash';

packages/util-crypto/src/detectPackage.ts

@@ -1,25 +1,10 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// For esm, this should be import.meta.url or to get the same behavior as __dirname, we can use
-//
-//   new URL(import.meta.url).pathname)
-//
-// The issue is the WP4 has "some" issues with import.meta.url. So because of bundlers, we can't have
-// nice things... In this case it is even worse since import.meta.url won't even make it compile, so
-// there is a complete dead end with usage thereof
-//
-// When that is fixed, a solution is to have both .js & .mjs files, with the following content -
-//
-// cjs: util.detectPackage(packageInfo, () => __dirname);
-// esm: detectPackage(packageInfo, () => import.meta.url);
-//
-// With the above we additionally need a .d.ts to just export the packageInfo
-
-import { detectPackage } from '@polkadot/util';
+import { packageInfo as netInfo } from '@polkadot/networks/packageInfo';
+import { detectPackage, packageInfo as utilInfo } from '@polkadot/util';
+import { packageInfo as randomInfo } from '@polkadot/x-randomvalues';
 
 import { packageInfo } from './packageInfo';
 
-detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
-
-export { packageInfo };
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [netInfo, utilInfo, randomInfo]);

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

@@ -8,9 +8,7 @@ import { isEthereumChecksum } from './isChecksum';
 export function isEthereumAddress (address?: string): boolean {
   if (!address || address.length !== 42 || !isHex(address)) {
     return false;
-  }
-
-  if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+  } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
     return true;
   }
 

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

@@ -6,7 +6,11 @@ import { u8aToHex } from '@polkadot/util';
 import { keccakAsU8a } from '../keccak';
 
 function isInvalidChar (char: string, byte: number): boolean {
-  return (byte > 7 && char !== char.toUpperCase()) || (byte <= 7 && char !== char.toLowerCase());
+  return char !== (
+    byte > 7
+      ? char.toUpperCase()
+      : char.toLowerCase()
+  );
 }
 
 export function isEthereumChecksum (_address: string): boolean {

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

@@ -0,0 +1,52 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { mnemonicToLegacySeed } from '@polkadot/util-crypto';
+
+import { hdEthereum } from '.';
+
+describe('hdEthereum', (): void => {
+  const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+  const derivationPath = 'm/44\'/60\'/0\'/0/0';
+  const PUBLIC = new Uint8Array([
+    3, 118, 64, 77, 247, 27, 4, 157,
+    236, 206, 251, 221, 230, 244, 154, 147,
+    189, 131, 249, 169, 102, 78, 3, 185,
+    153, 19, 89, 40, 24, 25, 139, 131,
+    93
+  ]);
+  const SECRET = new Uint8Array([
+    166, 162, 203, 17, 2, 206, 110, 176,
+    18, 102, 230, 144, 90, 158, 25, 232,
+    43, 180, 176, 49, 189, 149, 3, 71,
+    243, 228, 223, 104, 125, 132, 58, 228
+  ]
+  );
+  const PUBLICDERIVED = new Uint8Array([
+    3, 129, 53, 27, 27, 70, 210, 96,
+    43, 9, 146, 187, 93, 85, 49, 249,
+    193, 105, 107, 8, 18, 254, 178, 83,
+    75, 104, 132, 173, 196, 126, 46, 29,
+    139
+  ]);
+  const SECRETDERIVED = new Uint8Array([
+    7, 13, 195, 17, 115, 0, 1, 25,
+    24, 226, 107, 2, 23, 105, 69, 204,
+    21, 195, 213, 72, 207, 73, 253, 132,
+    24, 217, 127, 147, 175, 105, 158, 70
+  ]);
+
+  it('derives the right key pair from a mnemonic', (): void => {
+    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64));
+
+    expect(key.publicKey).toEqual(PUBLIC);
+    expect(key.secretKey).toEqual(SECRET);
+  });
+
+  it('derives the right key pair from a mnemonic and a derivation path', (): void => {
+    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64), derivationPath);
+
+    expect(key.publicKey).toEqual(PUBLICDERIVED);
+    expect(key.secretKey).toEqual(SECRETDERIVED);
+  });
+});

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

@@ -0,0 +1,67 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Keypair } from '../../types';
+
+import { assert, bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+
+import { hmacSha512 } from '../../hmac';
+import { secp256k1KeypairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1';
+import { HARDENED, hdValidatePath } from '../validatePath';
+
+interface CodedKeypair extends Keypair {
+  chainCode: Uint8Array;
+}
+
+const MASTER_SECRET = stringToU8a('Bitcoin seed');
+
+function createCoded (secretKey: Uint8Array, chainCode: Uint8Array): CodedKeypair {
+  return {
+    chainCode,
+    publicKey: secp256k1KeypairFromSeed(secretKey).publicKey,
+    secretKey
+  };
+}
+
+function deriveChild (hd: CodedKeypair, index: number): CodedKeypair {
+  const indexBuffer = bnToU8a(index, { bitLength: 32, isLe: false });
+  const data = index >= HARDENED
+    ? u8aConcat(new Uint8Array(1), hd.secretKey, indexBuffer)
+    : u8aConcat(hd.publicKey, indexBuffer);
+
+  try {
+    const I = hmacSha512(hd.chainCode, data);
+
+    return createCoded(
+      secp256k1PrivateKeyTweakAdd(hd.secretKey, I.slice(0, 32)),
+      I.slice(32)
+    );
+  } catch (err) {
+    // In case parse256(IL) >= n or ki == 0, proceed with the next value for i
+    return deriveChild(hd, index + 1);
+  }
+}
+
+export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
+  const I = hmacSha512(MASTER_SECRET, seed);
+  const hd = createCoded(I.slice(0, 32), I.slice(32));
+
+  if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+    return hd;
+  }
+
+  assert(hdValidatePath(path), 'Invalid derivation path');
+
+  return path
+    .split('/')
+    .slice(1)
+    .reduce((hd: CodedKeypair, c): CodedKeypair =>
+      deriveChild(
+        hd, parseInt(c, 10) + (
+          (c.length > 1) && c.endsWith("'")
+            ? HARDENED
+            : 0
+        )
+      ), hd
+    );
+}