[CI Skip] release/stable 8.2.2

skip-checks: true

.123trigger

@@ -17,4 +17,12 @@
 
 7.0.2
 7.0.3
-7.1.2
+7.1.2
+7.8.2
+7.9.2
+8.0.2
+8.0.3
+8.0.4
+8.0.5
+8.1.2
+8.2.2

.codeclimate.yml

@@ -1,5 +1,21 @@
+checks:
+  argument-count:
+    config:
+      threshold: 5
+  method-complexity:
+    config:
+      threshold: 7
+  method-count:
+    config:
+      threshold: 25
+  method-lines:
+    config:
+      threshold: 30
+
 exclude_patterns:
 - "**/*.spec.js"
 - "**/*.spec.ts"
 - "packages/networks/src/substrate.ts"
 - "packages/util/src/is/utf8.ts"
+- "packages/x-noble-hashes/src/**.ts"
+- "packages/x-noble-secp256k1/src/**.ts"

.eslintignore

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

.eslintrc.js

@@ -6,18 +6,12 @@ const base = require('@polkadot/dev/config/eslint.cjs');
 module.exports = {
   ...base,
   ignorePatterns: [
-    '.eslintrc.js',
-    '.github/**',
-    '.vscode/**',
-    '.yarn/**',
-    '**/build/*',
-    '**/coverage/*',
-    '**/node_modules/*'
+    ...base.ignorePatterns
   ],
   parserOptions: {
     ...base.parserOptions,
     project: [
-      './tsconfig.json'
+      './tsconfig.eslint.json'
     ]
   },
   rules: {

.github/workflows/lock.yml

@@ -2,7 +2,7 @@ name: 'Lock Threads'
 
 on:
   schedule:
-    - cron: '30 1/2 * * *'
+    - cron: '15 1/3 * * *'
 
 jobs:
   lock:

.github/workflows/ss58-check.yml

@@ -13,6 +13,7 @@ jobs:
         CI_LOG: 123
       run: |
         yarn install --immutable | grep -v 'YN0013'
+        yarn build
         yarn networks:crosscheck
 
     - name: issue

.github/workflows/stale.yml

@@ -1,7 +1,7 @@
 name: 'Close stale issues and PRs'
 on:
   schedule:
-    - cron: '30 2/2 * * *'
+    - cron: '50 1/3 * * *'
 
 jobs:
   stale:

.gitignore

@@ -11,7 +11,9 @@ tmp/
 .env.development.local
 .env.test.local
 .env.production.local
+.idea
 .npmrc
+.vscode
 .yarn/*
 !.yarn/releases
 !.yarn/plugins
@@ -24,5 +26,4 @@ yarn-debug.log*
 yarn-error.log*
 store.db
 store.db.compacted
-.idea
-.vscode
+tsconfig.*buildinfo

CHANGELOG.md

@@ -1,5 +1,217 @@
 # CHANGELOG
 
+## 8.2.2 Dec 19, 2021
+
+Contributed:
+
+- Add Bifrost Ledger capabilities (Thanks to https://github.com/awesomepan)
+- Add Sora genesisHash & Ledger capabilities (Thanks to https://github.com/NoodleSploder)
+
+Changes:
+
+- Add `isPromise` check utility function
+- Add `assertUnreachable` for codepaths that should not be followed
+- Preserve all-caps word splits in `stringCamelCase`
+- Adjust `x-*` fallbacks via `x-global/extractGlobal`
+- Sync with upstream Substrate ss58 registry
+- Additional tests for `bip39` wordlists
+- Maintainability cleanups
+- Update to latest Ledger dependencies
+- Swap to upstream `@noble` packages
+- Adjust tsconfig with references
+- 8.2.2 (8.2.1 failed CI due to incorrect CHANGELOG)
+
+
+## 8.1.2 Dec 5, 2021
+
+Changes:
+
+- Adjustment to non-full-word consecutive uppercase via `string{Camel, Pascal}Case`
+
+
+## 8.1.1 Dec 5, 2021
+
+Contributed:
+
+- Add Picasso genesisHash (Thanks to https://github.com/hussein-aitlahcen)
+
+Changes:
+
+- Allow for use of `secp256k1` from `@polkadot/wasm-crypto`
+- Adjust `isBigInt` to not do `instanceof` check
+- Ensure consequtive capitals in `stringCamelCase` are lowercased
+- Use `@polkadot/x-bigint` for `BigInt` constructor
+- Split `@noble/hashes` fork into `x-noble-hashes`
+- Add `@noble/secp256k1` fork into `x-noble-secp256k1`, replaces `elliptic`
+
+
+## 8.0.5 Dec 1, 2021
+
+Changes:
+
+- Adjust sha3 expectation of `BigInt` availability
+
+
+## 8.0.4 Nov 30, 2021
+
+Changes:
+
+- Adjust `stringCamelCase` with leading `_`
+
+
+## 8.0.3 Nov 30, 2021
+
+Changes:
+
+- Remove `Buffer` usage in `x-randomvalues`
+- Adjust `stringCamelCase` for all-caps parts
+
+
+## 8.0.2 Nov 26, 2021
+
+Changes:
+
+- Explicitly include BigInt patched versions
+
+
+## 8.0.1 Nov 26, 2021
+
+**Important** In the 8.0 version the hashing utilities have been consolidated around an optimized and audited version from `@noble/hashes`. As in the past the WASM hashing will be used by default if the environment is initialized.
+
+**Breaking change** The `schnorrkel*` functions have been renamed to `sr25519*`. Likewise the `ed25519` operations have been renamed from `nacl*` to `ed25519*`. Additionally the `{ed, sr, secp256k1}25519KeyPairFrom*` functions have been renamed to `{ed, sr, secp256k1}25519PairFrom*`.
+
+Changes:
+
+- Introduce `ed25519*` & `sr25519*` functions
+- Replace camelcase dep with simplified/optimized version
+- Replace (most) hashing operations with `@noble/hashes`
+- Replace JS fallback for `xxhash`
+- Adjust `BigInt` utility exports (with capability detection)
+- Previously added `bi*` functions renamed to `n*`
+- Extend performance tests with implementation compares
+- Remove non-significant Node Buffer concat fill
+
+
+## 7.9.2 Nov 22, 2021
+
+Changes:
+
+- Fix TS compiled definitions for `base*` types
+- Provide JS/Wasm interfaces for `hmacShaAsU8a`
+
+
+## 7.9.1 Nov 21, 2021
+
+Contributed:
+
+- Updated Polymesh genesisHash (Thanks to https://github.com/adamdossa)
+
+Changes:
+
+- Add strongly typed `object{Entries, Keys, Values}` utilities
+- Add `{hex, u8a}ToBigInt` utilities
+- Add `bi*` utilities for `bigint` operations (mirror of `bn*`)
+- Add `stringPascalCase` utility
+- Add `isCodec` to check for Codec-like structures
+- Add `has*` detection shortcuts (e.g. `hasWasm` or `hasBuffer`)
+- Add `sha256AsU8a` util (& replace use internally)
+- Optimize for `hexToU8a` and `u8aToHex` functions
+- Optimize `u8aEq` to use `DataView` for compares
+- Align `base{32, 58, 64}*` around (audited) `micro-base`
+- Space optimization for bip39 wordlists
+- Sync with upstream Substrate ss58 registry
+- Expand tests for uncovered functions
+
+
+## 7.8.2 Nov 7, 2021
+
+Changes:
+
+- Expose internal `isArray` check
+- Move `object{Property, Properties}` from api repo
+
+
+## 7.8.1 Nov 6, 2021
+
+Contributed:
+
+- Added Acala genesisHash (Thanks to https://github.com/qwer951123)
+
+Changes:
+
+- Add `objectClear` and `objectSpread` utility functions
+- Add `lazyMethod` & `lazyMethods` utility functions
+- Sync with upstream Substrate ss58 registry
+
+
+## 7.7.1 Oct 31, 2021
+
+Contributed:
+
+- Add Genshiro support (Thanks to https://github.com/Overseven)
+
+Changes:
+
+- Add `arrayZip` to combine a key + value array into entries-like
+- Assert `chainCode` inputs to `derive*`, protecting against misuse
+- Adjust testnet detection in `@polkadot/networks`
+- Adjust base library usage of `for` vs `reduce/map`
+- Bump Ledger libraries to latest versions
+
+
+## 7.6.1 Oct 23, 2021
+
+Changes:
+
+- Update `xxhash*` to only use `Uint8Array` internally, no `Buffer`
+- Adjust `isAscii` to check against original string codepoints (when provided)
+- Adjust networks to sync with `paritytech/ss58-registry`
+- Dedupe internal sr25519/ed25519 derivation functions
+- Bump Ledger libraries to latest versions
+
+
+## 7.5.1 Oct 16, 2021
+
+Contributed:
+
+- Fix comment on `blake2AsU8a` (Thanks to https://github.com/tomokazukozuma)
+- Update Ethereum derivation process (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Derivation paths now caters for > `MAX_SAFE_INTEGER` unsigned values
+- Sync with upstream Substrate ss58 registry
+- Update ss58 registry handling (both previous and current versions)
+
+
+## 7.4.1 Sep 17, 2021
+
+Changes:
+
+- Add `u8aWrapBytes` & `u8aUnwrapBytes` (originally from `@polkadot/extension-dapp`)
+- Verify both wrapped and unwrapped signatures transparently
+- Adjust `isHex` return to `0x${string}` under TypeScript
+- Adjust shared repo Jest config
+- Sync with upstream Substrate ss58 registry
+- Cleanup rollup build where `x-global` yields undefined
+
+
+## 7.3.1 Aug 28, 2021
+
+Contributed:
+
+- Added Bifrost genesisHash (Thanks to https://github.com/awesomepan)
+- Added Stafi genesisHash (Thanks to https://github.com/Tore19)
+- Add Ledger support for Nodle (Thanks to https://github.com/ETeissonniere)
+
+Changes:
+
+- Add support for `schnorrkelAgreement` (as exposed by new `wasm-crypto`)
+- Ensure `schnorrkel*` functions allows hex inputs
+- `@polkadot/wasm-crypto` 4.2.1
+- Sync with upstream Substrate ss58 registry
+
+
 ## 7.2.1 Aug 15, 2021
 
 Contributed:

jest.config.cjs

@@ -13,24 +13,7 @@ module.exports = Object.assign({}, config, {
     '@polkadot/util-(crypto)(.*)$': '<rootDir>/packages/util-$1/src/$2',
     // eslint-disable-next-line sort-keys
     '@polkadot/util(.*)$': '<rootDir>/packages/util/src/$1',
-    '@polkadot/x-(fetch|randomvalues|textdecoder|textencoder|ws)(.*)$': '<rootDir>/packages/x-$1/src/node',
-    '@polkadot/x-global(.*)$': '<rootDir>/packages/x-global/src/$1',
-    '@polkadot/x-rxjs(.*)$': '<rootDir>/packages/x-rxjs/src/$1'
-  },
-  modulePathIgnorePatterns: [
-    '<rootDir>/packages/hw-ledger/build',
-    '<rootDir>/packages/hw-ledger-transports/build',
-    '<rootDir>/packages/keyring/build',
-    '<rootDir>/packages/networks/build',
-    '<rootDir>/packages/util/build',
-    '<rootDir>/packages/util-crypto/build',
-    '<rootDir>/packages/x-fetch/build',
-    '<rootDir>/packages/x-global/build',
-    '<rootDir>/packages/x-randomvalues/build',
-    '<rootDir>/packages/x-rxjs/build',
-    '<rootDir>/packages/x-textdecoder/build',
-    '<rootDir>/packages/x-textencoder/build',
-    '<rootDir>/packages/x-ws/build'
-  ],
-  transformIgnorePatterns: ['/node_modules/(?!@polkadot)']
+    '@polkadot/x-(bigint|global)(.*)$': '<rootDir>/packages/x-$1/src/$2',
+    '@polkadot/x-(fetch|randomvalues|textdecoder|textencoder|ws)(.*)$': '<rootDir>/packages/x-$1/src/node'
+  }
 });

package.json

@@ -1,34 +1,39 @@
 {
-  "repository": "https://github.com/polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/common/issues",
+  "homepage": "https://github.com/polkadot-js/common#readme",
   "license": "Apache-2",
+  "packageManager": "yarn@3.0.1",
   "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
+  "sideEffects": false,
+  "version": "8.2.2",
   "workspaces": [
     "packages/*"
   ],
-  "resolutions": {
-    "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",
+    "lint": "polkadot-dev-run-lint",
     "networks:crosscheck": "polkadot-dev-run-test packages/networks/src/crosscheck",
-    "networks:sync": "node packages/networks/scripts/fromSubstrate.mjs",
+    "networks:sync": "yarn build && node packages/networks/scripts/fromSubstrate.mjs",
     "postinstall": "polkadot-dev-yarn-only",
     "test": "polkadot-dev-run-test --coverage --runInBand --testPathIgnorePatterns crosscheck --testPathIgnorePatterns toMiniSecretCmp",
     "test:mnemonicCmp": "polkadot-dev-run-test packages/util-crypto/src/mnemonic/toMiniSecretCmp.spec.ts",
     "test:one": "polkadot-dev-run-test --runInBand"
   },
   "devDependencies": {
-    "@babel/core": "^7.15.0",
-    "@polkadot/dev": "^0.62.59",
-    "@polkadot/ts": "^0.4.4",
-    "@types/ed2curve": "^0.2.2",
-    "@types/jest": "^26.0.24"
+    "@babel/core": "^7.16.5",
+    "@polkadot/dev": "^0.64.5",
+    "@polkadot/ts": "^0.4.20",
+    "@types/jest": "^27.0.3"
   },
-  "version": "7.2.1",
-  "packageManager": "yarn@3.0.1"
+  "resolutions": {
+    "typescript": "^4.5.3"
+  }
 }

packages/hw-ledger-transports/package.json

@@ -1,26 +1,32 @@
 {
-  "name": "@polkadot/hw-ledger-transports",
-  "version": "7.2.1",
-  "type": "module",
-  "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [],
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "contributors": [],
-  "license": "Apache-2.0",
-  "main": "node.js",
-  "browser": "browser.js",
-  "react-native": "react-native.js",
-  "sideEffects": false,
   "engines": {
     "node": ">=14.0.0"
   },
+  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger-transports#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/hw-ledger-transports",
+  "repository": {
+    "directory": "packages/hw-ledger-transports",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "8.2.2",
+  "browser": "browser.js",
+  "main": "node.js",
+  "react-native": "react-native.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.3",
-    "@ledgerhq/hw-transport": "^6.3.0",
-    "@ledgerhq/hw-transport-webhid": "^6.4.1",
-    "@ledgerhq/hw-transport-webusb": "^6.3.0"
+    "@babel/runtime": "^7.16.5",
+    "@ledgerhq/hw-transport": "^6.20.0",
+    "@ledgerhq/hw-transport-webhid": "^6.20.0",
+    "@ledgerhq/hw-transport-webusb": "^6.20.0"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-hid-singleton": "^6.3.0"
+    "@ledgerhq/hw-transport-node-hid-singleton": "^6.20.0"
   }
 }

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

@@ -10,13 +10,6 @@ import LedgerWebUsb from '@ledgerhq/hw-transport-webusb';
 export { packageInfo } from './packageInfo';
 
 export const transports: TransportDef[] = [
-  // deprecated
-  // import LedgerU2F from '@ledgerhq/hw-transport-u2f';
-  // {
-  //   create: (): Promise<Transport> =>
-  //     LedgerU2F.create(),
-  //   type: 'u2f'
-  // },
   {
     create: (): Promise<Transport> =>
       LedgerWebUsb.create(),

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

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '7.2.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger-transports', version: '8.2.2' };

packages/hw-ledger-transports/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": []
+}

packages/hw-ledger/package.json

@@ -1,24 +1,30 @@
 {
-  "name": "@polkadot/hw-ledger",
-  "version": "7.2.1",
-  "type": "module",
-  "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [],
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "contributors": [],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/hw-ledger#readme",
   "license": "Apache-2.0",
-  "main": "index.js",
+  "maintainers": [],
+  "name": "@polkadot/hw-ledger",
+  "repository": {
+    "directory": "packages/hw-ledger",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
   "sideEffects": [
     "./detectPackage.js",
     "./detectPackage.cjs"
   ],
-  "engines": {
-    "node": ">=14.0.0"
-  },
+  "type": "module",
+  "version": "8.2.2",
+  "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.3",
-    "@polkadot/hw-ledger-transports": "7.2.1",
-    "@polkadot/util": "7.2.1",
-    "@zondax/ledger-substrate": "^0.17.3"
+    "@babel/runtime": "^7.16.5",
+    "@polkadot/hw-ledger-transports": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@zondax/ledger-substrate": "^0.23.0"
   }
 }

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

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

@@ -4,16 +4,20 @@
 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';
+import { newBifrostApp, newCentrifugeApp, newDockApp, newEdgewareApp, newEquilibriumApp, newGenshiroApp, newKusamaApp, newNodleApp, newPolkadotApp, newPolymeshApp, newSoraApp, newStatemineApp } from '@zondax/ledger-substrate';
 
 // These match up with the keys of the knownLedger object in the @polkadot/networks/defaults.ts
 export const ledgerApps: Record<string, (transport: Transport) => SubstrateApp> = {
+  bifrost: newBifrostApp,
   centrifuge: newCentrifugeApp,
   'dock-mainnet': newDockApp,
   edgeware: newEdgewareApp,
   equilibrium: newEquilibriumApp,
+  genshiro: newGenshiroApp,
   kusama: newKusamaApp,
+  'nodle-chain': newNodleApp,
   polkadot: newPolkadotApp,
   polymesh: newPolymeshApp,
+  sora: newSoraApp,
   statemine: newStatemineApp
 };

packages/hw-ledger/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/hw-ledger', version: '7.2.1' };
+export const packageInfo = { name: '@polkadot/hw-ledger', version: '8.2.2' };

packages/hw-ledger/src/types.ts

@@ -1,6 +1,8 @@
 // Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
+
 export type LedgerTypes = 'hid' | 'u2f' | 'webusb';
 
 export interface AccountOptions {
@@ -15,7 +17,7 @@ export interface LedgerAddress {
 }
 
 export interface LedgerSignature {
-  signature: string;
+  signature: HexString;
 }
 
 export interface LedgerVersion {

packages/hw-ledger/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../hw-ledger-transports" },
+    { "path": "../util" }
+  ]
+}

packages/keyring/package.json

@@ -1,30 +1,34 @@
 {
-  "name": "@polkadot/keyring",
-  "version": "7.2.1",
-  "type": "module",
-  "description": "Keyring management",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [],
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "contributors": [],
+  "description": "Keyring management",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "license": "Apache-2.0",
-  "main": "index.js",
+  "maintainers": [],
+  "name": "@polkadot/keyring",
+  "repository": {
+    "directory": "packages/keyring",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
   "sideEffects": [
     "./detectPackage.js",
     "./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",
+  "type": "module",
+  "version": "8.2.2",
+  "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.3",
-    "@polkadot/util": "7.2.1",
-    "@polkadot/util-crypto": "7.2.1"
+    "@babel/runtime": "^7.16.5",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/util-crypto": "8.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "7.2.1",
-    "@polkadot/util-crypto": "7.2.1"
+    "@polkadot/util": "8.2.2",
+    "@polkadot/util-crypto": "8.2.2"
   }
 }

packages/keyring/src/index.spec.ts

@@ -74,7 +74,7 @@ describe('keypair', (): void => {
     it('allows adding from JSON', (): void => {
       expect(
         keyring.addFromJson(
-          JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}')
+          JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}') as KeyringPair$Json
         ).publicKey
       ).toEqual(
         new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
@@ -121,6 +121,18 @@ describe('keypair', (): void => {
       ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
     });
 
+    it('creates with integer derivations', (): void => {
+      // MAX_SAFE_INTEGER
+      expect(
+        keyring.createFromUri('//9007199254740991').address
+      ).toEqual('5CDsyNZyqxLpHnTvknr68anUcYoBFjZbFKiEJJf4prB75Uog');
+
+      // MAX_SAFE_INTEGER + extra digits
+      expect(
+        keyring.createFromUri('//900719925474099999').address
+      ).toEqual('5GHj2D7RG2m2DXYwGSDpXwuuxn53G987i7p2EQVDqP4NYu4q');
+    });
+
     it('creates via dev seed (2-byte encoding)', (): void => {
       keyring.setSS58Format(252);
 
@@ -160,7 +172,7 @@ describe('keypair', (): void => {
     it('allows adding from JSON', (): void => {
       expect(
         keyring.addFromJson(
-          JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}')
+          JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}') as KeyringPair$Json
         ).publicKey
       ).toEqual(
         new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
@@ -239,7 +251,7 @@ describe('keypair', (): void => {
     it('allows adding from JSON', (): void => {
       expect(
         keyring.addFromJson(
-          JSON.parse('{"address":"5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz","encoded":"0xa192d39b42bc1601bf61df31039a554228593fadf870bc837b658a5114627aca199fff596260c95fe8994c66a47636cf0270aa08f402ba5541038753960d00e6c3af5e239ec58fb1eef3db7d6bc266f4853bdfe4ed17122d9092d879014d53980d2ee57f6f55a88c38836447d8645008e8815379626addc8f81f80cd49a2","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"2"},"meta":{}}')
+          JSON.parse('{"address":"5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz","encoded":"0xa192d39b42bc1601bf61df31039a554228593fadf870bc837b658a5114627aca199fff596260c95fe8994c66a47636cf0270aa08f402ba5541038753960d00e6c3af5e239ec58fb1eef3db7d6bc266f4853bdfe4ed17122d9092d879014d53980d2ee57f6f55a88c38836447d8645008e8815379626addc8f81f80cd49a2","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"2"},"meta":{}}') as KeyringPair$Json
         ).address
       ).toEqual('5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz');
     });
@@ -247,7 +259,7 @@ describe('keypair', (): void => {
     it('allows creation from JSON', (): void => {
       keyring.setSS58Format(2);
       const pair = keyring.createFromJson(
-        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}') as KeyringPair$Json
       );
 
       expect(pair.address).toEqual('DHL8HKFuTTR55JzzLmkJRCAfPBbuevKaT9cXikxbEV97Ko8');
@@ -256,7 +268,7 @@ describe('keypair', (): void => {
 
     it('fails toJson() when password is incorrect', (): void => {
       const pair = keyring.createFromJson(
-        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}') as KeyringPair$Json
       );
 
       expect(
@@ -266,7 +278,7 @@ describe('keypair', (): void => {
 
     it('pass toJson() when password is correct', (): void => {
       const pair = keyring.createFromJson(
-        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}') as KeyringPair$Json
       );
 
       expect(
@@ -357,6 +369,14 @@ describe('keypair', (): void => {
       ).toEqual(ETH_ADDRESS_ONE);
     });
 
+    it('creates with dev phrase with derivation path specified - addFromUri with type', (): void => {
+      const keyringUntyped = new Keyring();
+
+      expect(
+        keyringUntyped.addFromUri(PHRASE, {}, 'ethereum').address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
     it('encodes a pair toJSON (and decodes)', (): void => {
       const pair = keyring.createFromUri(PHRASE);
       const json = pair.toJson('password');
@@ -393,7 +413,7 @@ describe('keypair', (): void => {
 
     it('allows adding from JSON', (): void => {
       const pair = keyring.addFromJson(
-        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}')
+        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}') as KeyringPair$Json
       );
 
       expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
@@ -410,7 +430,7 @@ describe('keypair', (): void => {
       const MESSAGE = stringToU8a('just some test message');
       const signer = keyring.createFromUri(PHRASE);
       const verifier = keyring.addFromJson(
-        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}')
+        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}') as KeyringPair$Json
       );
 
       const signature = signer.sign(MESSAGE);
@@ -427,7 +447,7 @@ describe('keypair', (): void => {
       const MESSAGE = stringToU8a('just some test message');
       const signer = keyring.createFromUri(PHRASE);
       const verifier = keyring.addFromJson(
-        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}')
+        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}') as KeyringPair$Json
       );
 
       const signature = signer.sign(MESSAGE, { withType: true });
@@ -496,7 +516,7 @@ describe('keypair', (): void => {
     });
 
     it('can decode from a version 2 JSON file', (): void => {
-      const pair = keyring.addFromJson(JSON.parse(PAIR));
+      const pair = keyring.addFromJson(JSON.parse(PAIR) as KeyringPair$Json);
 
       pair.decodePkcs8(PASS2);
 
@@ -526,7 +546,7 @@ describe('keypair', (): void => {
     });
 
     it('can decode from a version 3 JSON file', (): void => {
-      const pair = keyring.addFromJson(JSON.parse(PAIR));
+      const pair = keyring.addFromJson(JSON.parse(PAIR) as KeyringPair$Json);
 
       pair.decodePkcs8(PASS3);
 
@@ -545,7 +565,7 @@ describe('keypair', (): void => {
     });
 
     it('can decode from a version 3 JSON file', (): void => {
-      const pair = keyring.addFromJson(JSON.parse(PAIR));
+      const pair = keyring.addFromJson(JSON.parse(PAIR) as KeyringPair$Json);
 
       pair.decodePkcs8(PASS3);
 

packages/keyring/src/keyring.ts

@@ -1,24 +1,27 @@
 // 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 { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$Meta } from './types';
 
 import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
-import { base64Decode, decodeAddress, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
+import { base64Decode, decodeAddress, ed25519PairFromSeed as ed25519FromSeed, encodeAddress, ethereumEncode, hdEthereum, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, secp256k1PairFromSeed as secp256k1FromSeed, sr25519PairFromSeed as sr25519FromSeed } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import { createPair } from './pair';
 import { Pairs } from './pairs';
 
-const keypairFromSeed = {
+const PairFromSeed = {
   ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  ed25519: (seed: Uint8Array): Keypair => naclFromSeed(seed),
+  ed25519: (seed: Uint8Array): Keypair => ed25519FromSeed(seed),
   ethereum: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
-  sr25519: (seed: Uint8Array): Keypair => schnorrkelFromSeed(seed)
+  sr25519: (seed: Uint8Array): Keypair => sr25519FromSeed(seed)
 };
 
+function pairToPublic ({ publicKey }: KeyringPair): Uint8Array {
+  return publicKey;
+}
+
 /**
  * # @polkadot/keyring
  *
@@ -139,7 +142,7 @@ export class Keyring implements KeyringInstance {
    */
   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)
+      createPair({ toSS58: this.encodeAddress, type }, PairFromSeed[type](seed), meta, null)
     );
   }
 
