[CI Skip] release/stable 6.0.3

skip-checks: true

.123trigger

@@ -1,3 +1,16 @@
 6
+
 2.6.2
 2.12.2
+5.2.2
+5.2.3
+5.4.2
+5.4.3
+5.4.4
+5.5.2
+5.6.2
+5.6.3
+5.9.2
+
+6.0.2
+6.0.3

.eslintrc.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
 
 const base = require('@polkadot/dev/config/eslint.cjs');

.github/workflows/pr-any.yml

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

.github/workflows/ss58-check.yml

@@ -1,7 +1,7 @@
 name: SS58
 on:
   schedule:
-    - cron:  '45 3 * * *'
+    - cron:  '15 4/6 * * *'
 
 jobs:
   ss58:
@@ -19,6 +19,7 @@ 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
+        update_existing: true

.nvmrc

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

.yarnrc.yml

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

CHANGELOG.md

@@ -1,5 +1,168 @@
 # CHANGELOG
 
+## 6.0.3 Mar 5, 2021
+
+Changes:
+
+- Add import indirection for both CJS & ESM (where generated source file is commonjs)
+
+
+## 6.0.2 Mar 5, 2021
+
+Changes:
+
+- Fix `@polkadot/x-rxjs` ESM exports for Node environments (now different due to the ESM conversion)
+
+
+## 6.0.1 Mar 5, 2021
+
+**Important** In the 6.0 version the default package type has been changed to ESM modules by default. This should not affect usage, however since the output formats changed, a new major version is required.
+
+Contributed:
+
+- Add dev addresses for Frontier-based chains (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Build to ESM by default (with cjs versions via export map)
+- Allow addition or raw pairs on the keyring via `{add, create}FromPair`
+- Extract re-usable json encryption/decryption functions
+
+
+## 5.9.2 Feb 28, 2021
+
+Changes:
+
+- Fix package detection for `@polkadot/networks` (no dependencies)
+
+
+## 5.9.1 Feb 28, 2021
+
+Changes:
+
+- Expand `detectPackage` with optional param allowing checks for monorepo versions
+- Export logger `format` function directly as `loggerFormat`
+- Expand tests and checks for `hdValidatePath`
+- Remove `hdEthereum` class-based approach, simplify
+- Cleanup formatting on nested conditionals in the `@polkadot/x-` packages
+- All packages now export `packageInfo` from the root
+
+
+## 5.8.1 Feb 26, 2021
+
+Contributed:
+
+- Add ss58 information for HydraDX (Thanks to https://github.com/jak-pan)
+- HD derivation for Ethereum (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Adjust base64 encoding/decoding to not rely on Buffer being available
+- Rework Ethereum derivation to only use Uint8Array internally
+- Shared HD path validation for Ledger & Ethereum
+- Additional derivation, encoding and decoding tests on keyring
+- Align networks with upstream ss58 registry
+- `@polkadot/wasm-crypto` 3.2.4
+
+
+## 5.7.1 Feb 21, 2021
+
+**Breaking change** The signature of `pair.verify` now requires the signer public key as a parameter. If using `pair.verify` pass the publicKey (hex or Uint8Array) of the signer.
+
+Changes:
+
+- The signature on the keyring for `.verify` now explicitly requires the `publicKey` of the signer. Previously it only verified against an own public key.
+- Add additional ss58 test vectors (against chains with >63 prefixes in the Substrate registry)
+
+
+## 5.6.3 Feb 16, 2021
+
+Contributed:
+
+- Add ss58 information for Aventus (Thanks to https://github.com/nahuseyoum)
+
+Changes:
+
+- Add `unlock(password)` to keypair (less confusing than only having `decodePkcs8`, equivalent to `lock()`)
+- Change use of `detectPackage` to use `packageInfo.ts`
+- Align with upstream ss58 registry
+- `@polkadot/wasm-crypto` 3.2.3
+
+
+## 5.6.2 Feb 8, 2021
+
+Changes:
+
+- `@polkadot/networks` now filters the new upstream-introduced `null` networks
+
+
+## 5.6.1 Feb 7, 2021
+
+Contributed:
+
+- Fix installation instructions in `@polkadot/x-global` (Thanks to https://github.com/raoulmillais)
+
+Changes:
+
+- Conform to new ss58 encoding with ids up to 16,383 (>= 64 as 2 bytes)
+- Use JS sqrt inside `bnSqrt` when value <= MAX_SAFE_INTEGER
+- Adjust all `Buffer.from` usages, prefer `Uint8Array` where possible
+- Expand tests for keyring with `vrf{Sign, Verify}`
+- Align `@polkadot/networks` with latest ss58 registry
+
+
+## 5.5.2 Feb 2, 2021
+
+Changes:
+
+- Expose `BN_{MILLION, BILLION}` constants (in addition to 2-9)
+
+
+## 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:

babel.config.cjs

@@ -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-config-cjs.cjs');

jest.config.cjs

@@ -1,27 +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.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|randomvalues|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.cjs'
+  transformIgnorePatterns: ['/node_modules/(?!@polkadot)']
 });

package.json

@@ -7,7 +7,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^4.1.3"
+    "typescript": "^4.2.2"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
@@ -20,10 +20,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.12.10",
-    "@polkadot/dev": "^0.61.16",
-    "@polkadot/ts": "^0.3.58",
-    "@types/jest": "^26.0.19"
+    "@babel/core": "^7.13.8",
+    "@polkadot/dev": "^0.62.5",
+    "@polkadot/ts": "^0.3.61",
+    "@types/jest": "^26.0.20"
   },
-  "version": "5.2.1"
+  "version": "6.0.3"
 }

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,25 @@
+{
+  "name": "@polkadot/hw-ledger-transports",
+  "version": "6.0.3",
+  "type": "module",
+  "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.13.9",
+    "@ledgerhq/hw-transport-webusb": "^5.45.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.45.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';
+
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [
+  // deprecated
+  // import LedgerU2F from '@ledgerhq/hw-transport-u2f';
+  // {
+  //   create: (): Promise<Transport> =>
+  //     LedgerU2F.create(),
+  //   type: 'u2f'
+  // },
+  {
+    create: (): Promise<Transport> =>
+      LedgerWebUSB.create(),
+    type: 'webusb'
+  }
+];

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';
+
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [
+  {
+    create: (): Promise<Transport> =>
+      LedgerHid.create(),
+    type: 'hid'
+  }
+];

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

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

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';
+
+export { packageInfo } from './packageInfo';
+
+export const transports: TransportDef[] = [];

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,21 @@
+{
+  "name": "@polkadot/hw-ledger",
+  "version": "6.0.3",
+  "type": "module",
+  "repository": "github:polkadot-js/common",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "maintainers": [],
+  "contributors": [],
+  "license": "Apache-2.0",
+  "main": "index.js",
+  "sideEffects": [
+    "./detectPackage.js",
+    "./detectPackage.cjs"
+  ],
+  "dependencies": {
+    "@babel/runtime": "^7.13.9",
+    "@polkadot/hw-ledger-transports": "6.0.3",
+    "@polkadot/util": "^6.0.3",
+    "@zondax/ledger-polkadot": "^0.13.4"
+  }
+}

packages/hw-ledger/src/detectPackage.ts

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

packages/hw-ledger/src/index.ts

@@ -0,0 +1,122 @@
+// Copyright 2017-2021 @polkadot/hw-ledger authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './detectPackage';
+
+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, u8aToBuffer } from '@polkadot/util';
+
+export { packageInfo } from './packageInfo';
+
+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: `0x${signature.toString('hex')}`
+      };
+    });
+  }
+
+  #getApp = async (): Promise<SubstrateApp> => {
+    if (!this.#app) {
+      const def = transports.find(({ type }) => type === this.#transport);
+
+      assert(def, `Unable to find a transport for ${this.#transport}`);
+
+      const transport = await def.create();
+
+      this.#app = 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/packageInfo.ts

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

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,27 +1,27 @@
 {
   "name": "@polkadot/keyring",
-  "version": "5.2.1",
+  "version": "6.0.3",
+  "type": "module",
   "description": "Keyring management",
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
   "main": "index.js",
-  "module": "index.mjs",
   "sideEffects": [
     "./detectPackage.js",
-    "./detectPackage.mjs"
+    "./detectPackage.cjs"
   ],
   "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.5",
-    "@polkadot/util": "5.2.1",
-    "@polkadot/util-crypto": "5.2.1"
+    "@babel/runtime": "^7.13.9",
+    "@polkadot/util": "6.0.3",
+    "@polkadot/util-crypto": "6.0.3"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.2.1",
-    "@polkadot/util-crypto": "5.2.1"
+    "@polkadot/util": "6.0.3",
+    "@polkadot/util-crypto": "6.0.3"
   }
 }

packages/keyring/src/defaults.ts

@@ -1,13 +1,8 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // default substrate dev phrase
-const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
+export const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
 
 // seed from the above phrase
-const DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';
-
-export {
-  DEV_PHRASE,
-  DEV_SEED
-};
+export const DEV_SEED = '0xfac7959dbfe72f052e5a0c3c8d6530f202b02fd8f9f5ca3580ec8deb7797479e';

packages/keyring/src/detectPackage.ts

@@ -1,25 +1,9 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// 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, packageInfo as utilInfo } from '@polkadot/util';
+import { packageInfo as cryptoInfo } from '@polkadot/util-crypto/packageInfo';
 
-import { detectPackage } from '@polkadot/util';
+import { packageInfo } from './packageInfo';
 
-import packageInfo from './package-info.json';
-
-detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname);
-
-export { packageInfo };
+detectPackage(packageInfo, typeof __dirname !== 'undefined' && __dirname, [utilInfo, cryptoInfo]);

