[CI Skip] release/stable 5.5.1

skip-checks: true

.123trigger

@@ -1,2 +1,9 @@
-5
-2.6.22.12.2
+6
+2.6.2
+2.12.2
+5.2.2
+5.2.3
+
+5.4.2
+5.4.3
+5.4.4

.codeclimate.yml

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

.eslintrc.js

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util authors & contributors
+// Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const base = require('@polkadot/dev/config/eslint');
+const base = require('@polkadot/dev/config/eslint.cjs');
 
 module.exports = {
   ...base,

.github/ss58-check.md

@@ -1,10 +1,9 @@
 ---
-assignees: ['jacogr']
 title: SS58 registry is outdated
 labels: ['ci', '@networks']
 ---
 
-cc @jacogr
+cc @polkadot-js/notifications
 
 Discrepancies detected between https://github.com/paritytech/substrate/blob/master/ss58-registry.json and https://github.com/polkadot-js/common/blob/master/packages/networks/src/index.ts
 

.github/workflows/pr-any.yml

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

.github/workflows/ss58-check.yml

@@ -19,6 +19,6 @@ jobs:
       if: ${{ failure() }}
       uses: JasonEtco/create-an-issue@v2
       env:
-        GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+        GITHUB_TOKEN: ${{ secrets.GH_PAT_BOT }}
       with:
         filename: .github/ss58-check.md

.yarnrc.yml

@@ -9,7 +9,5 @@ plugins:
     spec: "@yarnpkg/plugin-interactive-tools"
   - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
     spec: "@yarnpkg/plugin-version"
-  - path: .yarn/plugins/@yarnpkg/plugin-workspace-tools.cjs
-    spec: "@yarnpkg/plugin-workspace-tools"
 
-yarnPath: .yarn/releases/yarn-2.3.3.cjs
+yarnPath: .yarn/releases/yarn-2.4.0.cjs

CHANGELOG.md

@@ -1,5 +1,121 @@
 # CHANGELOG
 
+## 5.5.1 Jan 31, 2021
+
+Changes:
+
+- Added `hdLedger` to util-crypto for Ledger-compatible bip32+ed25519 derivation
+- Added `hmac{Sha256, 512}` to util-crypto
+- Add `slip44` indices for Ledger into `@polkadot/networks`
+- Remove `module` entry in `package.json` (only rely on exports map)
+- Remove direct references to `global` object, use `@polkadot/x-global`
+- Update `@ledgerhq` dependencies to latest
+
+
+## 5.4.1 Jan 24, 2021
+
+Contributed:
+
+- Adjust Ledger app lookup for Polymesh (Thanks to https://github.com/adamdossa)
+
+Changes:
+
+- Allow decimals as `number[]` & symbol as `string[]` in balanceFormat defaults
+- Add `schnorrkelVrf{Sign, Verify}` to `@polkadot/util-crypto`
+- Export `vrf{Sign, Verify}` on keyring interface
+- Move `@polkadot/x-rxjs` packages from the api repo
+- Align `@polkadot/networks` with Substrate master
+- Explicit edcsa tests for derivation
+- `@polkadot/wasm-crypto` 3.2.1
+
+
+## 5.3.1 Jan 17, 2021
+
+**Important** For users of the `@polkadot/ledger` package, it is now included in this repo (since it is a general utility) and renamed to `@polkadot/hw-ledger`
+
+Contributed:
+
+- Add Dock Ledger integration (Thanks to https://github.com/lovesh)
+- Add Polymesh Ledger integration (Thanks to https://github.com/adamdossa)
+- Add flag for Ledger capabilities on networks (Thanks to https://github.com/Tbaut)
+
+Changes:
+
+- Move `@polkadot/ledger` packages into common
+- Update `@polkadot/networks` to align with latest Substrate ss58-registry
+
+
+## 5.2.1 Dec 27, 2020
+
+Changes:
+
+- Add `arrayFlatten` to merge a series of arrays into a single
+- Add `arrayChunk` to chunk an array into multiples of defined size
+- Add `bitLength` param (allowed 256, 512) to `keccakAs{Hex, U8a}`
+- Align `@polkadot/networks` with Substrate master
+
+
+## 5.1.1 Dec 19, 2020
+
+Changes:
+
+- `detectPackage` now can take a path-retrieval callback as second argument
+- Adjust `blake2js` imports to consistently cater for esm & cjs usage
+- Explicitly mark `detectPackage` usage as having side-effects
+- Align `@polkadot/networks` with Substrate master
+- `@polkadot/wasm-crypto` 3.1.1
+
+
+## 5.0.1 Dec 13, 2020
+
+**Important** While this package contains no external interface changes, it now compiles and ships both cjs and esm modules. This means that modern bundlers will have more information for tree-shaking available. Additionally when using Node with `.mjs` extensions, the esm version imports will be used on recent Node versions. Adding an export map, as here, may have some impacts so a major semver bump is advised. There may be (small) dragons hiding in the dark corners...
+
+Changes:
+
+- Build and expose both cjs and esm via exports map
+- Use `import type { ... }` form for all type imports
+- Align with Substrate master network list
+- Debug logs now don't depend on `NODE_ENV`, but rather `DEBUG=<type,type,...>` (`*` logs all)
+- Limit debug console output via `DEBUG_MAX=<number>` value, trimming when passed
+- Add `memoize` util, allowing for function memoization (as used in the API)
+- Align `@polkadot/networks` with Substrate master
+- `@polkadot/wasm-crypto` 3.0.1
+
+
+## 4.2.1 Nov 23, 2020
+
+Changes:
+
+- Rename default Mega to Million, Giga to Billion and Tera to Trillion in formatter
+- Dedupe bn.js by aligning versions between different libraries
+- Add explicit link to base Substrate ss58 formats (as managed in `@polkadot/util`)
+
+
+## 4.1.1 Nov 16, 2020
+
+Contributed:
+
+- Expand ETH tests, allow for verification against address (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Replace pbkdf2 imports with explicit use from sync-only package
+- Adjust secp256k1 imports with shared elliptic
+- Expand crypto tests for explicit wasm vs JS compares in all cases
+
+
+## 4.0.1 Nov 8, 2020
+
+- **Breaking change** Polyfills are not injected by these libraries anymore to avoid clobbering external globals, the user should provide them if their environment is missing base functionality.
+
+Changes:
+
+- Remove built-in utility polyfills for `Array.fill`, `String.padStart`, `String.padEnd` as well as `Object.setPrototypeOf`. These should be provided by the actual user of the libraries if so required.
+- Update `@polkadot/wasm-crypto` library (under-the-hood cleanups)
+- Remove explicit crypto polyfill injection (aligning with updated `@polkadot/wasm-crypto`)
+- Add cross-environment `@polkadot/x-randomvalues` (for use in `@polkadot/wasm-crypto`)
+
+
 ## 3.7.1 Nov 1, 2020
 
 Changes:

babel.config.js

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

jest.config.js

@@ -1,26 +1,36 @@
-// Copyright 2017-2020 @polkadot/util authors & contributors
+// Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const config = require('@polkadot/dev/config/jest');
+const config = require('@polkadot/dev/config/jest.cjs');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
+    '@polkadot/hw-ledger-transports(.*)$': '<rootDir>/packages/hw-ledger-transports/src/node',
+    // eslint-disable-next-line sort-keys
+    '@polkadot/hw-ledger(.*)$': '<rootDir>/packages/hw-ledger/src/$1',
     '@polkadot/keyring(.*)$': '<rootDir>/packages/keyring/src/$1',
     '@polkadot/networks(.*)$': '<rootDir>/packages/networks/src/$1',
     '@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|textdecoder|textencoder|ws)(.*)$': '<rootDir>/packages/x-$1/src/node'
+    '@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'
   ],
-  resolver: '@polkadot/dev/config/jest-resolver'
+  resolver: '@polkadot/dev/config/jest-resolver.cjs'
 });

package.json

@@ -7,8 +7,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "babel-core": "^7.0.0-bridge.0",
-    "typescript": "^4.0.5"
+    "typescript": "^4.1.3"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
@@ -21,10 +20,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.3",
-    "@polkadot/dev": "^0.59.12",
-    "@polkadot/ts": "^0.3.53",
-    "@types/jest": "^26.0.15"
+    "@babel/core": "^7.12.10",
+    "@polkadot/dev": "^0.61.24",
+    "@polkadot/ts": "^0.3.59",
+    "@types/jest": "^26.0.20"
   },
-  "version": "3.7.1"
+  "version": "5.5.1"
 }

packages/hw-ledger-transports/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

packages/hw-ledger-transports/README.md

@@ -0,0 +1,2 @@
+# @polkadot/hw-ledger-transports
+

packages/hw-ledger-transports/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@polkadot/hw-ledger-transports",
+  "version": "5.5.1",
+  "repository": "github:polkadot-js/common",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "maintainers": [],
+  "contributors": [],
+  "license": "Apache-2.0",
+  "main": "node.js",
+  "browser": "browser.js",
+  "react-native": "react-native.js",
+  "sideEffects": false,
+  "dependencies": {
+    "@babel/runtime": "^7.12.5",
+    "@ledgerhq/hw-transport-webusb": "^5.41.0"
+  },
+  "devDependencies": {
+    "@types/ledgerhq__hw-transport-node-hid": "^4.22.2",
+    "@types/ledgerhq__hw-transport-webusb": "^4.70.1"
+  },
+  "optionalDependencies": {
+    "@ledgerhq/hw-transport-node-hid-singleton": "^5.41.0"
+  }
+}

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