@@ -206,25 +209,24 @@ export class Keyring implements KeyringInstance {
     if (isPhraseHex) {
       seed = hexToU8a(phrase);
     } else {
-      const str = phrase;
-      const parts = str.split(' ');
+      const parts = phrase.split(' ');
 
       if ([12, 15, 18, 21, 24].includes(parts.length)) {
         seed = type === 'ethereum'
           ? 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');
+        assert(phrase.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');
 
-        seed = stringToU8a(str.padEnd(32));
+        seed = stringToU8a(phrase.padEnd(32));
       }
     }
 
     const derived = type === 'ethereum'
       ? isPhraseHex
-        ? keypairFromSeed[type](seed) // for eth, if the private key is provided as suri, it must be derived only once
+        ? PairFromSeed[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);
+      : keyFromPath(PairFromSeed[type](seed), path, type);
 
     return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
   }
@@ -237,7 +239,7 @@ export class Keyring implements KeyringInstance {
     return this.type === 'ethereum'
       ? ethereumEncode(address)
       : encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
-  }
+  };
 
   /**
    * @name getPair
@@ -264,11 +266,7 @@ export class Keyring implements KeyringInstance {
    * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
    */
   public getPublicKeys (): Uint8Array[] {
-    return this.#pairs
-      .all()
-      .map(({ publicKey }): Uint8Array =>
-        publicKey
-      );
+    return this.#pairs.all().map(pairToPublic);
   }
 
   /**

packages/keyring/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/keyring', version: '7.2.1' };
+export const packageInfo = { name: '@polkadot/keyring', version: '8.2.2' };

packages/keyring/src/pair/decode.ts

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/json/types';
+import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/types';
 import type { PairInfo } from './types';
 
 import { assert, isUndefined, u8aEq } from '@polkadot/util';

packages/keyring/src/pair/index.ts

@@ -1,13 +1,13 @@
 // 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 { HexString } from '@polkadot/util/types';
+import type { EncryptedJsonEncoding, Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import type { PairInfo } from './types';
 
-import { assert, u8aConcat, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
-import { blake2AsU8a, convertPublicKeyToCurve25519, convertSecretKeyToCurve25519, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclOpen, naclSeal, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVrfSign, schnorrkelVrfVerify, secp256k1Compress, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify } from '@polkadot/util-crypto';
+import { assert, objectSpread, u8aConcat, u8aEmpty, u8aEq, u8aToHex, u8aToU8a } from '@polkadot/util';
+import { blake2AsU8a, convertPublicKeyToCurve25519, convertSecretKeyToCurve25519, ed25519PairFromSeed as ed25519FromSeed, ed25519Sign, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclOpen, naclSeal, secp256k1Compress, secp256k1Expand, secp256k1PairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify, sr25519PairFromSeed as sr25519FromSeed, sr25519Sign, sr25519VrfSign, sr25519VrfVerify } from '@polkadot/util-crypto';
 
 import { decodePair } from './decode';
 import { encodePair } from './encode';
@@ -22,9 +22,9 @@ const SIG_TYPE_NONE = new Uint8Array();
 
 const TYPE_FROM_SEED = {
   ecdsa: secp256k1FromSeed,
-  ed25519: naclFromSeed,
+  ed25519: ed25519FromSeed,
   ethereum: secp256k1FromSeed,
-  sr25519: schnorrkelFromSeed
+  sr25519: sr25519FromSeed
 };
 
 const TYPE_PREFIX = {
@@ -36,9 +36,9 @@ const TYPE_PREFIX = {
 
 const TYPE_SIGNATURE = {
   ecdsa: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'blake2'),
-  ed25519: naclSign,
+  ed25519: ed25519Sign,
   ethereum: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'keccak'),
-  sr25519: schnorrkelSign
+  sr25519: sr25519Sign
 };
 
 const TYPE_ADDRESS = {
@@ -48,9 +48,8 @@ const TYPE_ADDRESS = {
   sr25519: (p: Uint8Array) => p
 };
 
-// Not 100% correct, since it can be a Uint8Array, but an invalid one - just say "undefined" is anything non-valid
 function isLocked (secretKey?: Uint8Array): secretKey is undefined {
-  return !secretKey || secretKey.length === 0 || secretKey.every((b) => b === 0);
+  return !secretKey || u8aEmpty(secretKey);
 }
 
 function vrfHash (proof: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array {
@@ -145,13 +144,15 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     },
     // eslint-disable-next-line sort-keys
     decodePkcs8,
-    decryptMessage: (encryptedMessageWithNonce: string | Uint8Array, senderPublicKey: string | Uint8Array): Uint8Array | null => {
+    decryptMessage: (encryptedMessageWithNonce: HexString | string | Uint8Array, senderPublicKey: HexString | string | Uint8Array): Uint8Array | null => {
       assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
       assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
 
+      const messageU8a = u8aToU8a(encryptedMessageWithNonce);
+
       return naclOpen(
-        u8aToU8a(encryptedMessageWithNonce.slice(24, encryptedMessageWithNonce.length)),
-        u8aToU8a(encryptedMessageWithNonce.slice(0, 24)),
+        messageU8a.slice(24, messageU8a.length),
+        messageU8a.slice(0, 24),
         convertPublicKeyToCurve25519(u8aToU8a(senderPublicKey)),
         convertSecretKeyToCurve25519(secretKey)
       );
@@ -168,11 +169,11 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     encodePkcs8: (passphrase?: string): Uint8Array => {
       return recode(passphrase);
     },
-    encryptMessage: (message: string | Uint8Array, recipientPublicKey: string | Uint8Array, _nonce?: Uint8Array): Uint8Array => {
+    encryptMessage: (message: HexString | string | Uint8Array, recipientPublicKey: HexString | string | Uint8Array, nonceIn?: Uint8Array): Uint8Array => {
       assert(!isLocked(secretKey), 'Cannot encrypt with a locked key pair');
       assert(!['ecdsa', 'ethereum'].includes(type), 'Secp256k1 not supported yet');
 
-      const { nonce, sealed } = naclSeal(u8aToU8a(message), convertSecretKeyToCurve25519(secretKey), convertPublicKeyToCurve25519(u8aToU8a(recipientPublicKey)), _nonce);
+      const { nonce, sealed } = naclSeal(u8aToU8a(message), convertSecretKeyToCurve25519(secretKey), convertPublicKeyToCurve25519(u8aToU8a(recipientPublicKey)), nonceIn);
 
       return u8aConcat(nonce, sealed);
     },
@@ -180,9 +181,9 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
       secretKey = new Uint8Array();
     },
     setMeta: (additional: KeyringPair$Meta): void => {
-      meta = { ...meta, ...additional };
+      meta = objectSpread({}, meta, additional);
     },
-    sign: (message: string | Uint8Array, options: SignOptions = {}): Uint8Array => {
+    sign: (message: HexString | string | Uint8Array, options: SignOptions = {}): Uint8Array => {
       assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
 
       return u8aConcat(
@@ -207,28 +208,26 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     unlock: (passphrase?: string): void => {
       return decodePkcs8(passphrase);
     },
-    verify: (message: string | Uint8Array, signature: Uint8Array, _signerPublic: string | Uint8Array): boolean => {
-      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(_signerPublic))).isValid;
+    verify: (message: HexString | string | Uint8Array, signature: HexString | string | Uint8Array, signerPublic: HexString | string | Uint8Array): boolean => {
+      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(signerPublic))).isValid;
     },
-    vrfSign: (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
+    vrfSign: (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: string | Uint8Array): Uint8Array => {
       assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
 
       if (type === 'sr25519') {
-        return schnorrkelVrfSign(message, { secretKey }, context, extra);
+        return sr25519VrfSign(message, { secretKey }, context, extra);
       }
 
       const proof = TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey });
 
       return u8aConcat(vrfHash(proof, context, extra), proof);
     },
-    vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, _signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean => {
-      const signerPublic = TYPE_ADDRESS[type](u8aToU8a(_signerPublic));
-
+    vrfVerify: (message: HexString | string | Uint8Array, vrfResult: Uint8Array, signerPublic: HexString | Uint8Array | string, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): boolean => {
       if (type === 'sr25519') {
-        return schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra);
+        return sr25519VrfVerify(message, vrfResult, publicKey, context, extra);
       }
 
-      const result = signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), signerPublic);
+      const result = signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), TYPE_ADDRESS[type](u8aToU8a(signerPublic)));
 
       return result.isValid && u8aEq(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra));
     }

packages/keyring/src/pair/nobody.ts

@@ -7,10 +7,12 @@ import { encodeAddress } from '@polkadot/util-crypto';
 
 const publicKey = new Uint8Array(32);
 const address = encodeAddress(publicKey);
+
 const meta = {
   isTesting: true,
   name: 'nobody'
 };
+
 const json: KeyringPair$Json = {
   address,
   encoded: '',
@@ -22,54 +24,54 @@ const json: KeyringPair$Json = {
   meta
 };
 
-export function nobody (): KeyringPair {
-  const pair: KeyringPair = {
-    address,
-    addressRaw: publicKey,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    decodePkcs8: (passphrase?: string, encoded?: Uint8Array): void =>
-      undefined,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    decryptMessage: (encryptedMessageWithNonce: string | Uint8Array, senderPublicKey: string | Uint8Array): Uint8Array | null =>
-      null,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair =>
-      pair,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    encodePkcs8: (passphrase?: string): Uint8Array =>
-      new Uint8Array(0),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    encryptMessage: (message: string | Uint8Array, recipientPublicKey: string | Uint8Array, _nonce?: Uint8Array): Uint8Array =>
-      new Uint8Array(),
-    isLocked: true,
-    lock: (): void => {
-      // no locking, it is always locked
-    },
-    meta,
-    publicKey,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    setMeta: (meta: KeyringPair$Meta): void =>
-      undefined,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    sign: (message: Uint8Array): Uint8Array =>
-      new Uint8Array(64),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    toJson: (passphrase?: string): KeyringPair$Json =>
-      json,
-    type: 'ed25519',
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    unlock: (passphrase?: string): void =>
-      undefined,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    verify: (message: Uint8Array, signature: Uint8Array): boolean =>
-      false,
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    vrfSign: (message: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array =>
-      new Uint8Array(96),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    vrfVerify: (message: Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean =>
-      false
-  };
+const pair: KeyringPair = {
+  address,
+  addressRaw: publicKey,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  decodePkcs8: (passphrase?: string, encoded?: Uint8Array): void =>
+    undefined,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  decryptMessage: (encryptedMessageWithNonce: string | Uint8Array, senderPublicKey: string | Uint8Array): Uint8Array | null =>
+    null,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair =>
+    pair,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  encodePkcs8: (passphrase?: string): Uint8Array =>
+    new Uint8Array(0),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  encryptMessage: (message: string | Uint8Array, recipientPublicKey: string | Uint8Array, _nonce?: Uint8Array): Uint8Array =>
+    new Uint8Array(),
+  isLocked: true,
+  lock: (): void => {
+    // no locking, it is always locked
+  },
+  meta,
+  publicKey,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setMeta: (meta: KeyringPair$Meta): void =>
+    undefined,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  sign: (message: Uint8Array): Uint8Array =>
+    new Uint8Array(64),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  toJson: (passphrase?: string): KeyringPair$Json =>
+    json,
+  type: 'ed25519',
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unlock: (passphrase?: string): void =>
+    undefined,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  verify: (message: Uint8Array, signature: Uint8Array): boolean =>
+    false,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  vrfSign: (message: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array =>
+    new Uint8Array(96),
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  vrfVerify: (message: Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean =>
+    false
+};
 
+export function nobody (): KeyringPair {
   return pair;
 }

packages/keyring/src/pair/toJson.ts

@@ -4,6 +4,7 @@
 import type { KeypairType } from '@polkadot/util-crypto/types';
 import type { KeyringPair$Json, KeyringPair$Meta } from '../types';
 
+import { objectSpread } from '@polkadot/util';
 import { jsonEncryptFormat } from '@polkadot/util-crypto';
 
 interface PairStateJson {
@@ -12,9 +13,8 @@ interface PairStateJson {
 }
 
 export function pairToJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
-  return {
-    ...jsonEncryptFormat(encoded, ['pkcs8', type], isEncrypted),
+  return objectSpread(jsonEncryptFormat(encoded, ['pkcs8', type], isEncrypted), {
     address,
     meta
-  };
+  });
 }

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

@@ -4,7 +4,7 @@
 import type { KeyringPair } from '../types';
 
 import { u8aToHex } from '@polkadot/util';
-import { cryptoWaitReady, encodeAddress as toSS58, naclKeypairFromSeed, randomAsU8a, schnorrkelKeypairFromSeed, secp256k1KeypairFromSeed } from '@polkadot/util-crypto';
+import { cryptoWaitReady, ed25519PairFromSeed, encodeAddress as toSS58, randomAsU8a, secp256k1PairFromSeed, sr25519PairFromSeed } from '@polkadot/util-crypto';
 
 import { createPair } from '.';
 
@@ -19,9 +19,9 @@ describe('vrf', (): void => {
   beforeAll(async (): Promise<void> => {
     await cryptoWaitReady();
 
-    ecdsa = createPair({ toSS58, type: 'ecdsa' }, secp256k1KeypairFromSeed(randomAsU8a()));
-    ed25519 = createPair({ toSS58, type: 'ed25519' }, naclKeypairFromSeed(randomAsU8a()));
-    sr25519 = createPair({ toSS58, type: 'sr25519' }, schnorrkelKeypairFromSeed(randomAsU8a()));
+    ecdsa = createPair({ toSS58, type: 'ecdsa' }, secp256k1PairFromSeed(randomAsU8a()));
+    ed25519 = createPair({ toSS58, type: 'ed25519' }, ed25519PairFromSeed(randomAsU8a()));
+    sr25519 = createPair({ toSS58, type: 'sr25519' }, sr25519PairFromSeed(randomAsU8a()));
   });
 
   it('has deterministic signature values for ecdsa', (): void => {

packages/keyring/src/pairs.ts

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

packages/keyring/src/suri.spec.ts

@@ -3,12 +3,15 @@
 
 // From https://github.com/paritytech/substrate/wiki/Secret-URI-Test-Vectors
 
+import type { KeypairType } from '@polkadot/util-crypto/types';
+
 import { u8aToHex } from '@polkadot/util';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 
 import Keyring from '.';
 
 const PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
+const ETHEREUM_PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
 
 const TESTS = {
   ecdsa: [
@@ -22,7 +25,17 @@ const TESTS = {
     {
       pk: '0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b',
       ss: '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d',
-      uri: "seed sock milk update focus rotate barely fade car face mechanic mercy/m/44'/60'/0'/0/0"
+      uri: `${ETHEREUM_PHRASE}/m/44'/60'/0'/0/0`
+    },
+    {
+      pk: '0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f',
+      ss: '0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac',
+      uri: `${PHRASE}/m/44'/60'/0'/0/0`
+    },
+    {
+      pk: '0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518',
+      ss: '0x3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0',
+      uri: `${PHRASE}/m/44'/60'/0'/0/1`
     }
   ],
   sr25519: [
@@ -75,17 +88,17 @@ const TESTS = {
 };
 
 describe('keyring.addFromUri', (): void => {
-  const keyring = new Keyring({ type: 'sr25519' });
-
-  beforeEach(async (): Promise<void> => {
-    await cryptoWaitReady();
-  });
-
   Object.entries(TESTS).forEach(([type, tests]): void => {
+    const keyring = new Keyring({ type: type as KeypairType });
+
+    beforeEach(async (): Promise<void> => {
+      await cryptoWaitReady();
+    });
+
     describe(type, (): void => {
       tests.forEach(({ pk, ss, uri }): void => {
         it(`creates ${uri}`, (): void => {
-          const pair = keyring.addFromUri(uri, {}, type as 'sr25519');
+          const pair = keyring.addFromUri(uri, {}, type as KeypairType);
 
           expect(u8aToHex(pair.publicKey)).toEqual(pk);
           expect(pair.address).toEqual(ss);

packages/keyring/src/testing.ts

@@ -3,7 +3,7 @@
 
 import type { KeyringInstance, KeyringOptions } from './types';
 
-import { hexToU8a } from '@polkadot/util';
+import { assert, hexToU8a } from '@polkadot/util';
 import { KeypairType } from '@polkadot/util-crypto/types';
 
 import { Keyring } from './keyring';
@@ -12,7 +12,7 @@ import { createPair } from './pair';
 interface PairDef {
   name?: string;
   publicKey: Uint8Array;
-  seed: string;
+  seed?: string;
   secretKey?: Uint8Array;
   type: KeypairType
 }
@@ -77,46 +77,49 @@ 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'
   }
 ];
 
+function createMeta (name?: string, seed?: string) {
+  assert(name || seed, 'Testing pair should have either a name or a seed');
+
+  return {
+    isTesting: true,
+    name: name || (seed && seed.replace('//', '_').toLowerCase())
+  };
+}
+
 /**
  * @name testKeyring
  * @summary Create an instance of Keyring pre-populated with locked test accounts
@@ -125,14 +128,13 @@ export const PAIRSETHEREUM: PairDef[] = [
  */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