packages/keyring/src/index.spec.ts

@@ -1,9 +1,12 @@
-// Copyright 2017-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, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
+import type { KeyringPair$Json } from './types';
 
+import { hexToU8a, stringToU8a } from '@polkadot/util';
+import { base64Decode, cryptoWaitReady, encodeAddress, randomAsU8a, setSS58Format } from '@polkadot/util-crypto';
+
+import { decodePair } from './pair/decode';
 import Keyring from '.';
 
 describe('keypair', (): void => {
@@ -46,11 +49,11 @@ describe('keypair', (): void => {
 
     it('adds from a mnemonic, with correct ss58', (): void => {
       setSS58Format(20); // this would not be used
-      keyring.setSS58Format(68); // this would be used
+      keyring.setSS58Format(2); // this would be used
 
       const pair = keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {});
 
-      expect(pair.address).toEqual('7sPsxWPE5DzAyPT3VuoJYw5NTGscx9QYN9oddQx4kALKC3hH');
+      expect(pair.address).toEqual('HSLu2eci2GCfWkRimjjdTXKoFSDL3rBv5Ey2JWCBj68cVZj');
       expect(encodeAddress(pair.publicKey)).toEqual('35cDYtPsdG1HUa2n2MaARgJyRz1WKMBZK1DL6c5cX7nugQh1');
     });
 
@@ -83,8 +86,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -92,8 +96,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
@@ -123,11 +128,11 @@ describe('keypair', (): void => {
     });
 
     it('adds from a mnemonic', (): void => {
-      keyring.setSS58Format(68);
+      keyring.setSS58Format(2);
 
       expect(
         keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {}).address
-      ).toEqual('7qQGarA4PWjPPVHG4USn1yuuVZvEHN7XZz8o7EbAp48jayZQ');
+      ).toEqual('FSjXNRT2K1R5caeHLPD6WMrqYUpfGZB7ua8W89JFctZ1YqV');
     });
 
     it('allows publicKeys retrieval', (): void => {
@@ -159,8 +164,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -168,8 +174,9 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
@@ -200,11 +207,11 @@ describe('keypair', (): void => {
     });
 
     it('adds from a mnemonic', (): void => {
-      keyring.setSS58Format(68);
+      keyring.setSS58Format(2);
 
       expect(
         keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card').address
-      ).toEqual('7ooxHV3mz4nnWbK8v7Mxcb71QMpof268eL1A2VrYWUNWJk8P');
+      ).toEqual('DrRE1KAcs4pCicX8yJPh7YxkLPQ2vXnCFSVRPQfx38KjEFe');
     });
 
     it('allows publicKeys retrieval', (): void => {
@@ -259,13 +266,33 @@ describe('keypair', (): void => {
       ).not.toThrow();
     });
 
+    it('encodes a pair toJSON (and decodes)', (): void => {
+      const pair = keyring.createFromUri('moral movie very draw assault whisper awful rebuild speed purity repeat card');
+      const json = pair.toJson('password');
+
+      expect(json.address).toEqual('0x03ddca309bd5fedd01f914d6fb76f23aa848a2a520802159215dba5085d7863619');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ecdsa'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
     it('signs and verifies', (): void => {
       const MESSAGE = stringToU8a('this is a message');
       const pair = keyring.getPair(addressKeyOne);
       const signature = pair.sign(MESSAGE);
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
 
     it('signs and verifies (withType)', (): void => {
@@ -273,36 +300,86 @@ describe('keypair', (): void => {
       const pair = keyring.getPair(addressKeyOne);
       const signature = pair.sign(MESSAGE, { withType: true });
 
-      expect(pair.verify(MESSAGE, signature)).toBe(true);
-      expect(pair.verify(new Uint8Array(), signature)).toBe(false);
+      expect(pair.verify(MESSAGE, signature, pair.publicKey)).toBe(true);
+      expect(pair.verify(MESSAGE, signature, randomAsU8a())).toBe(false);
+      expect(pair.verify(new Uint8Array(), signature, pair.publicKey)).toBe(false);
     });
   });
 
   describe('ethereum', (): void => {
-    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+    // combine mnemonic with derivation path
+    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy' + '/m/44\'/60\'/0\'/0/0';
+    const PRIV_KEY_ONE = '0x070dc3117300011918e26b02176945cc15c3d548cf49fd8418d97f93af699e46';
+    const ETH_ADDRESS_ONE = '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d';
+
     let keyring: Keyring;
 
     beforeEach((): void => {
       keyring = new Keyring({ type: 'ethereum' });
     });
 
-    it('adds a pair with the correct address', (): void => {
-      const pair = keyring.createFromUri(PHRASE);
+    it('creates with dev phrase from the private key', (): void => {
+      const pair = keyring.addFromSeed(hexToU8a(PRIV_KEY_ONE));
 
-      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
-      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
     });
 
-    it('encodes a pair toJSON', (): void => {
+    it('creates with dev phrase from the private key in createFromUri', (): void => {
+      const pair = keyring.createFromUri(PRIV_KEY_ONE);
+
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('creates with dev phrase with derivation path specified', (): void => {
+      const pair = keyring.createFromUri(PHRASE);
+
+      expect(
+        pair.address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('creates with dev phrase with derivation path specified - addFromUri', (): void => {
+      expect(
+        keyring.addFromUri(PHRASE).address
+      ).toEqual(ETH_ADDRESS_ONE);
+    });
+
+    it('encodes a pair toJSON (and decodes)', (): void => {
       const pair = keyring.createFromUri(PHRASE);
       const json = pair.toJson('password');
 
-      expect(json.address).toEqual('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077');
+      expect(json.address).toEqual('0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b'); // this is the public key (different from address for ethereum)
       expect(json.encoding).toEqual({
         content: ['pkcs8', 'ethereum'],
         type: ['scrypt', 'xsalsa20-poly1305'],
         version: '3'
       });
+
+      const newPair = keyring.createFromJson(json);
+
+      expect(newPair.publicKey).toEqual(pair.publicKey);
+      expect(
+        () => newPair.unlock('password')
+      ).not.toThrow();
+    });
+
+    it('encodes a pair toJSON and back', (): void => {
+      const pairOriginal = keyring.createFromUri(PHRASE);
+      const json = pairOriginal.toJson('password');
+      const pair = keyring.addFromJson(
+        json
+      );
+
+      expect(pair.address).toEqual(ETH_ADDRESS_ONE);
+
+      pair.decodePkcs8('password');
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe(ETH_ADDRESS_ONE);
     });
 
     it('allows adding from JSON', (): void => {
@@ -328,9 +405,13 @@ describe('keypair', (): void => {
       );
 
       const signature = signer.sign(MESSAGE);
+      const dummyPublic = verifier.publicKey.slice();
 
-      expect(verifier.verify(MESSAGE, signature)).toBe(true);
-      expect(verifier.verify(new Uint8Array(), signature)).toBe(false);
+      dummyPublic[dummyPublic.length - 1] = 0;
+
+      expect(verifier.verify(MESSAGE, signature, signer.publicKey)).toBe(true);
+      expect(verifier.verify(MESSAGE, signature, dummyPublic)).toBe(false);
+      expect(verifier.verify(new Uint8Array(), signature, signer.publicKey)).toBe(false);
     });
 
     it('allows for signing/verification (withType)', (): void => {
@@ -341,9 +422,37 @@ describe('keypair', (): void => {
       );
 
       const signature = signer.sign(MESSAGE, { withType: true });
+      const dummyPublic = verifier.publicKey.slice();
 
-      expect(verifier.verify(MESSAGE, signature)).toBe(true);
-      expect(verifier.verify(new Uint8Array(), signature)).toBe(false);
+      dummyPublic[dummyPublic.length - 1] = 0;
+
+      expect(verifier.verify(MESSAGE, signature, signer.publicKey)).toBe(true);
+      expect(verifier.verify(MESSAGE, signature, dummyPublic)).toBe(false);
+      expect(verifier.verify(new Uint8Array(), signature, signer.publicKey)).toBe(false);
+    });
+  });
+
+  describe('raw pair add/create', (): void => {
+    const json = JSON.parse('{"address":"5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H","encoded":"JQUl8ZpoXv2OMkL9TPylLmcIye2cYhaS9INICbFgZTsAgAAAAQAAAAgAAAAr/0hJOOzokIdBG71TstigLABX9D5xGD7L37ySxtjDrVRg26LL90jLQ47quT9o3bq6ppXMVL6USk7Q4p3WU66bojTFuCDyhpYRhNbUqU6s0rD3S4bhv9lG+pG9vQ4eD5PVQUvxdANmJpYuDg45nrTmsMC5AHGdFGkHW/LHnkmbFid1cvPYkdiBoef5CIEdoly512pxMupVxnJWF1NT","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"name":"hello"}}') as KeyringPair$Json;
+    const decoded = decodePair('1', base64Decode(json.encoded), json.encoding.type);
+    const keyring = new Keyring({ ss58Format: 44 });
+
+    it('creates a pair from a private/public combo', (): void => {
+      const pair = keyring.createFromPair(decoded, json.meta, 'sr25519');
+
+      expect(pair.address).toEqual('5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H');
+      expect(pair.isLocked).toEqual(false);
+      expect(pair.meta.name).toEqual('hello');
+    });
+
+    it('adds a pair from a private/public combo', (): void => {
+      keyring.addFromPair(decoded, json.meta, 'sr25519');
+
+      const pair = keyring.getPairs()[0];
+
+      expect(pair.address).toEqual('5PjeoaQzCoYbSi42aQRKB3Sx18StCaEAzCbGEEbWbZyfKS3H');
+      expect(pair.isLocked).toEqual(false);
+      expect(pair.meta.name).toEqual('hello');
     });
   });
 

packages/keyring/src/index.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
 
 import './detectPackage';
@@ -7,6 +7,8 @@ import { Keyring } from './keyring';
 
 export { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
 
+export { packageInfo } from './packageInfo';
+
 export default Keyring;
 
 export { Keyring };

packages/keyring/src/keyring.ts

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

packages/keyring/src/packageInfo.ts

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

packages/keyring/src/pair/decode.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
 
 import { createTestPairs } from '../testingPairs';

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

packages/keyring/src/pair/defaults.ts

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

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

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

packages/keyring/src/pair/encode.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
 
 import type { PairInfo } from './types';

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

@@ -1,10 +1,10 @@
-// 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 { hexToU8a, u8aToHex } from '@polkadot/util';
 import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';
 
-import { PAIRS } from '../testing';
+import { PAIRSSR25519 } from '../testing';
 import { createTestPairs } from '../testingPairs';
 import { createPair } from '.';
 
@@ -42,20 +42,56 @@ describe('pair', (): void => {
     expect(
       keyring.alice.verify(
         new Uint8Array([0x61, 0x62, 0x63, 0x64]),
-        SIGNATURE
+        SIGNATURE,
+        keyring.alice.publicKey
       )
     ).toEqual(true);
   });
 
+  it('fails a correctly signed message (signer changed)', (): void => {
+    expect(
+      keyring.alice.verify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
+        SIGNATURE,
+        keyring.bob.publicKey
+      )
+    ).toEqual(false);
+  });
+
   it('fails a correctly signed message (message changed)', (): void => {
     expect(
       keyring.alice.verify(
         new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
-        SIGNATURE
+        SIGNATURE,
+        keyring.alice.publicKey
       )
     ).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),
+        keyring.alice.publicKey
+      )
+    ).toBe(true);
+  });
+
+  it('fails vrf sign and verify (publicKey changed)', (): void => {
+    const message = new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]);
+
+    expect(
+      keyring.alice.vrfVerify(
+        message,
+        keyring.alice.vrfSign(message),
+        keyring.bob.publicKey
+      )
+    ).toBe(false);
+  });
+
   it('allows setting/getting of meta', (): void => {
     keyring.bob.setMeta({ foo: 'bar', something: 'else' });
 
@@ -67,15 +103,11 @@ describe('pair', (): void => {
   });
 
   it('allows encoding of address with different prefixes', (): void => {
-    expect(keyring.alice.address).toEqual(
-      '5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua'
-    );
+    expect(keyring.alice.address).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
 
-    setSS58Format(68);
+    setSS58Format(255);
 
-    expect(keyring.alice.address).toEqual(
-      '7sGUeMak588SPY2YMmmuKUuLz7u2WQpf74F9dCFtSLB2td9d'
-    );
+    expect(keyring.alice.address).toEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k');
 
     setSS58Format(42);
   });
@@ -92,11 +124,11 @@ describe('pair', (): void => {
   });
 
   it('allows derivation on the pair', (): void => {
-    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRS[0].publicKey, secretKey: PAIRS[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRSSR25519[0].publicKey, secretKey: PAIRSSR25519[0].secretKey }, {});
     const stash = alice.derive('//stash');
     const soft = alice.derive('//funding/0');
 
-    expect(stash.publicKey).toEqual(PAIRS[1].publicKey);
+    expect(stash.publicKey).toEqual(PAIRSSR25519[1].publicKey);
     expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
   });
 
@@ -110,11 +142,43 @@ describe('pair', (): void => {
   });
 
   describe('ethereum', (): void => {
+    const PUBLICDERIVED = new Uint8Array([
+      3, 129, 53, 27, 27, 70, 210, 96,
+      43, 9, 146, 187, 93, 85, 49, 249,
+      193, 105, 107, 8, 18, 254, 178, 83,
+      75, 104, 132, 173, 196, 126, 46, 29,
+      139
+    ]);
+    const SECRETDERIVED = new Uint8Array([
+      7, 13, 195, 17, 115, 0, 1, 25,
+      24, 226, 107, 2, 23, 105, 69, 204,
+      21, 195, 213, 72, 207, 73, 253, 132,
+      24, 217, 127, 147, 175, 105, 158, 70
+    ]);
+
     it('has a valid address from a known public', (): void => {
       const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') });
 
       expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
       expect(pair.addressRaw).toEqual(hexToU8a('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'));
     });
+
+    it('converts to json', (): void => {
+      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: PUBLICDERIVED, secretKey: SECRETDERIVED });
+      const json = pair.toJson('password');
+
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ethereum'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+      expect(json.address).toEqual(u8aToHex(PUBLICDERIVED));
+    });
+
+    it('has Gerald as test address for Ethereum type parachains', (): void => {
+      const keyringEthereum = createTestPairs({ type: 'ethereum' }, false);
+
+      expect(keyringEthereum.Gerald.address).toEqual('0x6Be02d1d3665660d22FF9624b7BE0551ee1Ac91b');
+    });
   });
 });

packages/keyring/src/pair/index.ts

@@ -1,12 +1,13 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import type { EncryptedJsonEncoding } from '@polkadot/util-crypto/json/types';
 import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import type { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import type { PairInfo } from './types';
 
-import { assert, u8aConcat, u8aToHex } from '@polkadot/util';
-import { blake2AsU8a, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, secp256k1Compress, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, signatureVerify } from '@polkadot/util-crypto';
+import { assert, u8aConcat, u8aEq, u8aToHex, u8aToU8a } 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 { decodePair } from './decode';
 import { encodePair } from './encode';
@@ -47,13 +48,13 @@ const TYPE_ADDRESS = {
   sr25519: (p: Uint8Array) => p
 };
 
-function isEmpty (u8a: Uint8Array): boolean {
-  return u8a.reduce((count, u8) => count + u8, 0) === 0;
-}
-
 // Not 100% correct, since it can be a Uint8Array, but an invalid one - just say "undefined" is anything non-valid
 function isLocked (secretKey?: Uint8Array): secretKey is undefined {
-  return !secretKey || secretKey.length === 0 || isEmpty(secretKey);
+  return !secretKey || secretKey.length === 0 || secretKey.every((b) => b === 0);
+}
+
+function vrfHash (proof: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array {
+  return blake2AsU8a(u8aConcat(context || '', extra || '', proof));
 }
 
 /**
@@ -87,7 +88,7 @@ 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 function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: EncryptedJsonEncoding[]): KeyringPair {
   const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
     const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
 
@@ -145,6 +146,7 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
     // eslint-disable-next-line sort-keys
     decodePkcs8,
     derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
+      assert(type !== 'ethereum', 'Unable to derive on this keypair');
       assert(!isLocked(secretKey), 'Cannot derive on a locked keypair');
 
       const { path } = keyExtractPath(suri);
@@ -152,32 +154,61 @@ export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: P
 
       return createPair({ toSS58, type }, derived, meta, null);
     },
-    encodePkcs8: (passphrase?: string): Uint8Array =>
-      recode(passphrase),
+    encodePkcs8: (passphrase?: string): Uint8Array => {
+      return recode(passphrase);
+    },
     lock: (): void => {
       secretKey = new Uint8Array();
     },
     setMeta: (additional: KeyringPair$Meta): void => {
       meta = { ...meta, ...additional };
     },
-    sign: (message: Uint8Array, options: SignOptions = {}): Uint8Array => {
+    sign: (message: string | Uint8Array, options: SignOptions = {}): Uint8Array => {
       assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
 
       return u8aConcat(
         options.withType
           ? TYPE_PREFIX[type]
           : SIG_TYPE_NONE,
-        TYPE_SIGNATURE[type](message, { publicKey, secretKey })
+        TYPE_SIGNATURE[type](u8aToU8a(message), { publicKey, secretKey })
       );
     },
     toJson: (passphrase?: string): KeyringPair$Json => {
+      // NOTE: For ecdsa and ethereum, the publicKey cannot be extracted from the address. For these
+      // pass the hex-encoded publicKey through to the address portion of the JSON (before decoding)
       const address = ['ecdsa', 'ethereum'].includes(type)
         ? u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
       return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
     },
-    verify: (message: Uint8Array, signature: Uint8Array): boolean =>
-      signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey)).isValid
+    unlock: (passphrase?: string): void => {
+      return decodePkcs8(passphrase);
+    },
+    verify: (message: string | Uint8Array, signature: Uint8Array, _signerPublic: string | Uint8Array): boolean => {
+      return signatureVerify(message, signature, TYPE_ADDRESS[type](u8aToU8a(_signerPublic))).isValid;
+    },
+    vrfSign: (message: string | 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](u8aToU8a(message), { publicKey, secretKey });
+
+      return u8aConcat(vrfHash(proof, context, extra), proof);
+    },
+    vrfVerify: (message: string | Uint8Array, vrfResult: Uint8Array, _signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean => {
+      const signerPublic = TYPE_ADDRESS[type](u8aToU8a(_signerPublic));
+
+      if (type === 'sr25519') {
+        return schnorrkelVrfVerify(message, vrfResult, publicKey, context, extra);
+      }
+
+      const result = signatureVerify(message, u8aConcat(TYPE_PREFIX[type], vrfResult.subarray(32)), signerPublic);
+
+      return result.isValid && u8aEq(vrfResult.subarray(0, 32), vrfHash(vrfResult.subarray(32), context, extra));
+    }
   };
 }

packages/keyring/src/pair/nobody.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
 
 import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';
@@ -52,7 +52,16 @@ export function nobody (): KeyringPair {
       json,
     type: 'ed25519',
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    unlock: (passphrase?: string): void =>
+      undefined,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
+      false,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    vrfSign: (message: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array =>
+      new Uint8Array(96),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    vrfVerify: (message: Uint8Array, vrfResult: Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean =>
       false
   };
 

packages/keyring/src/pair/toJson.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
 
 import { createTestPairs } from '../testingPairs';

packages/keyring/src/pair/toJson.ts

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

packages/keyring/src/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/pair/vrf.spec.ts

@@ -0,0 +1,53 @@
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { KeyringPair } from '../types';
+
+import { u8aToHex } from '@polkadot/util';
+import { cryptoWaitReady, encodeAddress as toSS58, naclKeypairFromSeed, randomAsU8a, schnorrkelKeypairFromSeed, secp256k1KeypairFromSeed } from '@polkadot/util-crypto';
+
+import { createPair } from '.';
+
+const MESSAGE = 'this is a test message';
+const CONTEXT = 'some context';
+
+describe('vrf', (): void => {
+  let ecdsa: KeyringPair;
+  let ed25519: KeyringPair;
+  let sr25519: KeyringPair;
+
+  beforeAll(async (): Promise<void> => {
+    await cryptoWaitReady();
+
+    ecdsa = createPair({ toSS58, type: 'ecdsa' }, secp256k1KeypairFromSeed(randomAsU8a()));
+    ed25519 = createPair({ toSS58, type: 'ed25519' }, naclKeypairFromSeed(randomAsU8a()));
+    sr25519 = createPair({ toSS58, type: 'sr25519' }, schnorrkelKeypairFromSeed(randomAsU8a()));
+  });
+
+  it('has deterministic signature values for ecdsa', (): void => {
+    const sig1 = ecdsa.vrfSign(MESSAGE, CONTEXT);
+    const sig2 = ecdsa.vrfSign(MESSAGE, CONTEXT);
+
+    expect(u8aToHex(sig1)).toEqual(u8aToHex(sig2));
+    expect(ecdsa.vrfVerify(MESSAGE, sig1, ecdsa.publicKey, CONTEXT)).toEqual(true);
+    expect(ecdsa.vrfVerify(MESSAGE, sig2, ecdsa.publicKey, CONTEXT)).toEqual(true);
+  });
+
+  it('has deterministic signature values for ed25519', (): void => {
+    const sig1 = ed25519.vrfSign(MESSAGE, CONTEXT);
+    const sig2 = ed25519.vrfSign(MESSAGE, CONTEXT);
+
+    expect(u8aToHex(sig1)).toEqual(u8aToHex(sig2));
+    expect(ed25519.vrfVerify(MESSAGE, sig1, ed25519.publicKey, CONTEXT)).toEqual(true);
+    expect(ed25519.vrfVerify(MESSAGE, sig2, ed25519.publicKey, CONTEXT)).toEqual(true);
+  });
+
+  it('has deterministic signature values for sr25519', (): void => {
+    const sig1 = sr25519.vrfSign(MESSAGE, CONTEXT);
+    const sig2 = sr25519.vrfSign(MESSAGE, CONTEXT);
+
+    expect(u8aToHex(sig1.slice(0, 32))).toEqual(u8aToHex(sig2.slice(0, 32)));
+    expect(sr25519.vrfVerify(MESSAGE, sig1, sr25519.publicKey, CONTEXT)).toEqual(true);
+    expect(sr25519.vrfVerify(MESSAGE, sig2, sr25519.publicKey, CONTEXT)).toEqual(true);
+  });
+});

packages/keyring/src/pairs.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
 
 import type { KeyringPair, KeyringPairs } from './types';

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,69 @@ 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`
+    }
+  ],
+  ethereum: [
+    {
+      pk: '0x0381351b1b46d2602b0992bb5d5531f9c1696b0812feb2534b6884adc47e2e1d8b',
+      ss: '0x31ea8795EE32D782C8ff41a5C68Dcbf0F5B27f6d',
+      uri: "seed sock milk update focus rotate barely fade car face mechanic mercy/m/44'/60'/0'/0/0"
+    }
+  ],
+  sr25519: [
+    {
+      pk: '0x46ebddef8cd9bb167dc30878d7113b7e168e6f0646beffd77d69d39bad76b47a',
+      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 +81,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,9 +1,10 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import type { KeyringInstance, KeyringOptions } from './types';
 
 import { hexToU8a } from '@polkadot/util';
+import { KeypairType } from '@polkadot/util-crypto/types';
 
 import { createPair } from './pair';
 import Keyring from '.';
@@ -13,53 +14,118 @@ interface PairDef {
   publicKey: Uint8Array;
   seed: string;
   secretKey?: Uint8Array;
-  type?: 'ed25519' | 'sr25519';
+  type: KeypairType
 }
 
 // NOTE This is not great since we have the secretKey here explicitly, but a testing
 // keyring is for testing - what happens is that in most cases the keyring is initialises
 // before anything else. Since the sr25519 crypto is async, this creates problems with
 // adding the keys when only the keyring is used.
-export const PAIRS: PairDef[] = [
+export const PAIRSSR25519: PairDef[] = [
   {
     publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
     secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'),
-    seed: 'Alice'
+    seed: 'Alice',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
     secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'),
-    seed: 'Alice//stash'
+    seed: 'Alice//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
     secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'),
-    seed: 'Bob'
+    seed: 'Bob',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
     secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'),
-    seed: 'Bob//stash'
+    seed: 'Bob//stash',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
     secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'),
-    seed: 'Charlie'
+    seed: 'Charlie',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
     secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'),
-    seed: 'Dave'
+    seed: 'Dave',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
     secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'),
-    seed: 'Eve'
+    seed: 'Eve',
+    type: 'sr25519'
   },
   {
     publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
     secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'),
-    seed: 'Ferdie'
+    seed: 'Ferdie',
+    type: 'sr25519'
+  }
+];
+
+export const PAIRSETHEREUM: PairDef[] = [
+  {
+    name: 'Alith',
+    publicKey: hexToU8a('0x02509540919faacf9ab52146c9aa40db68172d83777250b28e4679176e49ccdd9f'),
+    secretKey: hexToU8a('0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Baltathar',
+    publicKey: hexToU8a('0x033bc19e36ff1673910575b6727a974a9abd80c9a875d41ab3e2648dbfb9e4b518'),
+    secretKey: hexToU8a('0x8075991ce870b93a8870eca0c0f91913d12f47948ca0fd25b49c6fa7cdbeee8b'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Charleth',
+    publicKey: hexToU8a('0x0234637bdc0e89b5d46543bcbf8edff329d2702bc995e27e9af4b1ba009a3c2a5e'),
+    secretKey: hexToU8a('0x0b6e18cafb6ed99687ec547bd28139cafdd2bffe70e6b688025de6b445aa5c5b'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Dorothy',
+    publicKey: hexToU8a('0x02a00d60b2b408c2a14c5d70cdd2c205db8985ef737a7e55ad20ea32cc9e7c417c'),
+    secretKey: hexToU8a('0x39539ab1876910bbf3a223d84a29e28f1cb4e2e456503e7e91ed39b2e7223d68'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Ethan',
+    publicKey: hexToU8a('0x025cdc005b752651cd3f728fb9192182acb3a9c89e19072cbd5b03f3ee1f1b3ffa'),
+    secretKey: hexToU8a('0x7dce9bc8babb68fec1409be38c8e1a52650206a7ed90ff956ae8a6d15eeaaef4'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  {
+    name: 'Faith',
+    publicKey: hexToU8a('0x037964b6c9d546da4646ada28a99e34acaa1d14e7aba861a9055f9bd200c8abf74'),
+    secretKey: hexToU8a('0xb9d2ea9a615f3165812e8d44de0d24da9bbd164b65c4f0573e1ce2c8dbd9c8df'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
+  },
+  // Gerald will be removed when moonbeam is done changing dev addresses (should def be done by end of march 21)
+  {
+    name: 'Gerald',
+    publicKey: new Uint8Array([3, 98, 79, 114, 14, 174, 103, 106,
+      4, 17, 22, 49, 201, 202, 51, 140,
+      17, 208, 245, 168, 14, 228, 34, 16,
+      198, 190, 114, 152, 60, 235, 98, 15,
+      191]),
+    secretKey: hexToU8a('0x99b3c12287537e38c90a9219d4cb074a89a16e9cdb20bf85728ebd97c343e342'),
+    seed: "m/44'/40'/0'/0",
+    type: 'ethereum'
   }
 ];
 
@@ -71,13 +137,13 @@ export const PAIRS: PairDef[] = [
  */
 export function createTestKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
+  const pairs: PairDef[] = (options.type && options.type === 'ethereum') ? PAIRSETHEREUM : PAIRSSR25519;
 
-  PAIRS.forEach(({ name, publicKey, secretKey, seed, type = 'sr25519' }): void => {
+  pairs.forEach(({ name, publicKey, secretKey, seed, type }): void => {
     const meta = {
       isTesting: true,
       name: name || seed.replace('//', '_').toLowerCase()
     };
-
     const pair = !isDerived && !name
       ? keyring.addFromUri(seed, meta, options.type)
       : keyring.addPair(

packages/keyring/src/testingPairs.spec.ts

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

packages/keyring/src/testingPairs.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
 
 import type { KeyringOptions, KeyringPair } from './types';

packages/keyring/src/types.ts

@@ -1,8 +1,9 @@
-// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// Copyright 2017-2021 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Prefix } from '@polkadot/util-crypto/address/types';
-import type { KeypairType } from '@polkadot/util-crypto/types';
+import type { EncryptedJson } from '@polkadot/util-crypto/json/types';
+import type { Keypair, KeypairType } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
   ss58Format?: Prefix;
@@ -11,20 +12,8 @@ export interface KeyringOptions {
 
 export type KeyringPair$Meta = Record<string, unknown>;
 
-export type KeyringPair$JsonVersion = '0' | '1' | '2' | '3';
-
-export type KeyringPair$JsonEncodingTypes = 'none' | 'scrypt' | 'xsalsa20-poly1305';
-
-export interface KeyringPair$JsonEncoding {
-  content: ['pkcs8', KeypairType];
-  type: KeyringPair$JsonEncodingTypes | KeyringPair$JsonEncodingTypes[];
-  version: KeyringPair$JsonVersion;
-}
-
-export interface KeyringPair$Json {
+export interface KeyringPair$Json extends EncryptedJson {
   address: string;
-  encoded: string;
-  encoding: KeyringPair$JsonEncoding;
   meta: KeyringPair$Meta;
 }
 
@@ -40,14 +29,17 @@ export interface KeyringPair {
   readonly publicKey: Uint8Array;
   readonly type: KeypairType;
 
-  decodePkcs8: (passphrase?: string, encoded?: Uint8Array) => void;
-  derive: (suri: string, meta?: KeyringPair$Meta) => KeyringPair;
-  encodePkcs8: (passphrase?: string) => Uint8Array;
-  lock: () => void;
-  setMeta: (meta: KeyringPair$Meta) => void;
-  sign (message: Uint8Array, options?: SignOptions): Uint8Array;
+  decodePkcs8 (passphrase?: string, encoded?: Uint8Array): void;
+  derive (suri: string, meta?: KeyringPair$Meta): KeyringPair;
+  encodePkcs8 (passphrase?: string): Uint8Array;
+  lock (): void;
+  setMeta (meta: KeyringPair$Meta): void;
+  sign (message: string | Uint8Array, options?: SignOptions): Uint8Array;
   toJson (passphrase?: string): KeyringPair$Json;
-  verify (message: Uint8Array, signature: Uint8Array): boolean;
+  unlock (passphrase?: string): void;
+  verify (message: string | Uint8Array, signature: Uint8Array, signerPublic: string | Uint8Array): boolean;
+  vrfSign (message: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;
+  vrfVerify (message: string | Uint8Array, vrfResult: Uint8Array, signerPublic: Uint8Array | string, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;
 }
 
 export interface KeyringPairs {
@@ -70,9 +62,11 @@ export interface KeyringInstance {
   addFromAddress (address: string | Uint8Array, meta?: KeyringPair$Meta, encoded?: Uint8Array | null, type?: KeypairType, ignoreChecksum?: boolean): KeyringPair;
   addFromJson (pair: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
   addFromMnemonic (mnemonic: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+  addFromPair (pair: Keypair, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair
   addFromSeed (seed: Uint8Array, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   addFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   createFromJson (json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
+  createFromPair (pair: Keypair, meta: KeyringPair$Meta, type: KeypairType): KeyringPair
   createFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
   getPair (address: string | Uint8Array): KeyringPair;
   getPairs (): KeyringPair[];

packages/networks/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@polkadot/networks",
-  "version": "5.2.1",
+  "version": "6.0.3",
+  "type": "module",
   "description": "A list of all available Substrate networks and their applicable prefixes",
   "main": "index.js",
-  "module": "index.mjs",
   "sideEffects": false,
   "repository": "github:polkadot-js/common",
   "author": "Jaco Greeff <jacogr@gmail.com>",
@@ -13,10 +13,10 @@
   "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/networks#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.5"
+    "@babel/runtime": "^7.13.9"
   },
   "devDependencies": {
-    "@polkadot/util": "5.2.1",
-    "@polkadot/x-fetch": "5.2.1"
+    "@polkadot/util": "6.0.3",
+    "@polkadot/x-fetch": "6.0.3"
   }
 }

packages/networks/src/crosscheck.spec.ts

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

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,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/networks authors & contributors
+// Copyright 2017-2021 @polkadot/networks authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 // This contains exactly the same information as available in (with some extensions)
@@ -6,7 +6,9 @@
 //
 // Once the above is published as a package, the duplication here can be removed
 
-import type { Network, NetworkFromSubstrate } from './types';
+import type { Network, NetworkFromSubstrate, NetworkFromSubstrateNamed } from './types';
+
+export { packageInfo } from './packageInfo';
 
 // These are known prefixes that are not sorted
 const UNSORTED = [0, 2, 42];
@@ -16,29 +18,32 @@ const UNSORTED = [0, 2, 42];
 // last. This make lookups for the current a simple genesisHash[0]
 // (See Kusama as an example)
 
-const createReserved = (prefix: number, displayName = 'This prefix is reserved.'): NetworkFromSubstrate => ({
+const createReserved = (prefix: number, displayName: string, network: string | null = null): NetworkFromSubstrate => ({
   decimals: null,
   displayName,
-  network: `reserved${prefix}`,
+  isIgnored: true,
+  network,
   prefix,
   standardAccount: null,
   symbols: null,
   website: null
 });
 
-const all: NetworkFromSubstrate[] = [
+export const all: NetworkFromSubstrate[] = [
   {
     decimals: [10],
     displayName: 'Polkadot Relay Chain',
     genesisHash: ['0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3'],
+    hasLedgerSupport: true,
     icon: 'polkadot',
     network: 'polkadot',
     prefix: 0,
+    slip44: 0x00000162,
     standardAccount: '*25519',
     symbols: ['DOT'],
     website: 'https://polkadot.network'
   },
-  createReserved(1),
+  createReserved(1, 'Bare 32-bit Schnorr/Ristretto (S/R 25519) public key.'),
   {
     decimals: [12],
     displayName: 'Kusama Relay Chain',
@@ -47,14 +52,16 @@ 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'
   },
-  createReserved(3),
+  createReserved(3, 'Bare 32-bit Ed25519 public key.'),
   {
     decimals: null,
     displayName: 'Katal Chain',
@@ -130,13 +137,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,
@@ -215,7 +225,7 @@ const all: NetworkFromSubstrate[] = [
   {
     decimals: [6],
     displayName: 'Dock Testnet',
-    genesisHash: ['0x3f0608444cf5d7eec977430483ffef31ff86dfa6bfc6d7114023ee80cc03ea3f'],
+    isIgnored: true, // testnet
     network: 'dock-testnet',
     prefix: 21,
     standardAccount: '*25519',
@@ -226,8 +236,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'
@@ -253,12 +265,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',
@@ -269,6 +301,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: null,
     website: null
   },
+  {
+    decimals: [18],
+    displayName: 'Dhiway CORD Network',
+    network: 'cord',
+    prefix: 29,
+    standardAccount: '*25519',
+    symbols: ['DCU'],
+    website: 'https://dhiway.com/'
+  },
   {
     decimals: [12],
     displayName: 'Phala Network',
@@ -279,13 +320,22 @@ const all: NetworkFromSubstrate[] = [
     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,
@@ -296,6 +346,15 @@ const all: NetworkFromSubstrate[] = [
     symbols: null,
     website: null
   },
+  {
+    decimals: [12],
+    displayName: 'Ares Protocol',
+    network: 'ares',
+    prefix: 34,
+    standardAccount: '*25519',
+    symbols: ['ARES'],
+    website: 'https://www.aresprotocol.com/'
+  },
   {
     decimals: [15],
     displayName: 'Valiu Liquidity Network',
@@ -344,6 +403,7 @@ const all: NetworkFromSubstrate[] = [
   {
     decimals: [18],
     displayName: 'MathChain testnet',
+    isIgnored: true, // testnet
     network: 'mathchain-testnet',
     prefix: 40,
     standardAccount: '*25519',
@@ -368,7 +428,7 @@ const all: NetworkFromSubstrate[] = [
     symbols: null,
     website: 'https://substrate.dev/'
   },
-  createReserved(43),
+  createReserved(43, 'Bare 32-bit ECDSA SECP-256k1 public key.'),
   {
     decimals: [8],
     displayName: 'ChainX',
@@ -378,17 +438,62 @@ const all: NetworkFromSubstrate[] = [
     symbols: ['PCX'],
     website: 'https://chainx.org/'
   },
-  createReserved(46),
-  createReserved(47),
-  createReserved(48, 'All prefixes 48 and higher are reserved and cannot be allocated.')
+  {
+    decimals: [12, 12],
+    displayName: 'UniArts Network',
+    network: 'uniarts',
+    prefix: 45,
+    standardAccount: '*25519',
+    symbols: ['UART', 'UINK'],
+    website: 'https://uniarts.me'
+  },
+  createReserved(46, 'This prefix is reserved.', 'reserved46'),
+  createReserved(47, 'This prefix is reserved.', 'reserved47'),
+  {
+    decimals: [12],
+    displayName: 'Neatcoin Mainnet',
+    network: 'neatcoin',
+    prefix: 48,
+    standardAccount: '*25519',
+    symbols: ['NEAT'],
+    website: 'https://neatcoin.org'
+  },
+  {
+    decimals: [12],
+    displayName: 'HydraDX',
+    network: 'hydradx',
+    prefix: 63,
+    standardAccount: '*25519',
+    symbols: ['HDX'],
+    website: 'https://hydradx.io'
+  },
+  {
+    decimals: [18],
+    displayName: 'AvN Mainnet',
+    network: 'aventus',
+    prefix: 65,
+    standardAccount: '*25519',
+    symbols: ['AVT'],
+    website: 'https://aventus.io'
+  },
+  {
+    decimals: [12],
+    displayName: 'Crust Network',
+    network: 'crust',
+    prefix: 66,
+    standardAccount: '*25519',
+    symbols: ['CRU'],
+    website: 'https://crust.network'
+  }
 ];
 
 // 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')
+export const available: Network[] = all
+  .filter((n): n is NetworkFromSubstrateNamed => !n.isIgnored && !!n.network)
   .map((n) => ({ ...n, genesisHash: n.genesisHash || [], icon: n.icon || 'substrate' }))
   .sort((a, b) =>
     UNSORTED.includes(a.prefix) && UNSORTED.includes(b.prefix)
@@ -401,8 +506,4 @@ const available: Network[] = all
   );
 
 // A filtered list of those chains we have details about (genesisHashes)
-const filtered: Network[] = available.filter((n) => n.genesisHash.length || n.prefix === 42);
-
-export { all, available };
-
-export default filtered;
+export default available.filter((n) => n.genesisHash.length || n.prefix === 42);

packages/networks/src/packageInfo.ts

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

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';
@@ -6,16 +6,23 @@ export type Icon = 'beachball' | 'empty' | 'jdenticon' | 'polkadot' | 'substrate
 export interface NetworkFromSubstrate {
   decimals: number[] | null,
   displayName: string;
-  network: string;
+  network: string | null;
   prefix: number;
   genesisHash?: string[] | null;
+  hasLedgerSupport?: boolean;
   icon?: Icon | null;
+  isIgnored?: boolean;
+  slip44?: number;
   standardAccount: '*25519' | null;
   symbols: string[] | null;
   website: string | null;
 }
 
-export interface Network extends NetworkFromSubstrate {
+export interface NetworkFromSubstrateNamed extends NetworkFromSubstrate {
+  network: string;
+}
+
+export interface Network extends NetworkFromSubstrateNamed {
   genesisHash: string[];
   icon: Icon;
 }

packages/util-crypto/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "5.2.1",
+  "version": "6.0.3",
+  "type": "module",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
-  "module": "index.mjs",
   "sideEffects": [
     "./detectPackage.js",
-    "./detectPackage.mjs"
+    "./detectPackage.cjs"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
   "maintainers": [],
@@ -16,16 +16,17 @@
   "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.5",
-    "@polkadot/networks": "5.2.1",
-    "@polkadot/util": "5.2.1",
-    "@polkadot/wasm-crypto": "^3.1.1",
-    "@polkadot/x-randomvalues": "5.2.1",
+    "@babel/runtime": "^7.13.9",
+    "@polkadot/networks": "6.0.3",
+    "@polkadot/util": "6.0.3",
+    "@polkadot/wasm-crypto": "^4.0.2",
+    "@polkadot/x-randomvalues": "6.0.3",
     "base-x": "^3.0.8",
+    "base64-js": "^1.5.1",
     "blakejs": "^1.1.0",
     "bn.js": "^4.11.9",
     "create-hash": "^1.2.0",
-    "elliptic": "^6.5.3",
+    "elliptic": "^6.5.4",
     "hash.js": "^1.1.7",
     "js-sha3": "^0.8.0",
     "scryptsy": "^2.1.0",
@@ -40,6 +41,6 @@
     "@types/xxhashjs": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "5.2.1"
+    "@polkadot/util": "6.0.3"
   }
 }

packages/util-crypto/src/address/addressToEvm.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 { hexToU8a } from '@polkadot/util';

packages/util-crypto/src/address/addressToEvm.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 { decodeAddress } from './decode';

packages/util-crypto/src/address/check.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 { checkAddress } from '.';

packages/util-crypto/src/address/check.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 type { Prefix } from './types';
@@ -22,13 +22,13 @@ export function checkAddress (address: string, prefix: Prefix): [boolean, string
     return [false, (error as Error).message];
   }
 
-  if (decoded[0] !== prefix) {
-    return [false, `Prefix mismatch, expected ${prefix}, found ${decoded[0]}`];
+  const [isValid,,, ss58Decoded] = checkAddressChecksum(decoded);
+
+  if (ss58Decoded !== prefix) {
+    return [false, `Prefix mismatch, expected ${prefix}, found ${ss58Decoded}`];
   } else if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
     return [false, 'Invalid decoded address length'];
   }
 
-  const [isValid] = checkAddressChecksum(decoded);
-
   return [isValid, isValid ? null : 'Invalid decoded address checksum'];
 }

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

@@ -0,0 +1,31 @@
+// Copyright 2017-2021 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base58Decode } from '../base58/decode';
+import { checkAddressChecksum } from './checksum';
+
+describe('checkAddressChecksum', (): void => {
+  it('correctly extracts the info from a 1-byte-prefix address', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('F3opxRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
+    ).toEqual([true, 33, 1, 2]);
+  });
+
+  it('correctly extracts the info from a 2-byte-prefix address (66)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('cTGShekJ1L1UKFZR9xmv9UTJod7vqjFAPo4sDhXih2c3y1yLS'))
+    ).toEqual([true, 34, 2, 66]);
+  });
+
+  it('correctly extracts the info from a 2-byte-prefix address (255)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k'))
+    ).toEqual([true, 34, 2, 255]);
+  });
+
+  it('correctly extracts the info from a 2-byte-prefix address (ecdsa, from Substrate)', (): void => {
+    expect(
+      checkAddressChecksum(base58Decode('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV'))
+    ).toEqual([true, 35, 2, 200]);
+  });
+});

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

@@ -1,21 +1,25 @@
-// 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';
 
-export function checkAddressChecksum (decoded: Uint8Array): [boolean, number] {
-  const isPublicKey = [35, 36].includes(decoded.length);
+export function checkAddressChecksum (decoded: Uint8Array): [boolean, number, number, number] {
+  const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
+  const ss58Decoded = ss58Length === 1
+    ? decoded[0]
+    : ((decoded[0] & 0b0011_1111) << 2) | (decoded[1] >> 6) | ((decoded[1] & 0b0011_1111) << 8);
 
-  // non-publicKeys has 1 byte checksums, else default to 2
+  // 32/33 bytes public + 2 bytes checksum + prefix
+  const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
   const length = decoded.length - (isPublicKey ? 2 : 1);
 
   // calculate the hash and do the checksum byte checks
   const hash = sshash(decoded.subarray(0, length));
+  const isValid = (decoded[0] & 0b1000_0000) === 0 && ![46, 47].includes(decoded[0]) && (
+    isPublicKey
+      ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
+      : decoded[decoded.length - 1] === hash[0]
+  );
 
-  // see if the hash actually matches
-  const isValid = isPublicKey
-    ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-    : decoded[decoded.length - 1] === hash[0];
-
-  return [isValid, length];
+  return [isValid, length, ss58Length, ss58Decoded];
 }

packages/util-crypto/src/address/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 { hexToU8a, stringToU8a, u8aToHex } from '@polkadot/util';
@@ -51,25 +51,25 @@ describe('decodeAddress', (): void => {
 
   it('decodes a 1-byte accountId (with prefix)', (): void => {
     expect(
-      decodeAddress('PqtB', false, 68)
+      decodeAddress('g4b', false, 2)
     ).toEqual(new Uint8Array([1]));
   });
 
   it('decodes a 2-byte accountId', (): void => {
     expect(
-      decodeAddress('2jpAFn', false, 68)
+      decodeAddress('3xygo', false, 2)
     ).toEqual(new Uint8Array([0, 1]));
   });
 
   it('encodes a 4-byte address', (): void => {
     expect(
-      decodeAddress('as7QnGMf', false, 68)
+      decodeAddress('zswfoZa', false, 2)
     ).toEqual(new Uint8Array([1, 2, 3, 4]));
   });
 
   it('decodes a 8-byte address', (): void => {
     expect(
-      decodeAddress('4q7qY5RBG7Z4wv', false, 68)
+      decodeAddress('848Gh2GcGaZia', false, 2)
     ).toEqual(new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]));
   });
 
@@ -81,6 +81,28 @@ describe('decodeAddress', (): void => {
     );
   });
 
+  it('decodes a 2-byte prefix (65)', (): void => {
+    expect(
+      decodeAddress('cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF')
+    ).toEqual(
+      hexToU8a('0x08e8969768fc14399930d4b8d693f68a2ff6c6a597325d6946095e5e9d9d1b0e')
+    );
+  });
+
+  it('decodes a 2-byte prefix (255)', (): void => {
+    expect(
+      decodeAddress('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k')
+    ).toEqual(
+      decodeAddress('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua')
+    );
+  });
+
+  it('decodes a 2-byte prefix (ecdsa, from Substrate)', (): void => {
+    expect(
+      u8aToHex(decodeAddress('4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV'))
+    ).toEqual('0x035676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba9');
+  });
+
   it.skip('allows invalid prefix (in list)', (): void => {
     expect(
       (): Uint8Array => decodeAddress('6GfvWUvHvU8otbZ7sFhXH4eYeMcKdUkL61P3nFy52efEPVUx')

packages/util-crypto/src/address/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
 
 import type { Prefix } from './types';
@@ -10,32 +10,23 @@ import { base58Decode } from '../base58/decode';
 import { checkAddressChecksum } from './checksum';
 import { defaults } from './defaults';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function decodeAddress (encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
   if (isU8a(encoded) || isHex(encoded)) {
     return u8aToU8a(encoded);
   }
 
-  const wrapError = (message: string) => `Decoding ${encoded as string}: ${message}`;
-  let decoded;
-
   try {
-    decoded = base58Decode(encoded);
+    const decoded = base58Decode(encoded);
+
+    assert(defaults.allowedEncodedLengths.includes(decoded.length), 'Invalid decoded address length');
+
+    const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
+
+    assert(ignoreChecksum || isValid, 'Invalid decoded address checksum');
+    assert([-1, ss58Decoded].includes(ss58Format), `Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
+
+    return decoded.slice(ss58Length, endPos);
   } catch (error) {
-    throw new Error(wrapError((error as Error).message));
+    throw new Error(`Decoding ${encoded as string}: ${(error as Error).message}`);
   }
-
-  // assert(defaults.allowedPrefix.includes(decoded[0] as Prefix), error('Invalid decoded address prefix'));
-  assert(defaults.allowedEncodedLengths.includes(decoded.length), wrapError('Invalid decoded address length'));
-
-  // TODO Unless it is an "use everywhere" prefix, throw an error
-  // if (ss58Format !== -1 && (decoded[0] !== ss58Format)) {
-  //   console.log(`WARN: Expected ${ss58Format}, found ${decoded[0]}`);
-  // }
-
-  const [isValid, endPos] = checkAddressChecksum(decoded);
-
-  assert(ignoreChecksum || isValid, wrapError('Invalid decoded address checksum'));
-
-  return decoded.slice(1, endPos);
 }

packages/util-crypto/src/address/defaults.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 { available } from '@polkadot/networks';
@@ -6,7 +6,7 @@ import { available } from '@polkadot/networks';
 export const defaults = {
   allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
   // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
-  allowedEncodedLengths: [3, 4, 6, 10, 35, 36],
+  allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
   allowedPrefix: available.map(({ prefix }) => prefix),
   prefix: 42
 };

packages/util-crypto/src/address/derive.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 { waitReady } from '@polkadot/wasm-crypto';

packages/util-crypto/src/address/derive.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 type { Prefix } from './types';

packages/util-crypto/src/address/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 { createTestPairs } from '@polkadot/keyring/testingPairs';
@@ -7,6 +7,53 @@ import { encodeAddress } from '.';
 
 const keyring = createTestPairs({ type: 'ed25519' }, false);
 
+const SUBKEY = [
+  {
+    // substrate default
+    address: '5DA4D4GL5iakrn22h5uKoevgvo18Pqj5BcdEUv8etEDPdijA',
+    publicKey: '0x3050f8456519829fe03302da802d22d3233a5f4037b9a3e2bcc403ccfcb2d735',
+    ss58Format: 42
+  },
+  {
+    // aventus
+    address: 'cLtA6nCDyvwKcEHH4QkZDSHMhS9s78BvUJUsKUbUAn1Jc2SCF',
+    publicKey: '0x08e8969768fc14399930d4b8d693f68a2ff6c6a597325d6946095e5e9d9d1b0e',
+    ss58Format: 65
+  },
+  {
+    // crust
+    address: 'cTGShekJ1L1UKFZR9xmv9UTJod7vqjFAPo4sDhXih2c3y1yLS',
+    publicKey: '0x04a047d52fe542484c69bc528990cfeaf3a663dded0638ee1b51cf78bacd1072',
+    ss58Format: 66
+  },
+  {
+    // ecdsa
+    address: '4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV',
+    publicKey: '0x035676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba9',
+    ss58Format: 200
+  },
+  {
+    address: 'yGF4JP7q5AK46d1FPCEm9sYQ4KooSjHMpyVAjLnsCSWVafPnf',
+    publicKey: '0x66cd6cf085627d6c85af1aaf2bd10cf843033e929b4e3b1c2ba8e4aa46fe111b',
+    ss58Format: 255
+  },
+  {
+    address: 'yGDYxQatQwuxqT39Zs4LtcTnpzE12vXb7ZJ6xpdiHv6gTu1hF',
+    publicKey: '0x242fd5a078ac6b7c3c2531e9bcf1314343782aeb58e7bc6880794589e701db55',
+    ss58Format: 255
+  },
+  {
+    address: 'mHm8k9Emsvyfp3piCauSH684iA6NakctF8dySQcX94GDdrJrE',
+    publicKey: '0x44d5a3ac156335ea99d33a83c57c7146c40c8e2260a8a4adf4e7a86256454651',
+    ss58Format: 4242
+  },
+  {
+    address: 'r6Gr4gaMP8TsjhFbqvZhv3YvnasugLiRJpzpRHifsqqG18UXa',
+    publicKey: '0x88f01441682a17b52d6ae12d1a5670cf675fd254897efabaa5069eb3a701ab73',
+    ss58Format: 14269
+  }
+];
+
 describe('encode', (): void => {
   it('encodes an address to a valid value', (): void => {
     expect(
@@ -16,8 +63,8 @@ describe('encode', (): void => {
 
   it('can re-encode an address', (): void => {
     expect(
-      encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 68)
-    ).toEqual('7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv');
+      encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 2)
+    ).toEqual('HNZata7iMYWmk5RvZRTiAsSDhV8366zq2YGb3tLH5Upf74F');
   });
 
   it('can re-encode an address to Polkadot live', (): void => {
@@ -45,33 +92,33 @@ describe('encode', (): void => {
   it('encodes a 1-byte address (with prefix)', (): void => {
     expect(
       encodeAddress(
-        new Uint8Array([1]), 68
+        new Uint8Array([1]), 2
       )
-    ).toEqual('PqtB');
+    ).toEqual('g4b');
   });
 
   it('encodes a 2-byte address', (): void => {
     expect(
       encodeAddress(
-        new Uint8Array([0, 1]), 68
+        new Uint8Array([0, 1]), 2
       )
-    ).toEqual('2jpAFn');
+    ).toEqual('3xygo');
   });
 
   it('encodes a 4-byte address', (): void => {
     expect(
       encodeAddress(
-        new Uint8Array([1, 2, 3, 4]), 68
+        new Uint8Array([1, 2, 3, 4]), 2
       )
-    ).toEqual('as7QnGMf');
+    ).toEqual('zswfoZa');
   });
 
   it('encodes a 8-byte address', (): void => {
     expect(
       encodeAddress(
-        new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]), 68
+        new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]), 2
       )
-    ).toEqual('4q7qY5RBG7Z4wv');
+    ).toEqual('848Gh2GcGaZia');
   });
 
   it('encodes an 33-byte address', (): void => {
@@ -79,4 +126,36 @@ describe('encode', (): void => {
       encodeAddress('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
     ).toEqual('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou');
   });
+
+  it('encodes with 2 byte prefix', (): void => {
+    expect(
+      encodeAddress(keyring.alice.publicKey, 255)
+    ).toEqual('yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k');
+  });
+
+  SUBKEY.forEach(({ address, publicKey, ss58Format }, index): void => {
+    it(`encodes with Subkey equality (${index} - ${ss58Format})`, (): void => {
+      expect(
+        encodeAddress(publicKey, ss58Format)
+      ).toEqual(address);
+    });
+  });
+
+  it('does not encode for > 16,383, < 0', (): void => {
+    expect(
+      () => encodeAddress(keyring.alice.publicKey, -1)
+    ).toThrow(/range ss58Format specified/);
+    expect(
+      () => encodeAddress(keyring.alice.publicKey, 16384)
+    ).toThrow(/range ss58Format specified/);
+  });
+
+  it('does not encode reserved', (): void => {
+    expect(
+      () => encodeAddress(keyring.alice.publicKey, 46)
+    ).toThrow(/range ss58Format specified/);
+    expect(
+      () => encodeAddress(keyring.alice.publicKey, 47)
+    ).toThrow(/range ss58Format specified/);
+  });
 });

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

packages/util-crypto/src/address/encodeDerived.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 { encodeDerivedAddress } from '.';

packages/util-crypto/src/address/encodeDerived.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 type BN from 'bn.js';

packages/util-crypto/src/address/encodeMulti.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 { encodeMultiAddress } from '.';

packages/util-crypto/src/address/encodeMulti.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 type BN from 'bn.js';

packages/util-crypto/src/address/eq.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 { createTestPairs } from '@polkadot/keyring/testingPairs';
@@ -28,7 +28,7 @@ describe('addressEq', (): void => {
     expect(
       addressEq(
         '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
-        '7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv'
+        '15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5'
       )
     ).toEqual(true);
   });

packages/util-crypto/src/address/eq.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 { u8aEq } from '@polkadot/util';

packages/util-crypto/src/address/evmToAddress.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 { evmToAddress } from '.';

packages/util-crypto/src/address/evmToAddress.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 type { HashType } from '../secp256k1/types';

packages/util-crypto/src/address/index.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
 
 export { addressToEvm } from './addressToEvm';

packages/util-crypto/src/address/keyDerived.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 { createKeyDerived } from '.';

packages/util-crypto/src/address/keyDerived.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 type BN from 'bn.js';

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,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 type BN from 'bn.js';

packages/util-crypto/src/address/setSS58Format.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 { encodeAddress, setSS58Format } from '.';
 
 describe('setSS58Format', (): void => {
   beforeEach((): void => {
-    setSS58Format(68);
+    setSS58Format(2);
   });
 
   it('sets and allows encoding using', (): void => {
@@ -13,6 +13,6 @@ describe('setSS58Format', (): void => {
       encodeAddress(
         new Uint8Array([1])
       )
-    ).toEqual('PqtB');
+    ).toEqual('g4b');
   });
 });

packages/util-crypto/src/address/setSS58Format.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 type { Prefix } from './types';

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,4 +1,4 @@
-// Copyright 2017-2020 @polkadot/util authors & contributors
+// Copyright 2017-2021 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 import type { Prefix } from './types';

packages/util-crypto/src/address/sshash.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 { stringToU8a, u8aConcat } from '@polkadot/util';

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,11 +1,6 @@
-// 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
-const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
-const BITS_PER_CHAR = 5;
-
-export {
-  BASE32_ALPHABET,
-  BITS_PER_CHAR
-};
+export const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+export const BITS_PER_CHAR = 5;

packages/util-crypto/src/base32/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

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

packages/util-crypto/src/base32/index.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
 
 /**

packages/util-crypto/src/base32/is.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 './validate';

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,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 { validateChars } from '../base58/validate';