@@ -0,0 +1,24 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type Transport from '@ledgerhq/hw-transport';
+import type { TransportDef } from './types';
+
+import LedgerWebUSB from '@ledgerhq/hw-transport-webusb';
+
+const transports: TransportDef[] = [
+  // deprecated
+  // import LedgerU2F from '@ledgerhq/hw-transport-u2f';
+  // {
+  //   create: (): Promise<Transport> =>
+  //     LedgerU2F.create(),
+  //   type: 'u2f'
+  // },
+  {
+    create: (): Promise<Transport> =>
+      LedgerWebUSB.create(),
+    type: 'webusb'
+  }
+];
+
+export { transports };

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

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

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

@@ -0,0 +1,17 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type Transport from '@ledgerhq/hw-transport';
+import type { TransportDef } from './types';
+
+import LedgerHid from '@ledgerhq/hw-transport-node-hid-singleton';
+
+const transports: TransportDef[] = [
+  {
+    create: (): Promise<Transport> =>
+      LedgerHid.create(),
+    type: 'hid'
+  }
+];
+
+export { transports };

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

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

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

@@ -0,0 +1,11 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Transport from '@ledgerhq/hw-transport';
+
+export type LedgerTypes = 'hid' | 'u2f' | 'webusb';
+
+export interface TransportDef {
+  create (): Promise<Transport>;
+  type: LedgerTypes;
+}

packages/hw-ledger/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

packages/hw-ledger/README.md

@@ -0,0 +1,2 @@
+# @polkadot/hw-ledger
+

packages/hw-ledger/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@polkadot/hw-ledger",
+  "version": "5.5.1",
+  "repository": "github:polkadot-js/common",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "maintainers": [],
+  "contributors": [],
+  "license": "Apache-2.0",
+  "main": "index.js",
+  "sideEffects": false,
+  "dependencies": {
+    "@babel/runtime": "^7.12.5",
+    "@polkadot/hw-ledger-transports": "5.5.1",
+    "@polkadot/util": "^5.5.1",
+    "@zondax/ledger-polkadot": "^0.13.0"
+  }
+}

packages/hw-ledger/src/index.ts

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

packages/hw-ledger/src/types.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export type LedgerTypes = 'hid' | 'u2f' | 'webusb';
+
+export interface AccountOptions {
+  account: number;
+  addressIndex: number;
+  change: number;
+}
+
+export interface LedgerAddress {
+  address: string;
+  publicKey: string;
+}
+
+export interface LedgerSignature {
+  signature: string;
+}
+
+export interface LedgerVersion {
+  isLocked: boolean;
+  isTestMode: boolean;
+  version: [number, number, number];
+}

packages/keyring/package.json

@@ -1,34 +1,26 @@
 {
   "name": "@polkadot/keyring",
-  "version": "3.7.1",
+  "version": "5.5.1",
   "description": "Keyring management",
-  "main": "index.js",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/common.git"
-  },
-  "keywords": [
-    "Polkadot",
-    "Keyring",
-    "ed25519"
-  ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
+  "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/polkadot-js/common/issues"
-  },
+  "main": "index.js",
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.mjs"
+  ],
+  "repository": "github:polkadot-js/common",
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
-    "@polkadot/util": "^3.7.1",
-    "@polkadot/util-crypto": "^3.7.1"
+    "@babel/runtime": "^7.12.5",
+    "@polkadot/util": "5.5.1",
+    "@polkadot/util-crypto": "5.5.1"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "5.5.1",
+    "@polkadot/util-crypto": "5.5.1"
   }
 }

packages/keyring/src/defaults.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // default substrate dev phrase

packages/keyring/src/detectPackage.ts

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

packages/keyring/src/index.spec.ts