-  const pairs: PairDef[] = (options.type && options.type === 'ethereum') ? PAIRSETHEREUM : PAIRSSR25519;
+  const pairs = (options.type && options.type === 'ethereum')
+    ? PAIRSETHEREUM
+    : PAIRSSR25519;
 
-  pairs.forEach(({ name, publicKey, secretKey, seed, type }): void => {
-    const meta = {
-      isTesting: true,
-      name: name || seed.replace('//', '_').toLowerCase()
-    };
-    const pair = !isDerived && !name
+  for (const { name, publicKey, secretKey, seed, type } of pairs) {
+    const meta = createMeta(name, seed);
+    const pair = !isDerived && !name && seed
       ? keyring.addFromUri(seed, meta, options.type)
       : keyring.addPair(
         createPair({ toSS58: keyring.encodeAddress, type }, { publicKey, secretKey }, meta)
@@ -141,7 +143,7 @@ export function createTestKeyring (options: KeyringOptions = {}, isDerived = tru
     pair.lock = (): void => {
       // we don't have lock/unlock functionality here
     };
-  });
+  }
 
   return keyring;
 }

packages/keyring/src/testingPairs.ts

@@ -15,11 +15,9 @@ export function createTestPairs (options?: KeyringOptions, isDerived = true): Te
   const pairs = keyring.getPairs();
   const map: TestKeyringMap = { nobody: nobody() };
 
-  return pairs.reduce((result, pair): TestKeyringMap => {
-    const { name } = pair.meta;
+  for (const p of pairs) {
+    map[p.meta.name as string] = p;
+  }
 
-    result[name as string] = pair;
-
-    return result;
-  }, map);
+  return map;
 }