@@ -1,8 +1,8 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { hexToU8a, stringToU8a } from '@polkadot/util';
-import { cryptoWaitReady, setSS58Format, encodeAddress } from '@polkadot/util-crypto';
+import { cryptoWaitReady, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
 
 import Keyring from '.';
 

packages/keyring/src/index.ts

@@ -1,19 +1,12 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { detectPackage } from '@polkadot/util';
-import { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+import './detectPackage';
 
-import Keyring from './keyring';
+import { Keyring } from './keyring';
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-detectPackage(require('./package.json'), typeof __dirname !== 'undefined' && __dirname);
+export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
 
 export default Keyring;
 
-export {
-  Keyring,
-  decodeAddress,
-  encodeAddress,
-  setSS58Format
-};
+export { Keyring };

packages/keyring/src/keyring.ts

@@ -1,15 +1,15 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeypairType, Keypair } from '@polkadot/util-crypto/types';
-import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, KeyringOptions } from './types';
+import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
+import type { KeyringInstance, KeyringOptions, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from './types';
 
 import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
-import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToLegacySeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
+import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, mnemonicToLegacySeed, mnemonicToMiniSecret, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
-import createPair from './pair';
-import Pairs from './pairs';
+import { createPair } from './pair';
+import { Pairs } from './pairs';
 
 const keypairFromSeed = {
   ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
@@ -34,7 +34,7 @@ const keypairFromSeed = {
  * lookup of a pair for a given account address or public key using `getPair`. JSON metadata associated with
  * an account may be obtained using `toJson` accompanied by the account passphrase.
  */
-export default class Keyring implements KeyringInstance {
+export class Keyring implements KeyringInstance {
   readonly #pairs: Pairs;
 
   readonly #type: KeypairType;

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

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import testingPairs from '../testingPairs';
+import { createTestPairs } from '../testingPairs';
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('decode', (): void => {
   it('fails when no data provided', (): void => {

packages/keyring/src/pair/decode.ts

@@ -1,13 +1,13 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringPair$JsonEncodingTypes } from '../types';
-import { PairInfo } from './types';
+import type { KeyringPair$JsonEncodingTypes } from '../types';
+import type { PairInfo } from './types';
 
 import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
 import { naclDecrypt, scryptEncode, scryptFromU8a } from '@polkadot/util-crypto';
 
-import { ENCODING, NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH, SCRYPT_LENGTH } from './defaults';
+import { ENCODING, NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
 
 const SEED_OFFSET = PKCS8_HEADER.length;
 
@@ -42,7 +42,7 @@ function decodePkcs8 (encoded: Uint8Array): DecodeResult {
   };
 }
 
-export default function decode (passphrase?: string, encrypted?: Uint8Array | null, encType: KeyringPair$JsonEncodingTypes[] = ENCODING): DecodeResult {
+export function decodePair (passphrase?: string, encrypted?: Uint8Array | null, encType: KeyringPair$JsonEncodingTypes[] = ENCODING): DecodeResult {
   assert(encrypted, 'No encrypted data available to decode');
   assert(passphrase || !encType.includes('xsalsa20-poly1305'), 'Password required to decode encypted data');
 

packages/keyring/src/pair/defaults.ts

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringPair$JsonEncodingTypes } from '../types';
+import type { KeyringPair$JsonEncodingTypes } from '../types';
 
 const ENCODING: KeyringPair$JsonEncodingTypes[] = ['scrypt', 'xsalsa20-poly1305'];
 const NONCE_LENGTH = 24;

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

@@ -1,13 +1,13 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import testingPairs from '../testingPairs';
-import { PKCS8_DIVIDER, PKCS8_HEADER, NONCE_LENGTH, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH } from './defaults';
+import { createTestPairs } from '../testingPairs';
+import { NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH } from './defaults';
 
 const PKCS8_LENGTH = PKCS8_DIVIDER.length + PKCS8_HEADER.length + PUB_LENGTH + SEC_LENGTH;
 const ENCODED_LENGTH = 16 + PKCS8_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('encode', (): void => {
   it('returns PKCS8 when no passphrase supplied', (): void => {

packages/keyring/src/pair/encode.ts

@@ -1,14 +1,14 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { PairInfo } from './types';
+import type { PairInfo } from './types';
 
-import { u8aConcat, assert } from '@polkadot/util';
+import { assert, u8aConcat } from '@polkadot/util';
 import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';
 
 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';
 
-export default function encode ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
+export function encodePair ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
   assert(secretKey, 'Expected a valid secretKey to be passed to encode');
 
   const encoded = u8aConcat(

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

@@ -1,15 +1,14 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { hexToU8a } from '@polkadot/util';
 import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';
 
-import { hexToU8a } from '@polkadot/util';
-
 import { PAIRS } from '../testing';
-import testingPairs from '../testingPairs';
-import createPair from '.';
+import { createTestPairs } from '../testingPairs';
+import { createPair } from '.';
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('pair', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -57,6 +56,17 @@ describe('pair', (): void => {
     ).toEqual(false);
   });
 
+  it('allows vrf sign and verify', (): void => {
+    const message = new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]);
+
+    expect(
+      keyring.alice.vrfVerify(
+        message,
+        keyring.alice.vrfSign(message)
+      )
+    ).toBe(true);
+  });
+
   it('allows setting/getting of meta', (): void => {
     keyring.bob.setMeta({ foo: 'bar', something: 'else' });
 

packages/keyring/src/pair/index.ts

@@ -1,16 +1,16 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
-import { PairInfo } from './types';
+import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
+import type { PairInfo } from './types';
 
-import { assert, u8aConcat, u8aToHex } from '@polkadot/util';
-import { blake2AsU8a, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, secp256k1Compress, signatureVerify } from '@polkadot/util-crypto';
+import { assert, u8aConcat, u8aEq, u8aToHex } from '@polkadot/util';
+import { blake2AsU8a, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVrfSign, schnorrkelVrfVerify, secp256k1Compress, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify } from '@polkadot/util-crypto';
 
-import decode from './decode';
-import encode from './encode';
-import toJson from './toJson';
+import { decodePair } from './decode';
+import { encodePair } from './encode';
+import { pairToJson } from './toJson';
 
 interface Setup {
   toSS58: (publicKey: Uint8Array) => string;
@@ -57,7 +57,7 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
 }
 
 /**
- * @name pair
+ * @name createPair
  * @summary Creates a keyring pair object
  * @description Creates a keyring pair object with provided account public key, metadata, and encoded arguments.
  * The keyring pair stores the account state including the encoded address and associated metadata.
@@ -87,9 +87,9 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
  * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
  * property that indicates whether the public key value of the `encoded` property is encoded or not.
  */
-export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
   const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
-    const decoded = decode(passphrase, userEncoded || encoded, encTypes);
+    const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
 
     if (decoded.secretKey.length === 64) {
       publicKey = decoded.publicKey;
@@ -105,7 +105,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
   const recode = (passphrase?: string): Uint8Array => {
     isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
 
-    encoded = encode({ publicKey, secretKey }, passphrase); // re-encode, latest version
+    encoded = encodePair({ publicKey, secretKey }, passphrase); // re-encode, latest version
     encTypes = undefined; // swap to defaults, latest version follows
 
     return encoded;
@@ -175,9 +175,30 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
         ? u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
-      return toJson(type, { address, meta }, recode(passphrase), !!passphrase);
+      return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
     },
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
-      signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey), type === 'ethereum').isValid
+      signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey)).isValid,
+    vrfSign: (message: Uint8Array, context?: 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);
+      }
+
+      const proof = TYPE_SIGNATURE[type](message, { publicKey, secretKey });
+
+      return u8aConcat(
+        blake2AsU8a(u8aConcat(context || '', extra || '', proof)),
+        proof
+      );
+    },
+    vrfVerify: (message: Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean =>
+      type === 'sr25519'
+        ? schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra)
+        : (
+          signatureVerify(message, vrfResult.subarray(32), TYPE_ADDRESS[type](publicKey)).isValid &&
+          u8aEq(vrfResult.subarray(0, 32), blake2AsU8a(u8aConcat(context || '', extra || '', vrfResult.subarray(32))))
+        )
   };
 }

packages/keyring/src/pair/nobody.ts

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';
 
 import { encodeAddress } from '@polkadot/util-crypto';
 
@@ -22,7 +22,7 @@ const json: KeyringPair$Json = {
   meta
 };
 
-export default function everybody (): KeyringPair {
+export function nobody (): KeyringPair {
   const pair: KeyringPair = {
     address,
     addressRaw: publicKey,
@@ -53,6 +53,12 @@ export default function everybody (): KeyringPair {
     type: 'ed25519',
     // 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
   };
 

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

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import testingPairs from '../testingPairs';
+import { createTestPairs } from '../testingPairs';
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('toJson', (): void => {
   it('creates an unencoded output with no passphrase', (): void => {

packages/keyring/src/pair/toJson.ts

@@ -1,8 +1,8 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeypairType } from '@polkadot/util-crypto/types';
-import { KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from '../types';
+import type { KeypairType } from '@polkadot/util-crypto/types';
+import type { KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from '../types';
 
 import { base64Encode } from '@polkadot/util-crypto';
 
@@ -19,7 +19,7 @@ const VERSION = '3';
 
 const ENC_NONE: KeyringPair$JsonEncodingTypes[] = ['none'];
 
-export default function toJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
+export function pairToJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
   return {
     address,
     encoded: base64Encode(encoded),

packages/keyring/src/pair/types.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 export interface PairInfo {

packages/keyring/src/pairs.ts

@@ -1,14 +1,14 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringPairs, KeyringPair } from './types';
+import type { KeyringPair, KeyringPairs } from './types';
 
 import { assert, isHex, isU8a, u8aToHex, u8aToU8a } from '@polkadot/util';
 import { decodeAddress } from '@polkadot/util-crypto';
 
 type KeyringPairMap = Record<string, KeyringPair>;
 
-export default class Pairs implements KeyringPairs {
+export class Pairs implements KeyringPairs {
   readonly #map: KeyringPairMap = {};
 
   public add (pair: KeyringPair): KeyringPair {

packages/keyring/src/suri.spec.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // From https://github.com/paritytech/substrate/wiki/Secret-URI-Test-Vectors
@@ -10,53 +10,62 @@ import Keyring from '.';
 
 const PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
 
-const TESTS = [
-  {
-    pk: '0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a',
-    ss: '5DfhGyQdFobKM8NsWvEeAKk5EQQgYe9AydgJ7rMB6E1EqRzV',
-    uri: PHRASE
-  },
-  {
-    pk: '0xb69355deefa7a8f33e9297f5af22e680f03597a99d4f4b1c44be47e7a2275802',
-    ss: '5GC6LfpV352HtJPySfAecb5JdePtf4R9Vq49NUU8RhzgBqgq',
-    uri: `${PHRASE}///password`
-  },
-  {
-    pk: '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a',
-    ss: '5DXZzrDxHbkQov4QBAY4TjpwnHCMrKXkomTnKSw8UArBEY5v',
-    uri: `${PHRASE}/foo`
-  },
-  {
-    pk: '0x547d4a55642ec7ebadc0bd29b6e570b8c926059b3c0655d4948075e9a7e6f31e',
-    ss: '5DyV6fZuvPemWrUqBgWwTSgoV86w6xms3KhkFU6cQcWxU8eP',
-    uri: `${PHRASE}//foo`
-  },
-  {
-    pk: '0x3841947ffcde6f5fef26fb68b59bb8665637e30e32ec2051f99cf6b9c674fe09',
-    ss: '5DLU27is5iViNopQb2KxsTyPx6j4vCu8X3sk3j3NNLkPCqKM',
-    uri: `${PHRASE}//foo/bar`
-  },
-  {
-    pk: '0xdc142f7476a7b0aa262aeccf207f1d18daa90762db393006741e8a31f39dbc53',
-    ss: '5H3GPTqDSpjkfDwbHy12PD6BWm8jvGSX4xYC8UMprHpTPcRg',
-    uri: `${PHRASE}/foo//bar`
-  },
-  {
-    pk: '0xa2e56b06407a6d1e819d2fc33fa0ec604b29c2e868b70b3696bb049b8725934b',
-    ss: '5FkHmNgbg64MwStgCyDi2Uw3ufFu11mqQgmWT9uwK4Lghvpv',
-    uri: `${PHRASE}//foo/bar//42/69`
-  },
-  {
-    pk: '0x0e0d24e3e1ff2c07f269c99e2e0df8681fda1851ac42fc846ca2daaa90cd8f14',
-    ss: '5CP8S23JBNXYNpJsL7ESPJBNnUZE6itcfM4EnDxEhaVEU6dT',
-    uri: `${PHRASE}//foo/bar//42/69///password`
-  },
-  {
-    pk: '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d',
-    ss: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
-    uri: `${PHRASE}//Alice`
-  }
-];
+const TESTS = {
+  ecdsa: [
+    {
+      pk: '0x020a1091341fe5664bfa1782d5e04779689068c916b04cb365ec3153755684d9a1',
+      ss: '5C7C2Z5sWbytvHpuLTvzKunnnRwQxft1jiqrLD5rhucQ5S9X',
+      uri: `${PHRASE}//Alice`
+    }
+  ],
+  sr25519: [
+    {
+      pk: '0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a',
+      ss: '5DfhGyQdFobKM8NsWvEeAKk5EQQgYe9AydgJ7rMB6E1EqRzV',
+      uri: PHRASE
+    },
+    {
+      pk: '0xb69355deefa7a8f33e9297f5af22e680f03597a99d4f4b1c44be47e7a2275802',
+      ss: '5GC6LfpV352HtJPySfAecb5JdePtf4R9Vq49NUU8RhzgBqgq',
+      uri: `${PHRASE}///password`
+    },
+    {
+      pk: '0x40b9675df90efa6069ff623b0fdfcf706cd47ca7452a5056c7ad58194d23440a',
+      ss: '5DXZzrDxHbkQov4QBAY4TjpwnHCMrKXkomTnKSw8UArBEY5v',
+      uri: `${PHRASE}/foo`
+    },
+    {
+      pk: '0x547d4a55642ec7ebadc0bd29b6e570b8c926059b3c0655d4948075e9a7e6f31e',
+      ss: '5DyV6fZuvPemWrUqBgWwTSgoV86w6xms3KhkFU6cQcWxU8eP',
+      uri: `${PHRASE}//foo`
+    },
+    {
+      pk: '0x3841947ffcde6f5fef26fb68b59bb8665637e30e32ec2051f99cf6b9c674fe09',
+      ss: '5DLU27is5iViNopQb2KxsTyPx6j4vCu8X3sk3j3NNLkPCqKM',
+      uri: `${PHRASE}//foo/bar`
+    },
+    {
+      pk: '0xdc142f7476a7b0aa262aeccf207f1d18daa90762db393006741e8a31f39dbc53',
+      ss: '5H3GPTqDSpjkfDwbHy12PD6BWm8jvGSX4xYC8UMprHpTPcRg',
+      uri: `${PHRASE}/foo//bar`
+    },
+    {
+      pk: '0xa2e56b06407a6d1e819d2fc33fa0ec604b29c2e868b70b3696bb049b8725934b',
+      ss: '5FkHmNgbg64MwStgCyDi2Uw3ufFu11mqQgmWT9uwK4Lghvpv',
+      uri: `${PHRASE}//foo/bar//42/69`
+    },
+    {
+      pk: '0x0e0d24e3e1ff2c07f269c99e2e0df8681fda1851ac42fc846ca2daaa90cd8f14',
+      ss: '5CP8S23JBNXYNpJsL7ESPJBNnUZE6itcfM4EnDxEhaVEU6dT',
+      uri: `${PHRASE}//foo/bar//42/69///password`
+    },
+    {
+      pk: '0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d',
+      ss: '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+      uri: `${PHRASE}//Alice`
+    }
+  ]
+};
 
 describe('keyring.addFromUri', (): void => {
   const keyring = new Keyring({ type: 'sr25519' });
@@ -65,12 +74,16 @@ describe('keyring.addFromUri', (): void => {
     await cryptoWaitReady();
   });
 
-  TESTS.forEach(({ pk, ss, uri }): void => {
-    it(`creates ${uri}`, (): void => {
-      const pair = keyring.addFromUri(uri);
+  Object.entries(TESTS).forEach(([type, tests]): void => {
+    describe(type, (): void => {
+      tests.forEach(({ pk, ss, uri }): void => {
+        it(`creates ${uri}`, (): void => {
+          const pair = keyring.addFromUri(uri, {}, type as 'sr25519');
 
-      expect(u8aToHex(pair.publicKey)).toEqual(pk);
-      expect(pair.address).toEqual(ss);
+          expect(u8aToHex(pair.publicKey)).toEqual(pk);
+          expect(pair.address).toEqual(ss);
+        });
+      });
     });
   });
 });

packages/keyring/src/testing.ts

@@ -1,11 +1,11 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringInstance, KeyringOptions } from './types';
+import type { KeyringInstance, KeyringOptions } from './types';
 
 import { hexToU8a } from '@polkadot/util';
 
-import createPair from './pair';
+import { createPair } from './pair';
 import Keyring from '.';
 
 interface PairDef {
@@ -67,9 +67,9 @@ export const PAIRS: PairDef[] = [
  * @name testKeyring
  * @summary Create an instance of Keyring pre-populated with locked test accounts
  * @description The test accounts (i.e. alice, bob, dave, eve, ferdie)
- * are available on the dev chain and each test account is initialised with DOT funds.
+ * are available on the dev chain and each test account is initialized with DOT funds.
  */
-export default function testKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
+export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
 
   PAIRS.forEach(({ name, publicKey, secretKey, seed, type = 'sr25519' }): void => {

packages/keyring/src/testingPairs.spec.ts

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 
-import testingPairs from './testingPairs';
+import { createTestPairs } from './testingPairs';
 
 describe('testingPairs', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -12,19 +12,19 @@ describe('testingPairs', (): void => {
 
   it('creates without failing', (): void => {
     expect(
-      Object.keys(testingPairs())
+      Object.keys(createTestPairs())
     ).toHaveLength(2 + 0 + 7); // stash, session, pairs
   });
 
   it('has the correct address for Alice (non-HDKD)', (): void => {
     expect(
-      testingPairs({ type: 'ed25519' }, false).alice.address
+      createTestPairs({ type: 'ed25519' }, false).alice.address
     ).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
   });
 
   it('has the correct address for Alice (HDKD)', (): void => {
     expect(
-      testingPairs({ type: 'ed25519' }).alice.address
+      createTestPairs({ type: 'ed25519' }).alice.address
     ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
   });
 });

packages/keyring/src/testingPairs.ts

@@ -1,17 +1,17 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { KeyringPair, KeyringOptions } from './types';
+import type { KeyringOptions, KeyringPair } from './types';
 
-import createKeyring from './testing';
-import nobody from './pair/nobody';
+import { nobody } from './pair/nobody';
+import { createTestKeyring } from './testing';
 
 export interface TestKeyringMap {
   [index: string]: KeyringPair;
 }
 
-export default function testKeyringPairs (options?: KeyringOptions, isDerived = true): TestKeyringMap {
-  const keyring = createKeyring(options, isDerived);
+export function createTestPairs (options?: KeyringOptions, isDerived = true): TestKeyringMap {
+  const keyring = createTestKeyring(options, isDerived);
   const pairs = keyring.getPairs();
   const map: TestKeyringMap = { nobody: nobody() };
 

packages/keyring/src/types.ts

@@ -1,8 +1,8 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from '@polkadot/util-crypto/address/types';
-import { KeypairType } from '@polkadot/util-crypto/types';
+import type { Prefix } from '@polkadot/util-crypto/address/types';
+import type { KeypairType } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
   ss58Format?: Prefix;
@@ -48,6 +48,8 @@ export interface KeyringPair {
   sign (message: Uint8Array, options?: SignOptions): Uint8Array;
   toJson (passphrase?: string): KeyringPair$Json;
   verify (message: Uint8Array, signature: Uint8Array): boolean;
+  vrfSign (message: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
+  vrfVerify (message: Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
 }
 
 export interface KeyringPairs {

packages/networks/package.json

@@ -1,35 +1,21 @@
 {
   "name": "@polkadot/networks",
-  "version": "3.7.1",
+  "version": "5.5.1",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "main": "index.js",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/common.git"
-  },
-  "keywords": [
-    "Polkadot",
-    "ss58"
-  ],
+  "sideEffects": false,
+  "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
+  "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
-  "bugs": {
-    "url": "https://github.com/polkadot-js/common/issues"
-  },
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1"
+    "@babel/runtime": "^7.12.5"
   },
   "devDependencies": {
-    "@polkadot/util": "^3.7.1",
-    "@polkadot/x-fetch": "^3.7.1"
+    "@polkadot/util": "5.5.1",
+    "@polkadot/x-fetch": "5.5.1"
   }
 }

packages/networks/src/crosscheck.spec.ts

@@ -1,10 +1,11 @@
-// Copyright 2017-2020 @polkadot/networks authors & contributors
+// Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Ss58Registry } from './types';
+import type { Ss58Registry } from './types';
 
 import fs from 'fs';
-import fetch from '@polkadot/x-fetch';
+
+import { fetch } from '@polkadot/x-fetch';
 
 import { all } from './';
 

packages/networks/src/index.spec.ts

@@ -1,10 +1,14 @@
-// Copyright 2017-2020 @polkadot/networks authors & contributors
+// Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import filtered from './';
+import filtered, { available } from '.';
 
 describe('filtered', (): void => {
   it('has the correct starting order', (): void => {
     expect(filtered.slice(0, 3).map(({ prefix }) => prefix)).toEqual([0, 2, 42]);
   });
+
+  it('has no ignored networks', (): void => {
+    expect(available.some(({ isIgnored }) => isIgnored)).toEqual(false);
+  });
 });

packages/networks/src/index.ts

@@ -1,7 +1,12 @@
-// Copyright 2017-2020 @polkadot/networks authors & contributors
+// Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Network, NetworkFromSubstrate } from './types';
+// This contains exactly the same information as available in (with some extensions)
+// https://raw.githubusercontent.com/paritytech/substrate/master/ss58-registry.json
+//
+// Once the above is published as a package, the duplication here can be removed
+
+import type { Network, NetworkFromSubstrate } from './types';
 
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
@@ -14,6 +19,7 @@ const UNSORTED = [0, 2, 42];
 const createReserved = (prefix: number, displayName = 'This prefix is reserved.'): NetworkFromSubstrate => ({
   decimals: null,
   displayName,
+  isIgnored: true,
   network: `reserved${prefix}`,
   prefix,
   standardAccount: null,
@@ -26,9 +32,11 @@ const all: NetworkFromSubstrate[] = [
     decimals: [10],
     displayName: 'Polkadot Relay Chain',
     genesisHash: ['0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'],
+    hasLedgerSupport: true,
     icon: 'polkadot',
     network: 'polkadot',
     prefix: 0,
+    slip44: 0x00000162,
     standardAccount: '*25519',
     symbols: ['DOT'],
     website: 'https://polkadot.network'
@@ -42,9 +50,11 @@ const all: NetworkFromSubstrate[] = [
       '0xe3777fa922cafbff200cadeaea1a76bd7898ad5b89f7848999058b50e715f636', // Kusama CC2
       '0x3fd7b9eb6a00376e5be61f01abb429ffb0b104be05eaff4d458da48fcd425baf' // Kusama CC1
     ],
+    hasLedgerSupport: true,
     icon: 'polkadot',
     network: 'kusama',
     prefix: 2,
+    slip44: 0x000001b2,
     standardAccount: '*25519',
     symbols: ['KSM'],
     website: 'https://kusama.network'
@@ -125,13 +135,16 @@ const all: NetworkFromSubstrate[] = [
     website: 'http://laminar.network/'
   },
   {
-    decimals: null,
-    displayName: 'Polymath',
-    network: 'polymath',
+    decimals: [6],
+    displayName: 'Polymesh',
+    genesisHash: ['0x12fddc9e2128b3fe571e4e5427addcb87fcaf08493867a68dd6ae44b406b39c7'],
+    hasLedgerSupport: true,
+    network: 'polymesh',
     prefix: 12,
+    slip44: 0x00000253,
     standardAccount: '*25519',
-    symbols: null,
-    website: null
+    symbols: ['POLYX'],
+    website: 'https://polymath.network/'
   },
   {
     decimals: null,
@@ -151,6 +164,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: ['XTX'],
     website: 'https://totemaccounting.com'
   },
+  {
+    decimals: [12],
+    displayName: 'Synesthesia',
+    network: 'synesthesia',
+    prefix: 15,
+    standardAccount: '*25519',
+    symbols: ['SYN'],
+    website: 'https://synesthesia.network/'
+  },
   {
     decimals: [12],
     displayName: 'Kulupu',
@@ -201,7 +223,7 @@ const all: NetworkFromSubstrate[] = [
   {
     decimals: [6],
     displayName: 'Dock Testnet',
-    genesisHash: ['0x3f0608444cf5d7eec977430483ffef31ff86dfa6bfc6d7114023ee80cc03ea3f'],
+    isIgnored: true, // testnet
     network: 'dock-testnet',
     prefix: 21,
     standardAccount: '*25519',
@@ -212,8 +234,10 @@ const all: NetworkFromSubstrate[] = [
     decimals: [6],
     displayName: 'Dock Mainnet',
     genesisHash: ['0xf73467c6544aa68df2ee546b135f955c46b90fa627e9b5d7935f41061bb8a5a9'],
+    hasLedgerSupport: true,
     network: 'dock-mainnet',
     prefix: 22,
+    slip44: 0x00000252,
     standardAccount: '*25519',
     symbols: ['DCK'],
     website: 'https://dock.io'
@@ -239,12 +263,32 @@ const all: NetworkFromSubstrate[] = [
   {
     decimals: [18],
     displayName: 'ZERO Alphaville',
+    isIgnored: true, // testnet
     network: 'zero-alphaville',
     prefix: 25,
     standardAccount: '*25519',
     symbols: ['PLAY'],
     website: 'https://zero.io'
   },
+  {
+    decimals: [10],
+    displayName: 'Jupiter',
+    isIgnored: true, // testnet
+    network: 'jupiter',
+    prefix: 26,
+    standardAccount: '*25519',
+    symbols: ['jDOT'],
+    website: 'https://jupiter.patract.io'
+  },
+  {
+    decimals: [10, 12],
+    displayName: 'Patract',
+    network: 'patract',
+    prefix: 27,
+    standardAccount: '*25519',
+    symbols: ['pDOT', 'pKSM'],
+    website: 'https://patract.network'
+  },
   {
     decimals: null,
     displayName: 'Subsocial',
@@ -256,22 +300,40 @@ const all: NetworkFromSubstrate[] = [
     website: null
   },
   {
-    decimals: null,
+    decimals: [18],
+    displayName: 'Dhiway CORD Network',
+    network: 'cord',
+    prefix: 29,
+    standardAccount: '*25519',
+    symbols: ['DCU'],
+    website: 'https://dhiway.com/'
+  },
+  {
+    decimals: [12],
     displayName: 'Phala Network',
     network: 'phala',
     prefix: 30,
     standardAccount: '*25519',
-    symbols: null,
-    website: null
+    symbols: ['PHA'],
+    website: 'https://phala.network'
   },
   {
-    decimals: null,
-    displayName: 'Robonomics Network',
+    decimals: [12],
+    displayName: 'Litentry Network',
+    network: 'litentry',
+    prefix: 31,
+    standardAccount: '*25519',
+    symbols: ['LIT'],
+    website: 'https://litentry.com/'
+  },
+  {
+    decimals: [9],
+    displayName: 'Robonomics',
     network: 'robonomics',
     prefix: 32,
     standardAccount: '*25519',
-    symbols: null,
-    website: null
+    symbols: ['XRT'],
+    website: 'https://robonomics.network'
   },
   {
     decimals: null,
@@ -282,6 +344,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: null,
     website: null
   },
+  {
+    decimals: [15],
+    displayName: 'Valiu Liquidity Network',
+    network: 'vln',
+    prefix: 35,
+    standardAccount: '*25519',
+    symbols: ['USDv'],
+    website: 'https://valiu.com/'
+  },
   {
     decimals: [18],
     displayName: 'Centrifuge Chain',
@@ -300,6 +371,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: ['NODL'],
     website: 'https://nodle.io/'
   },
+  {
+    decimals: [18],
+    displayName: 'KILT Chain',
+    network: 'kilt',
+    prefix: 38,
+    standardAccount: '*25519',
+    symbols: ['KILT'],
+    website: 'https://kilt.io/'
+  },
   {
     decimals: [18],
     displayName: 'MathChain mainnet',
@@ -312,12 +392,22 @@ const all: NetworkFromSubstrate[] = [
   {
     decimals: [18],
     displayName: 'MathChain testnet',
+    isIgnored: true, // testnet
     network: 'mathchain-testnet',
     prefix: 40,
     standardAccount: '*25519',
     symbols: ['MATH'],
     website: 'https://mathwallet.org'
   },
+  {
+    decimals: null,
+    displayName: 'Polimec Chain',
+    network: 'poli',
+    prefix: 41,
+    standardAccount: '*25519',
+    symbols: null,
+    website: 'https://polimec.io/'
+  },
   {
     decimals: null,
     displayName: 'Substrate',
@@ -337,17 +427,27 @@ const all: NetworkFromSubstrate[] = [
     symbols: ['PCX'],
     website: 'https://chainx.org/'
   },
+  {
+    decimals: [12, 12],
+    displayName: 'UniArts Network',
+    network: 'uniarts',
+    prefix: 45,
+    standardAccount: '*25519',
+    symbols: ['UART', 'UINK'],
+    website: 'https://uniarts.me'
+  },
   createReserved(46),
   createReserved(47),
   createReserved(48, 'All prefixes 48 and higher are reserved and cannot be allocated.')
 ];
 
 // The list of available/claimed prefixes
+//   - no testnets
 //   - we only include those where we have a standardAccount
 //   - when no icon has been specified, default to substrate
 //   - sort by name, however we keep 0, 2, 42 first in the list
 const available: Network[] = all
-  .filter((n) => n.standardAccount === '*25519')
+  .filter((n) => !n.isIgnored)
   .map((n) => ({ ...n, genesisHash: n.genesisHash || [], icon: n.icon || 'substrate' }))
   .sort((a, b) =>
     UNSORTED.includes(a.prefix) && UNSORTED.includes(b.prefix)

packages/networks/src/types.ts

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate';
@@ -9,7 +9,10 @@ export interface NetworkFromSubstrate {
   network: string;
   prefix: number;
   genesisHash?: string[] | null;
+  hasLedgerSupport?: boolean;
   icon?: Icon | null;
+  isIgnored?: boolean;
+  slip44?: number;
   standardAccount: '*25519' | null;
   symbols: string[] | null;
   website: string | null;

packages/util-crypto/package.json

@@ -1,41 +1,32 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "3.7.1",
+  "version": "5.5.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
-  "keywords": [
-    "Polkadot"
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.mjs"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
+  "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/common.git"
-  },
-  "bugs": {
-    "url": "https://github.com/polkadot-js/common/issues"
-  },
+  "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",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
-    "@polkadot/networks": "^3.7.1",
-    "@polkadot/util": "^3.7.1",
-    "@polkadot/wasm-crypto": "^1.4.1",
+    "@babel/runtime": "^7.12.5",
+    "@polkadot/networks": "5.5.1",
+    "@polkadot/util": "5.5.1",
+    "@polkadot/wasm-crypto": "^3.2.2",
+    "@polkadot/x-randomvalues": "5.5.1",
     "base-x": "^3.0.8",
     "blakejs": "^1.1.0",
-    "bn.js": "^5.1.3",
+    "bn.js": "^4.11.9",
     "create-hash": "^1.2.0",
     "elliptic": "^6.5.3",
+    "hash.js": "^1.1.7",
     "js-sha3": "^0.8.0",
-    "pbkdf2": "^3.1.1",
     "scryptsy": "^2.1.0",
     "tweetnacl": "^1.0.3",
     "xxhashjs": "^0.2.2"
@@ -44,8 +35,10 @@
     "@types/bn.js": "^4.11.6",
     "@types/create-hash": "^1.2.2",
     "@types/elliptic": "^6.4.12",
-    "@types/pbkdf2": "^3.1.0",
     "@types/scryptsy": "^2.0.0",
     "@types/xxhashjs": "^0.2.2"
+  },
+  "peerDependencies": {
+    "@polkadot/util": "5.5.1"
   }
 }

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

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { hexToU8a } from '@polkadot/util';
 
-import addressToEvm from './addressToEvm';
+import { addressToEvm } from './addressToEvm';
 
 describe('addressToEvm', (): void => {
   it('creates a valid known EVM address', (): void => {

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

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

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

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import checkAddress from './check';
+import { checkAddress } from '.';
 
 describe('checkAddress', (): void => {
   it('returns [true, null] for Kusama', (): void => {

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

@@ -1,11 +1,11 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './types';
+import type { Prefix } from './types';
 
-import base58Decode from '../base58/decode';
-import checkChecksum from './checkChecksum';
-import defaults from './defaults';
+import { base58Decode } from '../base58/decode';
+import { checkAddressChecksum } from './checksum';
+import { defaults } from './defaults';
 
 /**
  * @name checkAddress
@@ -13,7 +13,7 @@ import defaults from './defaults';
  * @description
  * From the provided input, validate that the address is a valid input.
  */
-export default function check (address: string, prefix: Prefix): [boolean, string | null] {
+export function checkAddress (address: string, prefix: Prefix): [boolean, string | null] {
   let decoded;
 
   try {
@@ -28,7 +28,7 @@ export default function check (address: string, prefix: Prefix): [boolean, strin
     return [false, 'Invalid decoded address length'];
   }
 
-  const [isValid] = checkChecksum(decoded);
+  const [isValid] = checkAddressChecksum(decoded);
 
   return [isValid, isValid ? null : 'Invalid decoded address checksum'];
 }

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

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import sshash from './sshash';
+import { sshash } from './sshash';
 
-export default function checkChecksum (decoded: Uint8Array): [boolean, number] {
+export function checkAddressChecksum (decoded: Uint8Array): [boolean, number] {
   const isPublicKey = [35, 36].includes(decoded.length);
 
   // non-publicKeys has 1 byte checksums, else default to 2

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

@@ -1,21 +1,21 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { stringToU8a, u8aToHex, hexToU8a } from '@polkadot/util';
+import { hexToU8a, stringToU8a, u8aToHex } from '@polkadot/util';
 
-import testingPairs, { TestKeyringMap } from '../../../keyring/src/testingPairs';
-import decode from './decode';
+import { createTestPairs, TestKeyringMap } from '../../../keyring/src/testingPairs';
+import { decodeAddress } from '.';
 
 describe('decodeAddress', (): void => {
   let keyring: TestKeyringMap;
 
   beforeAll((): void => {
-    keyring = testingPairs({ type: 'sr25519' });
+    keyring = createTestPairs({ type: 'sr25519' });
   });
 
   it('decodes an address', (): void => {
     expect(
-      decode('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
+      decodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY')
     ).toEqual(
       keyring.alice.publicKey
     );
@@ -23,13 +23,13 @@ describe('decodeAddress', (): void => {
 
   it('decodes the council address', (): void => {
     expect(
-      u8aToHex(decode('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
+      u8aToHex(decodeAddress('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
     ).toEqual(u8aToHex(stringToU8a('modlpy/trsry'.padEnd(32, '\0'))));
   });
 
   it('converts a publicKey (u8a) as-is', (): void => {
     expect(
-      decode(new Uint8Array([1, 2, 3]))
+      decodeAddress(new Uint8Array([1, 2, 3]))
     ).toEqual(
       new Uint8Array([1, 2, 3])
     );
@@ -37,7 +37,7 @@ describe('decodeAddress', (): void => {
 
   it('converts a publicKey (hex) as-is', (): void => {
     expect(
-      decode('0x01020304')
+      decodeAddress('0x01020304')
     ).toEqual(
       new Uint8Array([1, 2, 3, 4])
     );
@@ -45,37 +45,37 @@ describe('decodeAddress', (): void => {
 
   it('decodes a short address', (): void => {
     expect(
-      decode('F7NZ')
+      decodeAddress('F7NZ')
     ).toEqual(new Uint8Array([1]));
   });
 
   it('decodes a 1-byte accountId (with prefix)', (): void => {
     expect(
-      decode('PqtB', false, 68)
+      decodeAddress('PqtB', false, 68)
     ).toEqual(new Uint8Array([1]));
   });
 
   it('decodes a 2-byte accountId', (): void => {
     expect(
-      decode('2jpAFn', false, 68)
+      decodeAddress('2jpAFn', false, 68)
     ).toEqual(new Uint8Array([0, 1]));
   });
 
   it('encodes a 4-byte address', (): void => {
     expect(
-      decode('as7QnGMf', false, 68)
+      decodeAddress('as7QnGMf', false, 68)
     ).toEqual(new Uint8Array([1, 2, 3, 4]));
   });
 
   it('decodes a 8-byte address', (): void => {
     expect(
-      decode('4q7qY5RBG7Z4wv', false, 68)
+      decodeAddress('4q7qY5RBG7Z4wv', false, 68)
     ).toEqual(new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]));
   });
 
   it('decodes a 33-byte address', (): void => {
     expect(
-      decode('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
+      decodeAddress('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
     ).toEqual(
       hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
     );
@@ -83,28 +83,28 @@ describe('decodeAddress', (): void => {
 
   it.skip('allows invalid prefix (in list)', (): void => {
     expect(
-      (): Uint8Array => decode('6GfvWUvHvU8otbZ7sFhXH4eYeMcKdUkL61P3nFy52efEPVUx')
+      (): Uint8Array => decodeAddress('6GfvWUvHvU8otbZ7sFhXH4eYeMcKdUkL61P3nFy52efEPVUx')
     ).toThrow(/address prefix/);
   });
 
   it('fails when length is invalid', (): void => {
     expect(
-      (): Uint8Array => decode('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')
+      (): Uint8Array => decodeAddress('y9EMHt34JJo4rWLSaxoLGdYXvjgSXEd4zHUnQgfNzwES8b')
     ).toThrow(/address length/);
   });
 
   it('fails when the checksum does not match', (): void => {
     expect(
-      (): Uint8Array => decode('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMa9cj')
+      (): Uint8Array => decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMa9cj')
     ).toThrow(/address checksum/);
     expect(
-      (): Uint8Array => decode('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
+      (): Uint8Array => decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
     ).toThrow(/address checksum/);
   });
 
   it('fails when invalid base58 encoded address is found', (): void => {
     expect(
-      () => u8aToHex(decode('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
+      () => u8aToHex(decodeAddress('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
     ).toThrow(/Decoding F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29: Invalid base58 character "I" \(0x49\) at index 4/);
   });
 });

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

@@ -1,18 +1,17 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './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 checkChecksum from './checkChecksum';
-import defaults from './defaults';
+import { base58Decode } from '../base58/decode';
+import { checkAddressChecksum } from './checksum';
+import { defaults } from './defaults';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export default function decode (encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format: Prefix = 99): Uint8Array {
+export function decodeAddress (encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
   if (isU8a(encoded) || isHex(encoded)) {
     return u8aToU8a(encoded);
   }
@@ -30,11 +29,11 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
   assert(defaults.allowedEncodedLengths.includes(decoded.length), wrapError('Invalid decoded address length'));
 
   // TODO Unless it is an "use everywhere" prefix, throw an error
-  // if (decoded[0] !== prefix) {
-  //   console.log(`WARN: Expected ${prefix}, found ${decoded[0]}`);
+  // if (ss58Format !== -1 && (decoded[0] !== ss58Format)) {
+  //   console.log(`WARN: Expected ${ss58Format}, found ${decoded[0]}`);
   // }
 
-  const [isValid, endPos] = checkChecksum(decoded);
+  const [isValid, endPos] = checkAddressChecksum(decoded);
 
   assert(ignoreChecksum || isValid, wrapError('Invalid decoded address checksum'));
 

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

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

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

@@ -1,9 +1,9 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { waitReady } from '@polkadot/wasm-crypto';
 
-import derive from './derive';
+import { deriveAddress } from '.';
 
 describe('deriveAddress', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -12,13 +12,13 @@ describe('deriveAddress', (): void => {
 
   it('derives a known path', (): void => {
     expect(
-      derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
+      deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
     ).toEqual('5GZ4srnepXvdsuNVoxCGyVZd8ScDm4gkGLTKuaGARy9akjTa');
   });
 
   it('fails on hard paths', (): void => {
     expect(
-      () => derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
+      () => deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
     ).toThrow(/Expected suri to contain a combination of non-hard paths/);
   });
 });

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

@@ -1,15 +1,15 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './types';
+import type { Prefix } from './types';
 
 import { assert } from '@polkadot/util';
 
-import DeriveJunction from '../key/DeriveJunction';
 import { keyExtractPath } from '../key';
+import { DeriveJunction } from '../key/DeriveJunction';
 import { schnorrkelDerivePublic } from '../schnorrkel';
-import decode from './decode';
-import encode from './encode';
+import { decodeAddress } from './decode';
+import { encodeAddress } from './encode';
 
 /**
  * @name deriveAddress
@@ -17,12 +17,12 @@ import encode from './encode';
  * @description
  * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
  */
-export default function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+export function deriveAddress (who: 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');
 
-  return encode(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
+  return encodeAddress(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
     return schnorrkelDerivePublic(publicKey, path.chainCode);
-  }, decode(who)), ss58Format);
+  }, decodeAddress(who)), ss58Format);
 }

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

@@ -1,11 +1,11 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import testingPairs from '@polkadot/keyring/testingPairs';
+import { createTestPairs } from '@polkadot/keyring/testingPairs';
 
-import encode from './encode';
+import { encodeAddress } from '.';
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('encode', (): void => {
   it('encodes an address to a valid value', (): void => {
@@ -16,19 +16,19 @@ describe('encode', (): void => {
 
   it('can re-encode an address', (): void => {
     expect(
-      encode('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 68)
+      encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 68)
     ).toEqual('7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv');
   });
 
   it('can re-encode an address to Polkadot live', (): void => {
     expect(
-      encode('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
+      encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
     ).toEqual('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5');
   });
 
   it('fails when non-valid publicKey provided', (): void => {
     expect(
-      (): string => encode(
+      (): string => encodeAddress(
         keyring.alice.publicKey.slice(0, 30)
       )
     ).toThrow(/Expected a valid key/);
@@ -36,7 +36,7 @@ describe('encode', (): void => {
 
   it('encodes a 1-byte address', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([1])
       )
     ).toEqual('F7NZ');
@@ -44,7 +44,7 @@ describe('encode', (): void => {
 
   it('encodes a 1-byte address (with prefix)', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([1]), 68
       )
     ).toEqual('PqtB');
@@ -52,7 +52,7 @@ describe('encode', (): void => {
 
   it('encodes a 2-byte address', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([0, 1]), 68
       )
     ).toEqual('2jpAFn');
@@ -60,7 +60,7 @@ describe('encode', (): void => {
 
   it('encodes a 4-byte address', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([1, 2, 3, 4]), 68
       )
     ).toEqual('as7QnGMf');
@@ -68,7 +68,7 @@ describe('encode', (): void => {
 
   it('encodes a 8-byte address', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]), 68
       )
     ).toEqual('4q7qY5RBG7Z4wv');
@@ -76,7 +76,7 @@ describe('encode', (): void => {
 
   it('encodes an 33-byte address', (): void => {
     expect(
-      encode('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
+      encodeAddress('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
     ).toEqual('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou');
   });
 });

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

@@ -1,20 +1,19 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './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 decode from './decode';
-import defaults from './defaults';
-import sshash from './sshash';
+import { base58Encode } from '../base58/encode';
+import { decodeAddress } from './decode';
+import { defaults } from './defaults';
+import { sshash } from './sshash';
 
-export default function encode (_key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
+export function encodeAddress (_key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
   // decode it, this means we can re-encode an address
-  const key = decode(_key);
+  const key = decodeAddress(_key);
 
   assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
 

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

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import encodeDerivedAddress from './encodeDerived';
+import { encodeDerivedAddress } from '.';
 
 describe('encodeDerivedAddress', (): void => {
   it('creates a valid known derived address', (): void => {

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

@@ -1,13 +1,12 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './types';
+import type BN from 'bn.js';
+import type { Prefix } from './types';
 
-import BN from 'bn.js';
-
-import decode from './decode';
-import encode from './encode';
-import keyDerived from './keyDerived';
+import { decodeAddress } from './decode';
+import { encodeAddress } from './encode';
+import { createKeyDerived } from './keyDerived';
 
 /**
  * @name encodeDerivedAddress
@@ -15,6 +14,6 @@ import keyDerived from './keyDerived';
  * @description
  * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
  */
-export default function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
-  return encode(keyDerived(decode(who), index), ss58Format);
+export function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
 }

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

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import encodeMultiAddress from './encodeMulti';
+import { encodeMultiAddress } from '.';
 
 describe('encodeMultiAddress', (): void => {
   it('creates a valid known multi address', (): void => {

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

@@ -1,12 +1,11 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './types';
+import type BN from 'bn.js';
+import type { Prefix } from './types';
 
-import BN from 'bn.js';
-
-import encode from './encode';
-import keyMulti from './keyMulti';
+import { encodeAddress } from './encode';
+import { createKeyMulti } from './keyMulti';
 
 /**
  * @name encodeMultiAddress
@@ -14,6 +13,6 @@ import keyMulti from './keyMulti';
  * @description
  * Creates a Substrate multisig address based on the input address and the required threshold.
  */
-export default function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
-  return encode(keyMulti(who, threshold), ss58Format);
+export function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encodeAddress(createKeyMulti(who, threshold), ss58Format);
 }

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

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

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

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

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

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import evmToAddress from './evmToAddress';
+import { evmToAddress } from '.';
 
 describe('evmToAddress', (): void => {
   it('creates a valid known SS58 address', (): void => {

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

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

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

@@ -1,34 +1,17 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import addressToEvm from './addressToEvm';
-import checkAddress from './check';
-import checkAddressChecksum from './checkChecksum';
-import createKeyMulti from './keyMulti';
-import createKeyDerived from './keyDerived';
-import decodeAddress from './decode';
-import deriveAddress from './derive';
-import encodeAddress from './encode';
-import encodeDerivedAddress from './encodeDerived';
-import encodeMultiAddress from './encodeMulti';
-import evmToAddress from './evmToAddress';
-import addressEq from './eq';
-import setSS58Format from './setSS58Format';
-import sortAddresses from './sort';
-
-export {
-  addressEq,
-  addressToEvm,
-  checkAddress,
-  checkAddressChecksum,
-  createKeyDerived,
-  createKeyMulti,
-  decodeAddress,
-  deriveAddress,
-  encodeAddress,
-  encodeDerivedAddress,
-  encodeMultiAddress,
-  evmToAddress,
-  setSS58Format,
-  sortAddresses
-};
+export { addressToEvm } from './addressToEvm';
+export { checkAddress } from './check';
+export { checkAddressChecksum } from './checksum';
+export { createKeyMulti } from './keyMulti';
+export { createKeyDerived } from './keyDerived';
+export { decodeAddress } from './decode';
+export { deriveAddress } from './derive';
+export { encodeAddress } from './encode';
+export { encodeDerivedAddress } from './encodeDerived';
+export { encodeMultiAddress } from './encodeMulti';
+export { evmToAddress } from './evmToAddress';
+export { addressEq } from './eq';
+export { setSS58Format } from './setSS58Format';
+export { sortAddresses } from './sort';

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

@@ -1,7 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import createKeyDerived from './keyDerived';
+import { createKeyDerived } from '.';
 
 describe('createKeyDerived', (): void => {
   it('matches sub accounts with Rust', (): void => {

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

@@ -1,15 +1,16 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import BN from 'bn.js';
+import type BN from 'bn.js';
+
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
-import decodeAddress from './decode';
+import { blake2AsU8a } from '../blake2/asU8a';
+import { decodeAddress } from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export default function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
+export function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { createKeyMulti } from '.';

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

@@ -1,15 +1,16 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import BN from 'bn.js';
+import type BN from 'bn.js';
+
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
-import decodeAddress from './decode';
+import { blake2AsU8a } from '../blake2/asU8a';
+import { decodeAddress } from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export default function createKeyMulti (who: (Uint8Array | string)[], threshold: BigInt | BN | number): Uint8Array {
+export function createKeyMulti (who: (Uint8Array | string)[], threshold: BigInt | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

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

@@ -1,8 +1,7 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import encode from './encode';
-import setSS58Format from './setSS58Format';
+import { encodeAddress, setSS58Format } from '.';
 
 describe('setSS58Format', (): void => {
   beforeEach((): void => {
@@ -11,7 +10,7 @@ describe('setSS58Format', (): void => {
 
   it('sets and allows encoding using', (): void => {
     expect(
-      encode(
+      encodeAddress(
         new Uint8Array([1])
       )
     ).toEqual('PqtB');

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

@@ -1,14 +1,14 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { Prefix } from './types';
+import type { Prefix } from './types';
 
-import defaults from './defaults';
+import { defaults } from './defaults';
 
 /**
  * @description Sets the global SS58 format to use for address encoding
  * @deprecated Use keyring.setSS58Format
  */
-export default function setSS58Format (prefix: Prefix): void {
+export function setSS58Format (prefix: Prefix): void {
   defaults.prefix = prefix;
 }

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { sortAddresses } from '.';

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

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

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

@@ -1,12 +1,12 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { stringToU8a, u8aConcat } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
+import { blake2AsU8a } from '../blake2/asU8a';
 
 const SS58_PREFIX = stringToU8a('SS58PRE');
 
-export default function hash (key: Uint8Array): Uint8Array {
+export function sshash (key: Uint8Array): Uint8Array {
   return blake2AsU8a(u8aConcat(SS58_PREFIX, key), 512);
 }

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // FIXME we really want this to map with what is in the allowedSS58 array... i.e. the

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// 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

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { u8aToString } from '@polkadot/util';

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// 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
@@ -6,7 +6,7 @@
 import { assert } from '@polkadot/util';
 
 import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
-import validate from './validate';
+import { base32Validate } from './validate';
 
 // Build the character lookup table:
 const LOOKUP = BASE32_ALPHABET
@@ -42,8 +42,8 @@ function decode (output: Uint8Array, input: string, offset: number): [Uint8Array
  * @description
  * From the provided input, decode the base32 and return the result as an `Uint8Array`.
  */
-export default function base32Decode (value: string, ipfsCompat = false): Uint8Array {
-  validate(value, ipfsCompat);
+export function base32Decode (value: string, ipfsCompat = false): Uint8Array {
+  base32Validate(value, ipfsCompat);
 
   const offset = (ipfsCompat ? 1 : 0);
   const [output, bits, buffer] = decode(

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { base58Decode } from '../base58';

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// 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
@@ -15,7 +15,7 @@ const MASK = (1 << BITS_PER_CHAR) - 1;
  * @description
  * From the provided input, create the base32 and return the result as a string.
  */
-export default function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
+export function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
   const u8a = u8aToU8a(value);
   let out = '';
   let bits = 0;

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

@@ -1,11 +1,11 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 /**
  * @summary Encode and decode base32 values
  */
 
-export { default as base32Decode } from './decode';
-export { default as base32Encode } from './encode';
-export { default as base32Validate } from './validate';
-export { default as isBase32 } from './is';
+export { base32Decode } from './decode';
+export { base32Encode } from './encode';
+export { base32Validate } from './validate';
+export { isBase32 } from './is';

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

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

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import { base32Validate } from '.';

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

@@ -1,15 +1,17 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// 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 the the supplied value is valid base32
  */
-export default function base32Validate (value?: string | null, ipfsCompat = false): true {
-  return validateChars('base32', BASE32_ALPHABET, value, ipfsCompat ? 'b' : undefined);
+export function base32Validate (value?: string | null, ipfsCompat?: boolean): true {
+  return validateChars(BASE_CONFIG, value, ipfsCompat);
 }

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

@@ -1,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import baseX from 'base-x';

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

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