packages/keyring/src/types.ts

@@ -1,9 +1,8 @@
 // Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Prefix } from '@polkadot/util-crypto/address/types';
-import type { EncryptedJson } from '@polkadot/util-crypto/json/types';
-import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
+import type { HexString } from '@polkadot/util/types';
+import type { EncryptedJson, Keypair, KeypairType, Prefix } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
   ss58Format?: Prefix;
@@ -13,7 +12,7 @@ export interface KeyringOptions {
 export type KeyringPair$Meta = Record<string, unknown>;
 
 export interface KeyringPair$Json extends EncryptedJson {
-  address: string;
+  address: string | HexString;
   meta: KeyringPair$Meta;
 }
 
@@ -34,14 +33,14 @@ export interface KeyringPair {
   encodePkcs8 (passphrase?: string): Uint8Array;
   lock (): void;
   setMeta (meta: KeyringPair$Meta): void;
-  sign (message: string | Uint8Array, options?: SignOptions): Uint8Array;
+  sign (message: HexString | string | Uint8Array, options?: SignOptions): Uint8Array;
   toJson (passphrase?: string): KeyringPair$Json;
   unlock (passphrase?: string): void;
-  encryptMessage (message: string | Uint8Array, recipientPublicKey: string | Uint8Array, nonce?: Uint8Array): Uint8Array;
-  decryptMessage (encryptedMessageWithNonce: string | Uint8Array, senderPublicKey: string | Uint8Array): Uint8Array | null;
-  verify (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array): boolean;
-  vrfSign (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
-  vrfVerify (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
+  encryptMessage (message: HexString | string | Uint8Array, recipientPublicKey: HexString | string | Uint8Array, nonce?: Uint8Array): Uint8Array;
+  decryptMessage (encryptedMessageWithNonce: HexString | string | Uint8Array, senderPublicKey: HexString | string | Uint8Array): Uint8Array | null;
+  verify (message: HexString | string | Uint8Array, signature: Uint8Array, signerPublic: HexString | string | Uint8Array): boolean;
+  vrfSign (message: HexString | string | Uint8Array, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): Uint8Array;
+  vrfVerify (message: HexString | string | Uint8Array, vrfResult: Uint8Array, signerPublic: HexString | Uint8Array | string, context?: HexString | string | Uint8Array, extra?: HexString | string | Uint8Array): boolean;
 }
 
 export interface KeyringPairs {

packages/keyring/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../util" },
+    { "path": "../util-crypto" }
+  ]
+}

packages/networks/package.json

@@ -1,25 +1,30 @@
 {
-  "name": "@polkadot/networks",
-  "version": "7.2.1",
-  "type": "module",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/common/issues",
+  "contributors": [],
   "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": [],
-  "contributors": [],
-  "license": "Apache-2.0",
-  "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/networks",
+  "repository": {
+    "directory": "packages/networks",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "version": "8.2.2",
+  "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.3"
+    "@babel/runtime": "^7.16.5"
   },
   "devDependencies": {
-    "@polkadot/util": "7.2.1",
-    "@polkadot/x-fetch": "7.2.1"
+    "@polkadot/hw-ledger": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/x-fetch": "8.2.2"
   }
 }

packages/networks/scripts/fromSubstrate.mjs

@@ -4,20 +4,27 @@
 import fs from 'fs';
 import fetch from 'node-fetch';
 
-const SUBSTRATE_REGISTRY = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
+import { substrateRegistry } from '../build/defaults.js';
 
-function outputField (v) {
+const substrateRegistryRepo = substrateRegistry
+  .replace('raw.githubusercontent.com', 'github.com')
+  .split('main')[0];
+
+function outputField (k, v) {
   if (typeof v === 'string') {
     return `'${v}'`;
   } else if (Array.isArray(v)) {
-    return `[${v.map((v) => outputField(v)).join(', ')}]`;
+    // new format is [] to indicate optionality
+    return (['decimals', 'symbols'].includes(k) && !v.length)
+      ? null
+      : `[${v.map((v) => outputField(k, v)).join(', ')}]`;
   }
 
   return v;
 }
 
 async function getSubstrateRegistry () {
-  const original = await fetch(SUBSTRATE_REGISTRY);
+  const original = await fetch(substrateRegistry);
   const json = await original.json();
 
   return json.registry
@@ -25,7 +32,7 @@ async function getSubstrateRegistry () {
       `  {\n${Object
         .entries(e)
         .sort(([a], [b]) => a.localeCompare(b))
-        .map(([k, v]) => `    ${k}: ${outputField(v)}`)
+        .map(([k, v]) => `    ${k}: ${outputField(k, v)}`)
         .join(',\n')}\n  }`
     )
     .join(',\n');
@@ -36,11 +43,17 @@ getSubstrateRegistry()
     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
+// This file should never be edited manually. Rather the process is as follow -
+//
+//   - make a PR to the upstream registry found at ${substrateRegistryRepo}
+//   - ensure the PR gets merged
+//   - yarn networks:sync in this repo to sync
+//
+// Any manual changes to this file will make CI cron checks fail and will be
+// lost when the registry is updated alongside the above sync.
 //
 
 import type { KnownSubstrate } from './types';

packages/networks/src/crosscheck.spec.ts

@@ -1,17 +1,17 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { KnownSubstrate, Ss58Registry } from './types';
+import type { Ss58Registry } from './types';
 
 import fs from 'fs';
 
-import { stringify } from '@polkadot/util';
+import { objectKeys, stringify } from '@polkadot/util';
 import { fetch } from '@polkadot/x-fetch';
 
+import { substrateRegistry } from './defaults';
 import { allNetworks } from './';
 
 const OUTPUT = './.github/ss58-check.md';
-const SUBSTRATE_REGISTRY = 'https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json';
 
 function assertAndLog (check: boolean, error: string): void {
   if (!check) {
@@ -28,7 +28,7 @@ describe('check latest Substrate ss58 registry', (): void => {
   let original: Ss58Registry;
 
   beforeAll(async (): Promise<void> => {
-    original = (await (await fetch(SUBSTRATE_REGISTRY)).json()) as Ss58Registry;
+    original = (await (await fetch(substrateRegistry)).json()) as Ss58Registry;
   });
 
   it('has the same number as the original', (): void => {
@@ -52,7 +52,7 @@ describe('check latest Substrate ss58 registry', (): void => {
   });
 
   it('has the same values as the original', (): void => {
-    const fields = Object.keys(original.schema) as (keyof KnownSubstrate)[];
+    const fields = objectKeys(original.schema);
     const errors = original.registry
       .map((n): [string, string[]] => {
         const other = allNetworks.find(({ prefix }) => prefix === n.prefix);
@@ -60,7 +60,11 @@ describe('check latest Substrate ss58 registry', (): void => {
         return [
           `${n.displayName} (${n.prefix})`,
           other
-            ? fields.filter((f) => stringify(n[f]) !== stringify(other[f]))
+            ? fields.filter((f) =>
+              ['decimals', 'symbols'].includes(f)
+                ? stringify(n[f] || []) !== stringify(other[f] || [])
+                : stringify(n[f]) !== stringify(other[f])
+            )
             : []
         ];
       })

packages/networks/src/defaults.spec.ts

@@ -1,25 +1,46 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { ledgerApps } from '@polkadot/hw-ledger/defaults';
 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([]);
+  describe('genesis', (): 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([]);
+    });
   });
 
-  it('has genesis for all Ledger chains', (): void => {
-    expect(
-      Object.keys(knownLedger).filter((network) =>
-        !knownGenesis[network]
-      )
-    ).toEqual([]);
+  describe('Ledger', (): 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/networks/src/defaults.ts

@@ -3,11 +3,19 @@
 
 import type { KnownGenesis, KnownIcon, KnownLedger, KnownTestnet } from './types';
 
+export const substrateRegistry = 'https://raw.githubusercontent.com/paritytech/ss58-registry/main/ss58-registry.json';
+
 // 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 = {
+  acala: [
+    '0xfc41b9bd8ef8fe53d58c7ea67c794c7ec9a73daf05e6d54b14ff6342c99ba64c'
+  ],
+  bifrost: [
+    '0x9f28c6a68e0fc9646eff64935684f6eeeece527e37bbe1f213d22caa1d9d6bed'
+  ],
   centrifuge: [
     '0x67dddf2673b69e5f875f6f25277495834398eafd67f492e09f3f3345e003d1b5'
   ],
@@ -20,6 +28,9 @@ export const knownGenesis: KnownGenesis = {
   equilibrium: [
     '0x6f1a800de3daff7f5e037ddf66ab22ce03ab91874debeddb1086f5f7dbd48925'
   ],
+  genshiro: [
+    '0x9b8cefc0eb5c568b527998bdd76c184e2b76ae561be76e4667072230217ea243'
+  ],
   hydradx: [
     '0xd2a620c27ec5cbc5621ff9a522689895074f7cca0d08e7134a7804e1a3ba86fc', // Snakenet Gen3-1
     '0x10af6e84234477d84dc572bac0789813b254aa490767ed06fb9591191d1073f9', // Snakenet Gen3
@@ -37,6 +48,12 @@ export const knownGenesis: KnownGenesis = {
     '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
     '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
   ],
+  'nodle-chain': [
+    '0xa3d114c2b8d0627c1aa9b134eafcf7d05ca561fdc19fb388bb9457f81809fb23'
+  ],
+  picasso: [
+    '0xe8e7f0f4c4f5a00720b4821dbfddefea7490bcf0b19009961cc46957984e2c1c'
+  ],
   plasm: [
     '0x3e86364d4b4894021cb2a0390bcf2feb5517d5292f2de2bb9404227e908b0b8b'
   ],
@@ -44,7 +61,13 @@ export const knownGenesis: KnownGenesis = {
     '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'
   ],
   polymesh: [
-    '0x9deeb940c92ae02111c3bd5baca89970384f4c9849f02a1b2e53e66414d30f9f'
+    '0x6fbd74e5e1d0a61d52ccfe9d4adaed16dd3a7caa37c6bc4d0c2fa12e8b2f4063'
+  ],
+  sora: [
+    '0x7e4e32d0feafd4f9c9414b0be86373f9a1efa904809b683453a9af6856d38ad5'
+  ],
+  stafi: [
+    '0x290a4149f09ea0e402c74c1c7e96ae4239588577fe78932f94f5404c68243d80'
   ],
   statemine: [
     '0x48239ef607d7928874027a43a67689209727dfb3d3dc5e5b03a39bdc2eda771a'
@@ -59,6 +82,7 @@ export const knownIcon: KnownIcon = {
   centrifuge: 'polkadot',
   kusama: 'polkadot',
   polkadot: 'polkadot',
+  sora: 'polkadot',
   statemine: 'polkadot',
   statemint: 'polkadot',
   westmint: 'polkadot'
@@ -68,20 +92,27 @@ export const knownIcon: KnownIcon = {
 // and maps to the known slip44 (minus the `0x8` hard derivation flag)
 // NOTE: Any network here needs to have a genesisHash attached in the config above
 export const knownLedger: KnownLedger = {
+  bifrost: 0x00000314,
   centrifuge: 0x000002eb,
   'dock-mainnet': 0x00000252,
   edgeware: 0x0000020b,
   equilibrium: 0x05f5e0fd,
+  genshiro: 0x05f5e0fc,
   kusama: 0x000001b2,
+  'nodle-chain': 0x000003eb,
   polkadot: 0x00000162,
   polymesh: 0x00000253,
+  sora: 0x00000269,
   statemine: 0x000001b2 // common-good on Kusama, shares derivation
 };
 
 // testnets should not allow selection
 export const knownTestnet: KnownTestnet = {
+  '': true, // this is the default non-network entry
+  'cess-testnet': true,
   'dock-testnet': true,
   jupiter: true,
   'mathchain-testnet': true,
+  subspace_testnet: true,
   'zero-alphaville': true
 };

packages/networks/src/interfaces.ts

@@ -1,43 +1,64 @@
 // Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import type { Network, SubstrateNetwork } from './types';
+import type { KnownSubstrate, Network, SubstrateNetwork } from './types';
 
 import { knownGenesis, knownIcon, knownLedger, knownTestnet } from './defaults';
 import { knownSubstrate } from './substrate';
 
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
+const TESTNETS = ['testnet'];
 
-export const allNetworks = knownSubstrate.map((o): SubstrateNetwork => {
+function toExpanded (o: KnownSubstrate): SubstrateNetwork {
   const network = o.network || '';
+  const nameParts = network.replace(/_/g, '-').split('-');
   const n = o as SubstrateNetwork;
 
+  // ledger additions
   n.slip44 = knownLedger[network];
   n.hasLedgerSupport = !!n.slip44;
 
+  // general items
   n.genesisHash = knownGenesis[network] || [];
   n.icon = knownIcon[network] || 'substrate';
-  n.isIgnored = !network || !!knownTestnet[network] || network.startsWith('reserved');
+
+  // filtering
+  n.isTestnet = !!knownTestnet[network] || TESTNETS.includes(nameParts[nameParts.length - 1]);
+  n.isIgnored = n.isTestnet || (!(o.standardAccount && o.decimals && o.symbols) && o.prefix !== 42);
 
   return n;
-});
+}
+
+function filterSelectable ({ genesisHash, prefix }: Network): boolean {
+  return !!genesisHash.length || prefix === 42;
+}
+
+function filterAvailable (n: SubstrateNetwork): n is Network {
+  return !n.isIgnored && !!n.network;
+}
+
+function sortNetworks (a: Network, b: Network): number {
+  const isUnSortedA = UNSORTED.includes(a.prefix);
+  const isUnSortedB = UNSORTED.includes(b.prefix);
+
+  return isUnSortedA === isUnSortedB
+    ? 0
+    : isUnSortedA
+      ? -1
+      : isUnSortedB
+        ? 1
+        : a.displayName.localeCompare(b.displayName);
+}
+
+// This is all the Substrate networks with our additional information
+export const allNetworks = knownSubstrate.map(toExpanded);
 
 // The list of available/claimed prefixes
 //   - no testnets
 //   - we only include those where we have a standardAccount
 //   - sort by name, however we keep 0, 2, 42 first in the list
-export const availableNetworks = allNetworks
-  .filter((n): n is Network => !n.isIgnored && !!n.network)
-  .sort((a, b) =>
-    UNSORTED.includes(a.prefix) === UNSORTED.includes(b.prefix)
-      ? 0
-      : UNSORTED.includes(a.prefix)
-        ? -1
-        : UNSORTED.includes(b.prefix)
-          ? 1
-          : a.displayName.localeCompare(b.displayName)
-  );
+export const availableNetworks = allNetworks.filter(filterAvailable).sort(sortNetworks);
 
 // A filtered list of those chains we have details about (genesisHashes)
-export const selectableNetworks = availableNetworks.filter((n) => n.genesisHash.length || n.prefix === 42);
+export const selectableNetworks = availableNetworks.filter(filterSelectable);

packages/networks/src/packageInfo.ts

@@ -3,4 +3,4 @@
 
 // Auto-generated by @polkadot/dev, do not edit
 
-export const packageInfo = { name: '@polkadot/networks', version: '7.2.1' };
+export const packageInfo = { name: '@polkadot/networks', version: '8.2.2' };

packages/networks/src/substrate.ts

@@ -1,11 +1,17 @@
 // 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
+// This file should never be edited manually. Rather the process is as follow -
+//
+//   - make a PR to the upstream registry found at https://github.com/paritytech/ss58-registry/
+//   - ensure the PR gets merged
+//   - yarn networks:sync in this repo to sync
+//
+// Any manual changes to this file will make CI cron checks fail and will be
+// lost when the registry is updated alongside the above sync.
 //
 
 import type { KnownSubstrate } from './types';
@@ -23,9 +29,9 @@ export const knownSubstrate: KnownSubstrate[] = [
   {
     decimals: null,
     displayName: 'Bare 32-bit Schnorr/Ristretto (S/R 25519) public key.',
-    network: null,
+    network: 'BareSr25519',
     prefix: 1,
-    standardAccount: null,
+    standardAccount: 'Sr25519',
     symbols: null,
     website: null
   },
@@ -41,9 +47,9 @@ export const knownSubstrate: KnownSubstrate[] = [
   {
     decimals: null,
     displayName: 'Bare 32-bit Ed25519 public key.',
-    network: null,
+    network: 'BareEd25519',
     prefix: 3,
-    standardAccount: null,
+    standardAccount: 'Ed25519',
     symbols: null,
     website: null
   },
@@ -129,13 +135,13 @@ export const knownSubstrate: KnownSubstrate[] = [
     website: 'https://polymath.network/'
   },
   {
-    decimals: null,
-    displayName: 'SubstraTEE',
-    network: 'substratee',
+    decimals: [12],
+    displayName: 'Integritee',
+    network: 'integritee',
     prefix: 13,
     standardAccount: '*25519',
-    symbols: null,
-    website: 'https://www.substratee.com'
+    symbols: ['TEER'],
+    website: 'https://integritee.network'
   },
   {
     decimals: [0],
@@ -143,7 +149,7 @@ export const knownSubstrate: KnownSubstrate[] = [
     network: 'totem',
     prefix: 14,
     standardAccount: '*25519',
-    symbols: ['XTX'],
+    symbols: ['TOTEM'],
     website: 'https://totemaccounting.com'
   },
   {
@@ -264,13 +270,13 @@ export const knownSubstrate: KnownSubstrate[] = [
     website: null
   },
   {
-    decimals: [18],
-    displayName: 'Dhiway CORD Network',
+    decimals: [12, 12],
+    displayName: 'CORD Network',
     network: 'cord',
     prefix: 29,
     standardAccount: '*25519',
-    symbols: ['DCU'],
-    website: 'https://dhiway.com/'
+    symbols: ['DHI', 'WAY'],
+    website: 'https://cord.network/'
   },
   {
     decimals: [12],
@@ -387,14 +393,14 @@ export const knownSubstrate: KnownSubstrate[] = [
     prefix: 42,
     standardAccount: '*25519',
     symbols: null,
-    website: 'https://substrate.dev/'
+    website: 'https://substrate.io/'
   },
   {
     decimals: null,
     displayName: 'Bare 32-bit ECDSA SECP-256k1 public key.',
-    network: null,
+    network: 'BareSecp256k1',
     prefix: 43,
-    standardAccount: null,
+    standardAccount: 'secp256k1',
     symbols: null,
     website: null
   },
@@ -443,6 +449,33 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['NEAT'],
     website: 'https://neatcoin.org'
   },
+  {
+    decimals: [12],
+    displayName: 'Picasso',
+    network: 'picasso',
+    prefix: 49,
+    standardAccount: '*25519',
+    symbols: ['PICA'],
+    website: 'https://picasso.composable.finance'
+  },
+  {
+    decimals: [12],
+    displayName: 'Composable',
+    network: 'composable',
+    prefix: 50,
+    standardAccount: '*25519',
+    symbols: ['LAYR'],
+    website: 'https://composable.finance'
+  },
+  {
+    decimals: [9],
+    displayName: 'xx network',
+    network: 'xxnetwork',
+    prefix: 55,
+    standardAccount: '*25519',
+    symbols: ['XX'],
+    website: 'https://xx.network'
+  },
   {
     decimals: [12],
     displayName: 'HydraDX',
@@ -471,12 +504,21 @@ export const knownSubstrate: KnownSubstrate[] = [
     website: 'https://crust.network'
   },
   {
-    decimals: [0, 9, 9, 9, 9, 9, 9, 9],
-    displayName: 'Equilibrium Network',
-    network: 'equilibrium',
+    decimals: [9, 9, 9],
+    displayName: 'Genshiro Network',
+    network: 'genshiro',
     prefix: 67,
     standardAccount: '*25519',
-    symbols: ['Unknown', 'USD', 'EQ', 'ETH', 'BTC', 'EOS', 'DOT', 'CRV'],
+    symbols: ['GENS', 'EQD', 'LPT0'],
+    website: 'https://genshiro.equilibrium.io'
+  },
+  {
+    decimals: [9],
+    displayName: 'Equilibrium Network',
+    network: 'equilibrium',
+    prefix: 68,
+    standardAccount: '*25519',
+    symbols: ['EQ'],
     website: 'https://equilibrium.io'
   },
   {
@@ -498,12 +540,12 @@ export const knownSubstrate: KnownSubstrate[] = [
     website: 'https://zeitgeist.pm'
   },
   {
-    decimals: [12],
+    decimals: [18],
     displayName: 'Manta network',
     network: 'manta',
     prefix: 77,
     standardAccount: '*25519',
-    symbols: ['MA'],
+    symbols: ['MANTA'],
     website: 'https://manta.network'
   },
   {
@@ -515,6 +557,15 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['KMA'],
     website: 'https://manta.network'
   },
+  {
+    decimals: [12],
+    displayName: 'Polkadex Mainnet',
+    network: 'polkadex',
+    prefix: 88,
+    standardAccount: '*25519',
+    symbols: ['PDEX'],
+    website: 'https://polkadex.trade'
+  },
   {
     decimals: [18],
     displayName: 'PolkaSmith Canary Network',
@@ -542,6 +593,15 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['TRAC'],
     website: 'https://origintrail.io'
   },
+  {
+    decimals: [10],
+    displayName: 'Pontem Network',
+    network: 'pontem-network',
+    prefix: 105,
+    standardAccount: '*25519',
+    symbols: ['PONT'],
+    website: 'https://pontem.network'
+  },
   {
     decimals: [12],
     displayName: 'Heiko',
@@ -551,6 +611,24 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['HKO'],
     website: 'https://parallel.fi/'
   },
+  {
+    decimals: null,
+    displayName: 'Integritee Incognito',
+    network: 'integritee-incognito',
+    prefix: 113,
+    standardAccount: '*25519',
+    symbols: null,
+    website: 'https://integritee.network'
+  },
+  {
+    decimals: [18],
+    displayName: 'Clover Finance',
+    network: 'clover',
+    prefix: 128,
+    standardAccount: '*25519',
+    symbols: ['CLV'],
+    website: 'https://clover.finance'
+  },
   {
     decimals: [18],
     displayName: 'Altair',
@@ -578,6 +656,33 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['NET'],
     website: 'https://social.network'
   },
+  {
+    decimals: [15],
+    displayName: 'QUARTZ by UNIQUE',
+    network: 'quartz_mainnet',
+    prefix: 255,
+    standardAccount: '*25519',
+    symbols: ['QTZ'],
+    website: 'https://unique.network'
+  },
+  {
+    decimals: [18],
+    displayName: 'Pioneer Network by Bit.Country',
+    network: 'pioneer_network',
+    prefix: 268,
+    standardAccount: '*25519',
+    symbols: ['NEER'],
+    website: 'https://bit.country'
+  },
+  {
+    decimals: [18],
+    displayName: 'Efinity',
+    network: 'efinity',
+    prefix: 1110,
+    standardAccount: 'Sr25519',
+    symbols: ['EFI'],
+    website: 'https://efinity.io/'
+  },
   {
     decimals: [18],
     displayName: 'Moonbeam',
@@ -596,6 +701,51 @@ export const knownSubstrate: KnownSubstrate[] = [
     symbols: ['MOVR'],
     website: 'https://moonbeam.network'
   },
+  {
+    decimals: [12],
+    displayName: 'Kapex',
+    network: 'kapex',
+    prefix: 2007,
+    standardAccount: '*25519',
+    symbols: ['KAPEX'],
+    website: 'https://totemaccounting.com'
+  },
+  {
+    decimals: [10],
+    displayName: 'Interlay',
+    network: 'interlay',
+    prefix: 2032,
+    standardAccount: '*25519',
+    symbols: ['INTR'],
+    website: 'https://interlay.io/'
+  },
+  {
+    decimals: [12],
+    displayName: 'Kintsugi',
+    network: 'kintsugi',
+    prefix: 2092,
+    standardAccount: '*25519',
+    symbols: ['KINT'],
+    website: 'https://interlay.io/'
+  },
+  {
+    decimals: [18],
+    displayName: 'Subspace testnet',
+    network: 'subspace_testnet',
+    prefix: 2254,
+    standardAccount: '*25519',
+    symbols: ['tSSC'],
+    website: 'https://subspace.network'
+  },
+  {
+    decimals: [18],
+    displayName: 'Subspace',
+    network: 'subspace',
+    prefix: 6094,
+    standardAccount: '*25519',
+    symbols: ['SSC'],
+    website: 'https://subspace.network'
+  },
   {
     decimals: [12],
     displayName: 'Basilisk',
@@ -604,5 +754,32 @@ export const knownSubstrate: KnownSubstrate[] = [
     standardAccount: '*25519',
     symbols: ['BSX'],
     website: 'https://bsx.fi'
+  },
+  {
+    decimals: [12],
+    displayName: 'CESS Testnet',
+    network: 'cess-testnet',
+    prefix: 11330,
+    standardAccount: '*25519',
+    symbols: ['TCESS'],
+    website: 'https://cess.cloud'
+  },
+  {
+    decimals: [12],
+    displayName: 'CESS',
+    network: 'cess',
+    prefix: 11331,
+    standardAccount: '*25519',
+    symbols: ['CESS'],
+    website: 'https://cess.cloud'
+  },
+  {
+    decimals: [18],
+    displayName: 'Automata ContextFree',
+    network: 'contextfree',
+    prefix: 11820,
+    standardAccount: '*25519',
+    symbols: ['CTX'],
+    website: 'https://ata.network'
   }
 ];

packages/networks/src/types.ts

@@ -8,7 +8,7 @@ export interface KnownSubstrate {
   displayName: string;
   network: string | null;
   prefix: number;
-  standardAccount: '*25519' | 'secp256k1' | null;
+  standardAccount: '*25519' | 'Ed25519' | 'Sr25519' | 'secp256k1' | null;
   symbols: string[] | null;
   website: string | null;
 }
@@ -26,6 +26,7 @@ export interface SubstrateNetwork extends KnownSubstrate {
   hasLedgerSupport: boolean;
   icon: Icon;
   isIgnored: boolean;
+  isTestnet: boolean;
   slip44?: number | null;
 }
 
@@ -36,5 +37,5 @@ export interface Network extends SubstrateNetwork {
 export interface Ss58Registry {
   registry: KnownSubstrate[];
   specification: string;
-  schema: Record<string, string>;
+  schema: Record<keyof KnownSubstrate, string>;
 }

packages/networks/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../hw-ledger" },
+    { "path": "../util" },
+    { "path": "../x-fetch" }
+  ]
+}

packages/util-crypto/package.json

@@ -1,52 +1,50 @@
 {
-  "name": "@polkadot/util-crypto",
-  "version": "7.2.1",
-  "type": "module",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/polkadot-js/common/issues",
+  "contributors": [],
   "description": "A collection of useful crypto utilities for @polkadot",
-  "main": "index.js",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
+  "license": "Apache-2.0",
+  "maintainers": [],
+  "name": "@polkadot/util-crypto",
+  "repository": {
+    "directory": "packages/util-crypto",
+    "type": "git",
+    "url": "https://github.com/polkadot-js/common.git"
+  },
   "sideEffects": [
     "./cryptoInit.js",
     "./cryptoInit.cjs",
     "./detectPackage.js",
     "./detectPackage.cjs"
   ],
-  "engines": {
-    "node": ">=14.0.0"
+  "type": "module",
+  "version": "8.2.2",
+  "browser": {
+    "crypto": false,
+    "stream": false
   },
-  "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [],
-  "contributors": [],
-  "license": "Apache-2.0",
-  "repository": "github:polkadot-js/common",
-  "bugs": "https://github.com/polkadot-js/common/issues",
-  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
+  "main": "index.js",
   "dependencies": {
-    "@babel/runtime": "^7.15.3",
-    "@polkadot/networks": "7.2.1",
-    "@polkadot/util": "7.2.1",
-    "@polkadot/wasm-crypto": "^4.1.2",
-    "@polkadot/x-randomvalues": "7.2.1",
-    "base-x": "^3.0.8",
-    "base64-js": "^1.5.1",
-    "blakejs": "^1.1.1",
-    "bn.js": "^4.11.9",
-    "create-hash": "^1.2.0",
+    "@babel/runtime": "^7.16.5",
+    "@noble/hashes": "^0.4.5",
+    "@noble/secp256k1": "^1.3.4",
+    "@polkadot/networks": "8.2.2",
+    "@polkadot/util": "8.2.2",
+    "@polkadot/wasm-crypto": "^4.5.1",
+    "@polkadot/x-bigint": "8.2.2",
+    "@polkadot/x-randomvalues": "8.2.2",
     "ed2curve": "^0.3.0",
-    "elliptic": "^6.5.4",
-    "hash.js": "^1.1.7",
-    "js-sha3": "^0.8.0",
-    "scryptsy": "^2.1.0",
-    "tweetnacl": "^1.0.3",
-    "xxhashjs": "^0.2.2"
+    "micro-base": "^0.10.0",
+    "tweetnacl": "^1.0.3"
   },
   "devDependencies": {
-    "@types/bn.js": "^4.11.6",
-    "@types/create-hash": "^1.2.2",
-    "@types/elliptic": "^6.4.13",
-    "@types/scryptsy": "^2.0.0",
-    "@types/xxhashjs": "^0.2.2"
+    "@types/ed2curve": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "7.2.1"
+    "@polkadot/util": "8.2.2"
   }
 }

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

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

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

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

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { base58Decode } from '../base58/decode';
+import { base58Decode } from '../base58';
 import { checkAddressChecksum } from './checksum';
 
 describe('checkAddressChecksum', (): void => {

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

@@ -3,21 +3,15 @@
 
 import { hexToU8a, stringToU8a, u8aToHex } from '@polkadot/util';
 
-import { createTestPairs, TestKeyringMap } from '../../../keyring/src/testingPairs';
+import { ALICE_PUBLIC_SR } from './encode.spec';
 import { decodeAddress } from '.';
 
 describe('decodeAddress', (): void => {
-  let keyring: TestKeyringMap;
-
-  beforeAll((): void => {
-    keyring = createTestPairs({ type: 'sr25519' });
-  });
-
   it('decodes an address', (): void => {
     expect(
       decodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
     ).toEqual(
-      keyring.alice.publicKey
+      ALICE_PUBLIC_SR
     );
   });
 

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

@@ -1,16 +1,17 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6
 import { assert, isHex, isU8a, u8aToU8a } from '@polkadot/util';
 
-import { base58Decode } from '../base58/decode';
+import { base58Decode } from '../base58';
 import { checkAddressChecksum } from './checksum';
 import { defaults } from './defaults';
 
-export function decodeAddress (encoded?: string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
+export function decodeAddress (encoded?: HexString | string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
   assert(encoded, 'Invalid empty address passed');
 
   if (isU8a(encoded) || isHex(encoded)) {
@@ -29,6 +30,6 @@ export function decodeAddress (encoded?: string | Uint8Array | null, ignoreCheck
 
     return decoded.slice(ss58Length, endPos);
   } catch (error) {
-    throw new Error(`Decoding ${encoded as string}: ${(error as Error).message}`);
+    throw new Error(`Decoding ${encoded}: ${(error as Error).message}`);
   }
 }

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

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

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

@@ -1,28 +1,37 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
+import type { DeriveJunction } from '../key/DeriveJunction';
 import type { Prefix } from './types';
 
 import { assert } from '@polkadot/util';
 
 import { keyExtractPath } from '../key';
-import { DeriveJunction } from '../key/DeriveJunction';
-import { schnorrkelDerivePublic } from '../schnorrkel';
+import { sr25519DerivePublic } from '../sr25519';
 import { decodeAddress } from './decode';
 import { encodeAddress } from './encode';
 
+function filterHard ({ isHard }: DeriveJunction): boolean {
+  return isHard;
+}
+
 /**
  * @name deriveAddress
  * @summary Creates a sr25519 derived address from the supplied and path.
  * @description
  * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
  */
-export function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+export function deriveAddress (who: HexString | Uint8Array | string, suri: string, ss58Format?: Prefix): string {
   const { path } = keyExtractPath(suri);
 
-  assert(path.length && !path.some((path) => path.isHard), 'Expected suri to contain a combination of non-hard paths');
+  assert(path.length && !path.every(filterHard), 'Expected suri to contain a combination of non-hard paths');
 
-  return encodeAddress(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
-    return schnorrkelDerivePublic(publicKey, path.chainCode);
-  }, decodeAddress(who)), ss58Format);
+  let publicKey = decodeAddress(who);
+
+  for (const { chainCode } of path) {
+    publicKey = sr25519DerivePublic(publicKey, chainCode);
+  }
+
+  return encodeAddress(publicKey, ss58Format);
 }

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

@@ -1,11 +1,11 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { createTestPairs } from '@polkadot/keyring/testingPairs';
-
 import { encodeAddress } from '.';
 
-const keyring = createTestPairs({ type: 'ed25519' }, false);
+export const ALICE_PUBLIC_SR = new Uint8Array([212, 53, 147, 199, 21, 253, 211, 28, 97, 20, 26, 189, 4, 169, 159, 214, 130, 44, 133, 88, 133, 76, 205, 227, 154, 86, 132, 231, 165, 109, 162, 125]);
+
+export const ALICE_PUBLIC_ED = new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79]);
 
 const SUBKEY = [
   {
@@ -69,7 +69,7 @@ const SUBKEY = [
 describe('encode', (): void => {
   it('encodes an address to a valid value', (): void => {
     expect(
-      keyring.alice.address
+      encodeAddress(ALICE_PUBLIC_ED)
     ).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
   });
 
@@ -88,7 +88,7 @@ describe('encode', (): void => {
   it('fails when non-valid publicKey provided', (): void => {
     expect(
       (): string => encodeAddress(
-        keyring.alice.publicKey.slice(0, 30)
+        ALICE_PUBLIC_ED.slice(0, 30)
       )
     ).toThrow(/Expected a valid key/);
   });
@@ -141,7 +141,7 @@ describe('encode', (): void => {
 
   it('encodes with 2 byte prefix', (): void => {
     expect(
-      encodeAddress(keyring.alice.publicKey, 255)
+      encodeAddress(ALICE_PUBLIC_ED, 255)
     ).toEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k');
   });
 
@@ -155,19 +155,19 @@ describe('encode', (): void => {
 
   it('does not encode for > 16,383, < 0', (): void => {
     expect(
-      () => encodeAddress(keyring.alice.publicKey, -1)
+      () => encodeAddress(ALICE_PUBLIC_ED, -1)
     ).toThrow(/range ss58Format specified/);
     expect(
-      () => encodeAddress(keyring.alice.publicKey, 16384)
+      () => encodeAddress(ALICE_PUBLIC_ED, 16384)
     ).toThrow(/range ss58Format specified/);
   });
 
   it('does not encode reserved', (): void => {
     expect(
-      () => encodeAddress(keyring.alice.publicKey, 46)
+      () => encodeAddress(ALICE_PUBLIC_ED, 46)
     ).toThrow(/range ss58Format specified/);
     expect(
-      () => encodeAddress(keyring.alice.publicKey, 47)
+      () => encodeAddress(ALICE_PUBLIC_ED, 47)
     ).toThrow(/range ss58Format specified/);
   });
 });

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

@@ -1,17 +1,18 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
 import type { Prefix } from './types';
 
 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L34
 import { assert, u8aConcat } from '@polkadot/util';
 
-import { base58Encode } from '../base58/encode';
+import { base58Encode } from '../base58';
 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: HexString | Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
   // decode it, this means we can re-encode an address
   const u8a = decodeAddress(key);
 

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

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

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

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

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

@@ -1,8 +1,7 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { createTestPairs } from '@polkadot/keyring/testingPairs';
-
+import { ALICE_PUBLIC_SR } from './encode.spec';
 import { addressEq } from '.';
 
 describe('addressEq', (): void => {
@@ -34,12 +33,10 @@ describe('addressEq', (): void => {
   });
 
   it('returns true for equal, address vs publicKey', (): void => {
-    const keyring = createTestPairs({ type: 'sr25519' });
-
     expect(
       addressEq(
         '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
-        keyring.alice.publicKey
+        ALICE_PUBLIC_SR
       )
     ).toEqual(true);
   });

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

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

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

@@ -1,28 +1,23 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { HexString } from '@polkadot/util/types';
 import type { HashType } from '../secp256k1/types';
 import type { Prefix } from './types';
 
-import { u8aConcat } from '@polkadot/util';
+import { assert, u8aConcat } from '@polkadot/util';
 
-import { secp256k1Hasher } from '../secp256k1/hasher';
+import { hasher } from '../secp256k1/hasher';
 import { encodeAddress } from './encode';
 
 /**
  * @name evmToAddress
  * @summary Converts an EVM address to its corresponding SS58 address.
  */
-export function evmToAddress (evmAddress: string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
-  const wrapError = (message: string) => `Converting ${evmAddress as string}: ${message}`;
-
+export function evmToAddress (evmAddress: HexString | string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
   const message = u8aConcat('evm:', evmAddress);
 
-  if (message.length !== 24) {
-    throw new Error(wrapError('Invalid evm address length'));
-  }
+  assert(message.length === 24, () => `Converting ${evmAddress as string}: Invalid evm address length`);
 
-  const address = secp256k1Hasher(hashType, message);
-
-  return encodeAddress(address, ss58Format);
+  return encodeAddress(hasher(hashType, message), ss58Format);
 }

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

@@ -0,0 +1,111 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isAddress } from '.';
+
+describe('isAddress', (): void => {
+  it('decodes an address', (): void => {
+    expect(
+      isAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+    ).toEqual(true);
+  });
+
+  it('decodes the council address', (): void => {
+    expect(
+      isAddress('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29')
+    ).toEqual(true);
+  });
+
+  it('converts a publicKey (hex) as-is', (): void => {
+    expect(
+      isAddress('0x01020304')
+    ).toEqual(true);
+  });
+
+  it('decodes a short address', (): void => {
+    expect(
+      isAddress('F7NZ')
+    ).toEqual(true);
+  });
+
+  it('decodes a 1-byte accountId (with prefix)', (): void => {
+    expect(
+      isAddress('g4b', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte accountId', (): void => {
+    expect(
+      isAddress('3xygo', false, 2)
+    ).toEqual(true);
+  });
+
+  it('encodes a 4-byte address', (): void => {
+    expect(
+      isAddress('zswfoZa', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 8-byte address', (): void => {
+    expect(
+      isAddress('848Gh2GcGaZia', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 33-byte address', (): void => {
+    expect(
+      isAddress('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (65)', (): void => {
+    expect(
+      isAddress('cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (69)', (): void => {
+    expect(
+      isAddress('cnUaoo5wodnTVA4bnr4woSweto8hWZADUvLFXkR9Q6U7BRsbF')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (252)', (): void => {
+    expect(
+      isAddress('xw9Hca4RJTmBRgzJT4ieJBh7XCK9gE3NXBDSEmgGHd4TCrbnG')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (255)', (): void => {
+    expect(
+      isAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (ecdsa, from Substrate)', (): void => {
+    expect(
+      isAddress('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV')
+    ).toEqual(true);
+  });
+
+  it('fails when length is invalid', (): void => {
+    expect(
+      isAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')
+    ).toEqual(false);
+  });
+
+  it('fails when the checksum does not match', (): void => {
+    expect(
+      isAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMa9cj')
+    ).toEqual(false);
+    expect(
+      isAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
+    ).toEqual(false);
+  });
+
+  it('fails when invalid base58 encoded address is found', (): void => {
+    expect(
+      isAddress('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29')
+    ).toEqual(false);
+  });
+});

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

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

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

@@ -2,20 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
+import type { HexString } from '@polkadot/util/types';
 
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
 import { blake2AsU8a } from '../blake2/asU8a';
+import { BN_LE_16_OPTS } from '../bn';
 import { decodeAddress } from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export function createKeyDerived (who: Uint8Array | string, index: bigint | BN | number): Uint8Array {
+export function createKeyDerived (who: HexString | Uint8Array | string, index: bigint | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,
       decodeAddress(who),
-      bnToU8a(index, { bitLength: 16, isLe: true })
+      bnToU8a(index, BN_LE_16_OPTS)
     )
   );
 }

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

@@ -2,21 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { BN } from '@polkadot/util';
+import type { HexString } from '@polkadot/util/types';
 
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
 
 import { blake2AsU8a } from '../blake2/asU8a';
-import { decodeAddress } from './decode';
+import { BN_LE_16_OPTS } from '../bn';
+import { addressToU8a } from './util';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export function createKeyMulti (who: (Uint8Array | string)[], threshold: bigint | BN | number): Uint8Array {
+export function createKeyMulti (who: (HexString | Uint8Array | string)[], threshold: bigint | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,
       compactToU8a(who.length),
-      ...u8aSorted(who.map((who) => decodeAddress(who))),
-      bnToU8a(threshold, { bitLength: 16, isLe: true })
+      ...u8aSorted(who.map(addressToU8a)),
+      bnToU8a(threshold, BN_LE_16_OPTS)
     )
   );
 }

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

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

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

@@ -0,0 +1,8 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { decodeAddress } from './decode';
+
+export function addressToU8a (who: string | Uint8Array): Uint8Array {
+  return decodeAddress(who);
+}

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

@@ -0,0 +1,111 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { validateAddress } from '.';
+
+describe('validateAddress', (): void => {
+  it('decodes an address', (): void => {
+    expect(
+      validateAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+    ).toEqual(true);
+  });
+
+  it('decodes the council address', (): void => {
+    expect(
+      validateAddress('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29')
+    ).toEqual(true);
+  });
+
+  it('converts a publicKey (hex) as-is', (): void => {
+    expect(
+      validateAddress('0x01020304')
+    ).toEqual(true);
+  });
+
+  it('decodes a short address', (): void => {
+    expect(
+      validateAddress('F7NZ')
+    ).toEqual(true);
+  });
+
+  it('decodes a 1-byte accountId (with prefix)', (): void => {
+    expect(
+      validateAddress('g4b', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte accountId', (): void => {
+    expect(
+      validateAddress('3xygo', false, 2)
+    ).toEqual(true);
+  });
+
+  it('encodes a 4-byte address', (): void => {
+    expect(
+      validateAddress('zswfoZa', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 8-byte address', (): void => {
+    expect(
+      validateAddress('848Gh2GcGaZia', false, 2)
+    ).toEqual(true);
+  });
+
+  it('decodes a 33-byte address', (): void => {
+    expect(
+      validateAddress('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (65)', (): void => {
+    expect(
+      validateAddress('cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (69)', (): void => {
+    expect(
+      validateAddress('cnUaoo5wodnTVA4bnr4woSweto8hWZADUvLFXkR9Q6U7BRsbF')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (252)', (): void => {
+    expect(
+      validateAddress('xw9Hca4RJTmBRgzJT4ieJBh7XCK9gE3NXBDSEmgGHd4TCrbnG')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (255)', (): void => {
+    expect(
+      validateAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
+    ).toEqual(true);
+  });
+
+  it('decodes a 2-byte prefix (ecdsa, from Substrate)', (): void => {
+    expect(
+      validateAddress('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV')
+    ).toEqual(true);
+  });
+
+  it('fails when length is invalid', (): void => {
+    expect(
+      () => validateAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')
+    ).toThrow(/address length/);
+  });
+
+  it('fails when the checksum does not match', (): void => {
+    expect(
+      () => validateAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMa9cj')
+    ).toThrow(/address checksum/);
+    expect(
+      () => validateAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
+    ).toThrow(/address checksum/);
+  });
+
+  it('fails when invalid base58 encoded address is found', (): void => {
+    expect(
+      () => validateAddress('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29')
+    ).toThrow(/Decoding F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29: Invalid base58 character "I" \(0x49\) at index 4/);
+  });
+});

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

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

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

@@ -1,6 +1,53 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// https://github.com/multiformats/js-multibase/blob/master/src/constants.js
-export const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
-export const BITS_PER_CHAR = 5;
+import { utils } from 'micro-base';
+
+import { createDecode, createEncode, createIs, createValidate } from './helpers';
+
+const chars = 'abcdefghijklmnopqrstuvwxyz234567';
+
+const config = {
+  chars,
+  coder: utils.chain(
+    // We define our own chain, the default base32 has padding
+    utils.radix2(5),
+    utils.alphabet(chars),
+    {
+      decode: (input: string) => input.split(''),
+      encode: (input: string[]) => input.join('')
+    }
+  ),
+  ipfs: 'b',
+  type: 'base32'
+};
+
+/**
+ * @name base32Validate
+ * @summary Validates a base32 value.
+ * @description
+ * Validates that the supplied value is valid base32, throwing exceptions if not
+ */
+export const base32Validate = createValidate(config);
+
+/**
+* @name isBase32
+* @description Checks if the input is in base32, returning true/false
+*/
+export const isBase32 = createIs(base32Validate);
+
+/**
+ * @name base32Decode
+ * @summary Delookup a base32 value.
+ * @description
+ * From the provided input, decode the base32 and return the result as an `Uint8Array`.
+ */
+export const base32Decode = createDecode(config, base32Validate);
+
+/**
+* @name base32Encode
+* @summary Creates a base32 value.
+* @description
+* From the provided input, create the base32 and return the result as a string.
+*/
+export const base32Encode = createEncode(config);

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

@@ -3,7 +3,7 @@
 
 import { u8aToString } from '@polkadot/util';
 
-import { base32Decode } from './';
+import { base32Decode } from '.';
 
 describe('base32Decode', (): void => {
   it('decodes a base32', (): void => {

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

@@ -1,58 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
-
-import { assert } from '@polkadot/util';
-
-import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
-import { base32Validate } from './validate';
-
-// Build the character lookup table:
-const LOOKUP = BASE32_ALPHABET
-  .split('')
-  .reduce((lookup: Record<string, number>, char: string, index: number): Record<string, number> => {
-    lookup[char] = index;
-
-    return lookup;
-  }, {});
-
-/** @internal */
-function decode (output: Uint8Array, input: string, offset: number): [Uint8Array, number, number] {
-  let bits = 0;
-  let buffer = 0;
-  let written = 0;
-
-  for (let i = offset; i < input.length; i++) {
-    buffer = (buffer << BITS_PER_CHAR) | LOOKUP[input[i]];
-    bits += BITS_PER_CHAR;
-
-    if (bits >= 8) {
-      bits -= 8;
-      output[written++] = 0xff & (buffer >> bits);
-    }
-  }
-
-  return [output, bits, buffer];
-}
-
-/**
- * @name base32Decode
- * @summary Delookup a base32 value.
- * @description
- * From the provided input, decode the base32 and return the result as an `Uint8Array`.
- */
-export function base32Decode (value: string, ipfsCompat = false): Uint8Array {
-  base32Validate(value, ipfsCompat);
-
-  const offset = (ipfsCompat ? 1 : 0);
-  const [output, bits, buffer] = decode(
-    new Uint8Array(((value.length - offset) * BITS_PER_CHAR / 8) | 0),
-    value,
-    offset
-  );
-
-  assert(!(bits >= BITS_PER_CHAR || 0xff & (buffer << (8 - bits))), 'Unexpected end of data');
-
-  return output;
-}

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { base58Decode } from '../base58';
-import { base32Encode } from './';
+import { base32Encode } from '.';
 
 describe('base32Encode', (): void => {
   it('encodes to a base32', (): void => {
@@ -11,6 +11,12 @@ describe('base32Encode', (): void => {
     ).toEqual('irswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb');
   });
 
+  it('encodes to a base32 (ipfs-compat)', (): void => {
+    expect(
+      base32Encode('Decentralize everything!!', true)
+    ).toEqual('birswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb');
+  });
+
   it('encodes a base58 to a base32', (): void => {
     expect(
       base32Encode(

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

@@ -1,41 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
-
-import { u8aToU8a } from '@polkadot/util';
-
-import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
-
-const MASK = (1 << BITS_PER_CHAR) - 1;
-
-/**
- * @name base32Encode
- * @summary Creates a base32 value.
- * @description
- * From the provided input, create the base32 and return the result as a string.
- */
-export function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
-  const u8a = u8aToU8a(value);
-  let out = '';
-  let bits = 0;
-  let buffer = 0;
-
-  for (let i = 0; i < u8a.length; ++i) {
-    buffer = (buffer << 8) | u8a[i];
-    bits += 8;
-
-    while (bits > BITS_PER_CHAR) {
-      bits -= BITS_PER_CHAR;
-      out += BASE32_ALPHABET[MASK & (buffer >> bits)];
-    }
-  }
-
-  if (bits) {
-    out += BASE32_ALPHABET[MASK & (buffer << (BITS_PER_CHAR - bits))];
-  }
-
-  return ipfsCompat
-    ? `b${out}`
-    : out;
-}

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

@@ -0,0 +1,84 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { U8aLike } from '@polkadot/util/types';
+
+import { assert, u8aToU8a } from '@polkadot/util';
+
+// re-export the type so *.d.ts files don't have ../src imports
+export type { U8aLike } from '@polkadot/util/types';
+
+interface Coder {
+  decode: (value: string) => Uint8Array;
+  encode: (value: Uint8Array) => string;
+}
+
+interface Config {
+  chars: string;
+  coder: Coder;
+  ipfs?: string;
+  regex?: RegExp;
+  type: string;
+}
+
+type DecodeFn = (value: string, ipfsCompat?: boolean) => Uint8Array;
+
+type EncodeFn = (value: U8aLike, ipfsCompat?: boolean) => string;
+
+type ValidateFn = (value?: unknown, ipfsCompat?: boolean) => value is string;
+
+export function createDecode ({ coder, ipfs }: Config, validate: ValidateFn): DecodeFn {
+  return (value: string, ipfsCompat?: boolean): Uint8Array => {
+    validate(value, ipfsCompat);
+
+    return coder.decode(
+      ipfs && ipfsCompat
+        ? value.substr(1)
+        : value
+    );
+  };
+}
+
+export function createEncode ({ coder, ipfs }: Config): EncodeFn {
+  return (value: U8aLike, ipfsCompat?: boolean): string => {
+    const out = coder.encode(u8aToU8a(value));
+
+    return ipfs && ipfsCompat
+      ? `${ipfs}${out}`
+      : out;
+  };
+}
+
+export function createIs (validate: ValidateFn): ValidateFn {
+  return (value?: unknown, ipfsCompat?: boolean): value is string => {
+    try {
+      return validate(value, ipfsCompat);
+    } catch (error) {
+      return false;
+    }
+  };
+}
+
+export function createValidate ({ chars, ipfs, type }: Config): ValidateFn {
+  return (value?: unknown, ipfsCompat?: boolean): value is string => {
+    assert(value && typeof value === 'string', () => `Expected non-null, non-empty ${type} string input`);
+
+    if (ipfs && ipfsCompat) {
+      assert(value[0] === ipfs, () => `Expected ipfs-compatible ${type} to start with '${ipfs}'`);
+    }
+
+    for (let i = (ipfsCompat ? 1 : 0); i < value.length; i++) {
+      assert(
+        chars.includes(value[i]) || (
+          value[i] === '=' && (
+            (i === value.length - 1) ||
+            !chars.includes(value[i + 1])
+          )
+        ),
+        () => `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`
+      );
+    }
+
+    return true;
+  };
+}

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

@@ -5,7 +5,4 @@
  * @summary Encode and decode base32 values
  */
 
-export { base32Decode } from './decode';
-export { base32Encode } from './encode';
-export { base32Validate } from './validate';
-export { isBase32 } from './is';
+export { base32Decode, base32Encode, base32Validate, isBase32 } from './bs32';

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

@@ -0,0 +1,30 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isBase32 } from '.';
+
+describe('isBase32', (): void => {
+  it('validates encoded', (): void => {
+    expect(
+      isBase32('afkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', false)
+    ).toEqual(true);
+  });
+
+  it('validates ipfs-compat encoded', (): void => {
+    expect(
+      isBase32('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', false)
+    ).toEqual(true);
+  });
+
+  it('fails on invalid', (): void => {
+    expect(
+      isBase32('not in base32')
+    ).toEqual(false);
+  });
+
+  it('fails on non-ipfs', (): void => {
+    expect(
+      isBase32('afkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+    ).toEqual(false);
+  });
+});

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

@@ -1,16 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { base32Validate } from './validate';
-
-export function testValidator (validate: (value?: string | null, ipfsCompat?: boolean) => boolean, value?: string | null, ipfsCompat?: boolean): boolean {
-  try {
-    return validate(value, ipfsCompat);
-  } catch (error) {
-    return false;
-  }
-}
-
-export function isBase32 (value?: string | null, ipfsCompat?: boolean): value is string {
-  return testValidator(base32Validate, value, ipfsCompat);
-}

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

@@ -4,9 +4,39 @@
 import { base32Validate } from '.';
 
 describe('base32Validate', (): void => {
+  it('validates encoded', (): void => {
+    expect(
+      base32Validate('afkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', false)
+    ).toEqual(true);
+  });
+
   it('validates ipfs-compat encoded', (): void => {
     expect(
-      () => base32Validate('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
-    ).not.toThrow();
+      base32Validate('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+    ).toEqual(true);
+  });
+
+  it('fails on empty', (): void => {
+    expect(
+      () => base32Validate('')
+    ).toThrow(/Expected/);
+  });
+
+  it('fails on non-string', (): void => {
+    expect(
+      () => base32Validate(true)
+    ).toThrow(/Expected/);
+  });
+
+  it('fails on invalid', (): void => {
+    expect(
+      () => base32Validate('not in base32')
+    ).toThrow(/Invalid/);
+  });
+
+  it('fails on non-ipfs', (): void => {
+    expect(
+      () => base32Validate('afkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+    ).toThrow(/Expected/);
   });
 });

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

@@ -1,17 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { validateChars } from '../base58/validate';
-import { BASE32_ALPHABET } from './bs32';
-
-const BASE_CONFIG = { alphabet: BASE32_ALPHABET, ipfsChar: 'b', type: 'base32' };
-
-/**
- * @name base32Validate
- * @summary Validates a base32 value.
- * @description
- * Validates that the supplied value is valid base32
- */
-export function base32Validate (value?: string | null, ipfsCompat?: boolean): value is string {
-  return validateChars(BASE_CONFIG, value, ipfsCompat);
-}

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

@@ -1,9 +1,43 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import baseX from 'base-x';
+import { base58 } from 'micro-base';
 
-// https://github.com/cryptocoinjs/base-x#alphabets
-export const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';
 
-export const bs58 = baseX(BASE58_ALPHABET);
+const config = {
+  chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
+  coder: base58,
+  ipfs: 'z',
+  type: 'base58'
+};
+
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates that the supplied value is valid base58, throwing exceptions if not
+ */
+export const base58Validate = createValidate(config);
+
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * From the provided input, decode the base58 and return the result as an `Uint8Array`.
+ */
+export const base58Decode = createDecode(config, base58Validate);
+
+/**
+* @name base58Encode
+* @summary Creates a base58 value.
+* @description
+* From the provided input, create the base58 and return the result as a string.
+*/
+export const base58Encode = createEncode(config);
+
+/**
+* @name isBase58
+* @description Checks if the input is in base58, returning true/false
+*/
+export const isBase58 = createIs(base58Validate);

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

@@ -0,0 +1,23 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base32Decode } from '../base32';
+import { base58Decode } from './';
+
+describe('base58Encode', (): void => {
+  it('encodes a base58 to a base32', (): void => {
+    expect(
+      base58Decode('b2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV')
+    ).toEqual(
+      base32Decode('afkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy')
+    );
+  });
+
+  it('encodes a base58 to a base32 (ipfs-compat)', (): void => {
+    expect(
+      base58Decode('zb2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV', true)
+    ).toEqual(
+      base32Decode('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+    );
+  });
+});

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

@@ -1,19 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { bufferToU8a } from '@polkadot/util';
-
-import { bs58 } from './bs58';
-import { base58Validate } from './validate';
-
-/**
- * @name base58Decode
- * @summary Decodes a base58 value.
- * @description
- * From the provided input, decode the base58 and return the result as an `Uint8Array`.
- */
-export function base58Decode (value: string, ipfsCompat?: boolean): Uint8Array {
-  base58Validate(value, ipfsCompat);
-
-  return bufferToU8a(bs58.decode(value.substr(ipfsCompat ? 1 : 0)));
-}

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

@@ -5,7 +5,15 @@ import { base32Decode } from '../base32';
 import { base58Encode } from './';
 
 describe('base58Encode', (): void => {
-  it('encodes a base32 to a base38', (): void => {
+  it('encodes a base32 to a base58', (): void => {
+    expect(
+      base58Encode(
+        base32Decode('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+      )
+    ).toEqual('b2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV');
+  });
+
+  it('encodes a base32 to a base58 (ipfs-compat)', (): void => {
     expect(
       base58Encode(
         base32Decode('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true),

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

@@ -1,20 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aToU8a } from '@polkadot/util';
-
-import { bs58 } from './bs58';
-
-/**
- * @name base58Encode
- * @summary Creates a base58 value.
- * @description
- * 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(u8aToU8a(value));
-
-  return ipfsCompat
-    ? `z${out}`
-    : out;
-}

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

@@ -5,7 +5,4 @@
  * @summary Encode and decode base58 values
  */
 
-export { base58Decode } from './decode';
-export { base58Encode } from './encode';
-export { base58Validate } from './validate';
-export { isBase58 } from './is';
+export { base58Decode, base58Encode, base58Validate, isBase58 } from './bs58';

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

@@ -1,9 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { testValidator } from '../base32/is';
-import { base58Validate } from './validate';
-
-export function isBase58 (value?: string | null, ipfsCompat?: boolean): value is string {
-  return testValidator(base58Validate, value, ipfsCompat);
-}

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

@@ -1,35 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { assert } from '@polkadot/util';
-
-import { BASE58_ALPHABET } from './bs58';
-
-interface CheckConfig {
-  alphabet: string;
-  ipfsChar: string;
-  type: string;
-}
-
-const BASE_CONFIG = { alphabet: BASE58_ALPHABET, ipfsChar: 'z', type: 'base58' };
-
-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}`);
-  }
-
-  return true;
-}
-
-/**
- * @name base58Validate
- * @summary Validates a base58 value.
- * @description
- * Validates that the supplied value is valid base58
- */
-export function base58Validate (value?: string | null, ipfsCompat?: boolean): value is string {
-  return validateChars(BASE_CONFIG, value, ipfsCompat);
-}

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

@@ -0,0 +1,42 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64 } from 'micro-base';
+
+import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers';
+
+const config = {
+  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  coder: base64,
+  type: 'base64'
+};
+
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates that the supplied value is valid base64
+ */
+export const base64Validate = createValidate(config);
+
+/**
+ * @name isBase64
+ * @description Checks if the input is in base64, returning true/false
+ */
+export const isBase64 = createIs(base64Validate);
+
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+export const base64Decode = createDecode(config, base64Validate);
+
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+export const base64Encode = createEncode(config);

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

@@ -6,11 +6,27 @@ import { stringToU8a } from '@polkadot/util';
 import { base64Decode } from '.';
 
 describe('base64Decode', (): void => {
-  it('decodes a mixed base64 utf8 string', (): void => {
+  it('decodes a mixed base64 utf8 string (1)', (): void => {
     expect(
       base64Decode('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
     ).toEqual(
       stringToU8a('hello world Приветствую ми 你好')
     );
   });
+
+  it('decodes a mixed base64 utf8 string (2)', (): void => {
+    expect(
+      base64Decode('4pyTIMOgIGxhIG1vZGU=')
+    ).toEqual(
+      stringToU8a('✓ à la mode')
+    );
+  });
+
+  it('decodes a mixed base64 utf8 string (3)', (): void => {
+    expect(
+      base64Decode('SGVsbG8gV29ybGQh')
+    ).toEqual(
+      stringToU8a('Hello World!')
+    );
+  });
 });

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

@@ -1,18 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import base64 from 'base64-js';
-
-import { base64Validate } from './validate';
-
-/**
- * @name base64Decode
- * @summary Decodes a base64 value.
- * @description
- * From the provided input, decode the base64 and return the result as an `Uint8Array`.
- */
-export function base64Decode (value: string): Uint8Array {
-  base64Validate(value);
-
-  return base64.toByteArray(value);
-}

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

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

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

@@ -5,9 +5,6 @@
  * @summary Encode and decode base64 values
  */
 
-export { base64Decode } from './decode';
-export { base64Encode } from './encode';
+export { base64Decode, base64Encode, base64Validate, isBase64 } from './bs64';
 export { base64Pad } from './pad';
 export { base64Trim } from './trim';
-export { base64Validate } from './validate';
-export { isBase64 } from './is';

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

@@ -1,12 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { base64Validate } from './validate';
-
-export function isBase64 (value?: string | null): value is string {
-  try {
-    return base64Validate(value);
-  } catch (error) {
-    return false;
-  }
-}

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

@@ -1,6 +1,10 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+/**
+ * @name base64Pad
+ * @description Adds padding characters for correct length
+ */
 export function base64Pad (value: string): string {
   return value.padEnd(value.length + (value.length % 4), '=');
 }

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

@@ -1,6 +1,10 @@
 // Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+/**
+ * @name base64Trim
+ * @description Trims padding characters
+ */
 export function base64Trim (value: string): string {
   while (value.length && value[value.length - 1] === '=') {
     value = value.slice(0, -1);

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

@@ -7,6 +7,6 @@ describe('base64Validate', (): void => {
   it('validates a mixed base64 utf8 string', (): void => {
     expect(
       () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
-    ).toThrow(/Invalid base64 encoding/);
+    ).toThrow(/Invalid base64 character "\^" \(0x5e\) at index 30/);
   });
 });

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

@@ -1,17 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { assert } from '@polkadot/util';
-
-/**
- * @name base64Validate
- * @summary Validates a base64 value.
- * @description
- * Validates that the supplied value is valid base64
- */
-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.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aToHex } from '@polkadot/util';
-
-import { blake2AsU8a } from './asU8a';
-
-/**
- * @name blake2AsHex
- * @summary Creates a blake2b hex from the input.
- * @description
- * From a `Uint8Array` input, create the blake2b and return the result as a hex string with the specified `bitLength`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { blake2AsHex } from '@polkadot/util-crypto';
- *
- * blake2AsHex('abc'); // => 0xba80a53f981c4d0d
- * ```
- */
-export function blake2AsHex (data: Uint8Array | string, bitLength = 256, key?: Uint8Array | null, onlyJs = false): string {
-  return u8aToHex(
-    blake2AsU8a(data, bitLength, key, onlyJs)
-  );
-}

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

@@ -4,6 +4,7 @@
 import { hexToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';
 
+import { performanceWasm } from '../test/performance';
 import { blake2AsU8a } from '.';
 
 describe('blake2AsU8a', (): void => {
@@ -58,4 +59,10 @@ describe('blake2AsU8a', (): void => {
 
     expect(a).toEqual(b);
   });
+
+  describe.each([256, 512] as (256 | 512)[])('bitLength=$p', (bitLength): void => {
+    performanceWasm(`blake2AsU8a, bitLength=${bitLength}`, 64000, (input, onlyJs) =>
+      blake2AsU8a(input, bitLength, null, onlyJs)
+    );
+  });
 });