[CI Skip] release/stable 2.13.1

skip-checks: true

.123trigger

@@ -1 +1,2 @@
-4
+5
+2.6.22.12.2

.eslintignore

@@ -1,3 +1,4 @@
+.eslintrc.js
 **/build/*
 **/coverage/*
 **/node_modules/*

.github/workflows/pr-any.yml

@@ -2,72 +2,17 @@ name: PR
 on: [pull_request]
 
 jobs:
-  lint:
-    name: Linting
-    runs-on: ubuntu-latest
+  pr:
     strategy:
       matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: lint
-      run: |
-        yarn install --frozen-lockfile
-        yarn lint
-
-  test:
-    name: Testing
+        step: ['lint', 'test', 'build', 'docs']
+    name: ${{ matrix.step }}
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
     - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: test
+    - name: ${{ matrix.step }}
       env:
         CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
       run: |
-        yarn install --frozen-lockfile
-        yarn test
-
-  build_code:
-    name: Build Code
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: build
-      run: |
-        yarn install --frozen-lockfile
-        yarn build
-
-  build_docs:
-    name: Build Docs
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: build
-      run: |
-        yarn install --frozen-lockfile
-        yarn docs
+        yarn install --immutable | grep -v 'YN0013'
+        yarn ${{ matrix.step }}

.github/workflows/push-master.yml

@@ -5,62 +5,30 @@ on:
       - master
 
 jobs:
-  build_code:
-    name: Build Code
-    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
-    runs-on: ubuntu-latest
+  master:
     strategy:
       matrix:
-        node-version: [12.x]
+        step: ['build:release', 'docs:release']
+    name: ${{ matrix.step }}
+    if: "! startsWith(github.event.head_commit.message, '[CI Skip]') && github.repository == 'polkadot-js/common'"
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v1
       with:
         token: ${{ secrets.GH_PAT }}
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: build
+    - name: ${{ matrix.step }}
       env:
         CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
+        GH_PAGES_SRC: build-docs
         GH_PAT: ${{ secrets.GH_PAT }}
-        GH_TOKEN: ${{ secrets.GH_PAT }}
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GH_RELEASE_GITHUB_API_TOKEN: ${{ secrets.GH_PAT }}
         NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
       run: |
-        yarn install --frozen-lockfile
-        yarn polkadot-ci-ghact-build
-
-  build_docs:
-    name: Build Docs
-    if: "! contains(github.event.head_commit.message, '[CI Skip]')"
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
-    steps:
-    - uses: actions/checkout@v1
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v1
-      with:
-        node-version: ${{ matrix.node-version }}
-    - name: build
-      env:
-        GH_PAT: ${{ secrets.GH_PAT }}
-        GH_TOKEN: ${{ secrets.GH_PAT }}
-        GH_PAGES_SRC: build-docs
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        yarn install --frozen-lockfile
-        yarn polkadot-ci-ghact-docs
+        yarn install --immutable | grep -v 'YN0013'
+        yarn ${{ matrix.step }}
 
   dummy:
-    name: Dummy
-    if: "contains(github.event.head_commit.message, '[CI Skip]')"
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: [12.x]
     steps:
     - name: dummy
       run: |

.gitignore

@@ -12,10 +12,10 @@ tmp/
 .env.test.local
 .env.production.local
 .npmrc
+.yarn/*
+!.yarn/releases
+!.yarn/plugins
 .pnp.*
-.yarn/cache
-.yarn/unplugged
-.yarn/build-state.yml
 cc-test-reporter
 lerna-debug.log*
 npm-debug.log*

.yarnrc.yml

@@ -0,0 +1,11 @@
+enableImmutableInstalls: false
+
+enableProgressBars: false
+
+nodeLinker: node-modules
+
+plugins:
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.js
+    spec: "@yarnpkg/plugin-interactive-tools"
+
+yarnPath: .yarn/releases/yarn-rc.js

CHANGELOG.md

@@ -1,19 +1,92 @@
-# 2.3.1 Feb 15, 2020
+# CHANGELOG
+
+## 2.13.1 Jun 8, 2020
+
+- Fix JS blake2 fallback (non-wasm) to correctly deal with hex inputs
+- Align `bnToHex` signature with `bnToU8a` (with old/new style)
+- Allow `bnTo{Hex,U8a}` to take any value with `.toBn()` signatures
+
+## 2.12.2 Jun 1, 2020
+
+- Fix `isFunction` signature to assert `Function`
+
+## 2.12.1 Jun 1, 2020
+
+- **Important** Removed `mnemonicToSeed`, it is only for bip39, use `mnemonicToMiniSecret` for the Substrate variant
+- Added `u8aEq` to compare two Uint8Array or hex values for an exact match
+- Added `addressEq` to compare two addresses (ss58, Uint8array or hex) for an exact match
+- Throw error on `{nacl,schnorrkel}Verify` on invalid input lengths
+- Performance optimizations in `u8aToHex` & `u8aConcat`
+
+## 2.11.1 May 26, 2020
+
+- Internal cleanups on typings
+- Support for latest TypeScript, eslint & typescript-eslint
+
+## 2.10.1 May 14, 2020
+
+- Add Kulupu ss58 prefix as an allowed value (Thanks to https://github.com/sorpaas)
+- Make the `TextEncoder` polyfill handle non-compliant Buffer implementations (newer versions of Jest)
+- `DeriveJunction` now also allows for BigInt values (aligning with number types elsewhere)
+- Small code-flow optimizations
+
+## 2.9.1 Apr 30, 2020
+
+- Add support for ECDSA keypairs (Thanks to https://github.com/akru)
+- Added `createKeyMulti` & `createKeySub` to create utility sub & multi keys
+- Added `u8aSorted` to sort `Uint8Arrays`
+- Added `sortAddresses` to sort addresses based on their internal representation
+
+## 2.8.1 Apr 9, 2020
+
+- Keypair will now throw an error when attempting to sign/derive using a locked pair (Thanks to https://github.com/h4x3rotab)
+- Cleanup `isDevelopment` regex to cater for chains such as `Westend Development`
+
+## 2.7.1 Mar 31, 2020
+
+- Add `bnSqrt` to calculate the integer sqrt via Newton iteration
+- Allow for optional wasm-crypto, specifically via `@polkadot/util-crypto/noWasm`
+- Misc. CI infrastructure cleanups
+
+## 2.6.1 Feb 29, 2020
+
+- **Breaking change** Following on the 2.0 release, `@polkadot/wasm` was updated to 1.1+. sr25510 now only verifies 0.8+ signatures, closing the loop on dropping Substrate 1.x-era support
+- Add `signatureVerify (message: Uint8Array | string, signature: Uint8Array | string, addressOrPublicKey: Uint8Array | string): VerifyResult` to verify any signature, regardless of type. Returns validity & detected crypto type.
+- Add `cryptoIsReady (): boolean` function to check status of initialization
+- Add `addressCheckChecksum (decoded: Uint8Array)` as an helper to extract and verify the ss58 checksum
+- Swap to yarn 2, allow use in yarn 2 projects
+
+## 2.5.1 Feb 22, 2020
+
+- **Breaking change** (TypeScript only) The `*.d.ts` files now contain TypeScript 3.8 features, `#private`, which is not usable in older versions
+- Add `isBigInt(value)` to allow `BigInt` checks. Also add support in `bnToBn` as well as number conversion utils
+- Add `isChildClass(Parent, Child?)` to check if a class extends the parent, asserting Child is Parent
+- (internal) Use `#<field>` instead of `private _<field>` for private class variables
+
+## 2.4.1 Feb 18, 2020
+
+- Ensure that `formatBalance` does not apply unit overrides apply when no SI is applicable
+- Adjust `formatBalance(<balance>, <options>)` to take expanded `withUnit: string | boolean` option where string is an actual unit, e.g. `KSM`
+- The `decimals` option to `formatBalance` should now be passed as part of the `options` (previous last-param deprecated)
+- The `.setSS58Format` on keyring will now just operate on pairs created on the keyring, not globally. The global `setSS58Format` in `@polkadot/util-crypto` will be deprecated.
+- The deprecated `addressPrefix` option to keyring has been belatedly removed (Use `ss58Format` rather)
+
+## 2.3.1 Feb 15, 2020
 
 - Remove dependency on moment.js with `formatDate` function (Thanks to https://github.com/AndreasGassmann)
 - Move TypeScript `@types/*` to dev deps (Thanks to https://github.com/AndreasGassmann)
 - Update to `@polkadot/wasm-crypto` 1.0
-- Cleanup dependencies to pave the way for using yarnpkg 2 (Explicit instead of implicit)
+- Cleanup dependencies to pave the way for using yarn 2 (Explicit instead of implicit)
 
-# 2.2.1 Feb 06, 2020
+## 2.2.1 Feb 06, 2020
 
 - Add resolver for jest requires (tests from src)
 
-# 2.1.1 Feb 04, 2020
+## 2.1.1 Feb 04, 2020
 
 - Update `detectPackage(<package.json>, __dirname?)` with calling folder
 
-# 2.0.1 Jan 30, 2020
+## 2.0.1 Jan 30, 2020
 
 - Update w3f/schnorrkel to 0.8.5 (Full Substrate 2.x support, no 1.x support)
 - Remove Alice session (ed2551) account from testing keyring (not applicable to Substrate 2.x)
@@ -21,27 +94,27 @@
 - Renamed `assertSingletonPackage` to `detectPackage` with inclusion of version listing
 - Swap to elliptic library for secp2561 recovery (No node bindings)
 
-# 1.8.1 Jan 09, 2020
+## 1.8.1 Jan 09, 2020
 
 - Add cross-client encryption/decryption support (Thanks to https://github.com/hskang9)
 
-# 1.7.1 Nov 27, 2019
+## 1.7.1 Nov 27, 2019
 
 - `formatBalance` signature now allows to force unit displays
 - Keypair now allows for derive on a pair, with `pair.derive(...)`
 - `assert` now acts like a real asserts, with no return - signature adapted for new TS 3.7
 
-# 1.6.1 Oct 24, 2019
+## 1.6.1 Oct 24, 2019
 
 - `pair.sign(message)` now takes an optional second `options?: SignOptions` parameter, where `SignOptions` is currently defined as `{ withType: boolean }`. Here `withType` instructs the signing to prepend the type of signature (ed2551, sr25519 or ecdsa). This is used for the new Polkadot/Substrate MultiSignature format.
 
-# 1.5.1 Sep 25, 2019
+## 1.5.1 Sep 25, 2019
 
 - Fix typings on the Keyring-exposed encode & decodeAddress
 - Allow ss58Format = 0 as a valid value
 - Loosen type definitions for allowed ss58format values (still checked against allowed array)
 
-# 1.4.1 Sep 12, 2019
+## 1.4.1 Sep 12, 2019
 
 - **Breaking change** To set the `ss58Format`, you should now use `setSS58Format` as opposed to the old `setAddressPrefix`
 - Renamed `keyring.setAddressPrefix` to `keyring.setSS58Format`
@@ -49,25 +122,25 @@
 - Added `stringToHex` and `hexToString` conversion utilities to `@polkadot/util`
 - Swap to [Babel 7.6.0](https://babeljs.io/) for all compilation, for latest improvements in code generation
 
-# 1.3.1 Sep 10, 2019
+## 1.3.1 Sep 10, 2019
 
 - Remove the `ExtError` class, always prefer the standard JS `Error` object for errors. This would bre a breaking change for any applications using `ExtError`
 
-# 1.2.1 Sep 09, 2019
+## 1.2.1 Sep 09, 2019
 
 - Keyring `addFromAddress` can now be used to store external accounts, for example those provided by external signers
 - Maintainability updates
 
-# 1.1.1 Aug 09, 2019
+## 1.1.1 Aug 09, 2019
 
 - `assertSingletonPackage` now warns via console.warn, but does not throw. This does allow the info to come accross while still allowing the app developers using multiple libraries time to fix.
 
-# 1.0.1 Aug 02, 2019
+## 1.0.1 Aug 02, 2019
 
 - `formatBalance` now allows for `Compact` inputs
 - `formaBalance` now allows correct formatting of very large decimals
 
-# 0.94.1 Jul 20, 2019
+### 0.94.1 Jul 20, 2019
 
 - Add `checkAddress(address, prefix)` to `@polkadot/util-crypto` that validates an ss-58 address
 - Add support for the Kusama network (as a valid checked prefix)
@@ -75,7 +148,7 @@
 - The ed25519 key for Alice (representing the session), now appears in the test keyrings
 - Fix missing dependencies for keyring (after address moves in 0.93.1)
 
-# 0.93.1 Jun 14, 2019
+### 0.93.1 Jun 14, 2019
 
 - Breaking: External pair interface for keyring has been changed. Instead of
   - `getMeta` use the `meta` getter, i.e. `console.log(pair.meta.name)`
@@ -83,133 +156,133 @@
   - `publicKey` use the `publicKey` getter, i.e. `console.log(pair.publicKey)`
 - `Move decodeAddress`, `encodeAddress` & `setAddressPrefix` functions into `@polkadot/util-crypto` from `@polkadot/keyring`. External interfaces should not be affected at this point since it is also (still) exported and exposed on keyring
 
-# 0.92.1 Jun 04, 2019
+### 0.92.1 Jun 04, 2019
 
 - Only allow integer input values into `formatBalance`
 - Allow `formatBalance`, `formatDecimal` & `formatNumber` to cater for negative numbers
 - Add 'Bob//stash' to testing keyring, joining the existing 'Alice//stash'
 
-# 0.91.1 May 22, 2019
+### 0.91.1 May 22, 2019
 
 - ed25519/sr25519 sign & verify functions can now take the message input as Uint8Array/string/hex and verify allows for the signature/publicKey to be specified as Uint8Array/hex
 - Update `@polkadot/wasm` to include a maintenance bump for the `w3f/schnorrkel` libraries
 
-# 0.90.1 May 08, 2019
+### 0.90.1 May 08, 2019
 
 - Moving towards 1.0
 - Added bnMin & bnMax functions
 
-# 0.76.1 Apr 03, 2019
+### 0.76.1 Apr 03, 2019
 
 - Fix `addFromMnemonic` to generate using new-style derivation.
 - Pull in `formatBalance`, `formatDecimal`, `formatElapsed`, `formatNumber`, `calcSi`, `findSi` & `isTestChain` utility functions from the originals in `@polkadot/ui-util`
 - Swap out `wasm-schnorrkel` & `wasm-ed25519` for combined version with `wasm-crypto`
 - Swap DB interfaces to optional LRU, removing `transactionAsync` (client-only changes)
 
-# 0.75.1 Mar 29, 2019
+### 0.75.1 Mar 29, 2019
 
 - Start journey to 1.0
 
-# 0.42.1 Mar 28, 2019
+### 0.42.1 Mar 28, 2019
 
 - Add `assertSingletonPackage` to util
 - Ensure that only a single keyring instance is loaded (uses above)
 
-# 0.41.1 Mar 25, 2019
+### 0.41.1 Mar 25, 2019
 
 - Extensions to the client-specific database interfaces (non-breaking for API and util users)
 
-# 0.40.1 Mar 23, 2019
+### 0.40.1 Mar 23, 2019
 
 - Add additional derivation path extraction mechanisms to util-crypto
 - Add createFromUri function to keypair (creates keypair, does not add it)
 - Allow all crypto hashing & ed25519 to use WASM (as available, JS fallbacks)
 
-# 0.39.1 Mar 20, 2019
+### 0.39.1 Mar 20, 2019
 
 - Pull in bip39 generation functions from `@poladkot/wasm-crypto` with a fallback to the pure JS versions
 
-# 0.38.1 Mar 18, 2019
+### 0.38.1 Mar 18, 2019
 
 - Align with current substrate master for sr25519 keys and hard/soft derivation
 - Swap default dev keys to derived (sr25519)
 
-# 0.37.1 Mar 14, 2019
+### 0.37.1 Mar 14, 2019
 
 - Swap to publishing -beta.x on merge (non-breaking testing)
 
-# 0.36.1 Mar 13, 2019
+### 0.36.1 Mar 13, 2019
 
 - Add `fromUri` to keyring along with hard & soft key derivation.
 
-# 0.35.1 Mar 04, 2019
+### 0.35.1 Mar 04, 2019
 
 - Remove NodeJs-only `syncify` function, not exported by the package (with binary dependency for Node)
 
-# 0.34.1 Feb 13, 2019
+### 0.34.1 Feb 13, 2019
 
 - Keyring now allows for ed25519 and sr25519 instances. Upon creation, you need to pass the `ed25519`or `sr25519` string to denote the type, i.e. `new Keyring({ type: 'sr25519' })`
 
-# 0.33.1 Nov 22, 2018
+### 0.33.1 Nov 22, 2018
 
-# 0.32.1 Oct 18, 2018
+### 0.32.1 Oct 18, 2018
 
-# 0.31.1 Oct 12, 2018
+### 0.31.1 Oct 12, 2018
 
-# 0.30.1 Sep 11, 2018
+### 0.30.1 Sep 11, 2018
 
-# 0.29.1 Sep 01, 2018
+### 0.29.1 Sep 01, 2018
 
-# 0.28.1 Aug 11, 2018
+### 0.28.1 Aug 11, 2018
 
-# 0.27.1 Aug 06, 2018
+### 0.27.1 Aug 06, 2018
 
-# 0.26.1 Jun 27, 2018
+### 0.26.1 Jun 27, 2018
 
-# 0.25.1 Jun 26, 2018
+### 0.25.1 Jun 26, 2018
 
-# 0.24.1 Jun 22, 2018
+### 0.24.1 Jun 22, 2018
 
-# 0.23.1 Jun 21, 2018
+### 0.23.1 Jun 21, 2018
 
-# 0.22.1 May 24, 2018
+### 0.22.1 May 24, 2018
 
-# 0.21.1 May 17, 2018
+### 0.21.1 May 17, 2018
 
-# 0.20.1 May 16, 2018
+### 0.20.1 May 16, 2018
 
-# 0.19.1 Apr 19, 2018
+### 0.19.1 Apr 19, 2018
 
-# 0.18.1 Mar 20, 2018
+### 0.18.1 Mar 20, 2018
 
-# 0.17.1 Mar0 8, 2018
+### 0.17.1 Mar0 8, 2018
 
-# 0.16.1 Feb 23, 2018
+### 0.16.1 Feb 23, 2018
 
-# 0.15.1 Feb 15, 2018
+### 0.15.1 Feb 15, 2018
 
-# 0.14.1 Feb 07, 2018
+### 0.14.1 Feb 07, 2018
 
-# 0.13.1 Jan 25, 2018
+### 0.13.1 Jan 25, 2018
 
-# 0.12.1 Jan 11, 2018
+### 0.12.1 Jan 11, 2018
 
-# 0.11.1 Dec 30, 2017
+### 0.11.1 Dec 30, 2017
 
-# 0.10.1 Dec 17, 2017
+### 0.10.1 Dec 17, 2017
 
-# 0.9.1 Dec 14, 2017
+### 0.9.1 Dec 14, 2017
 
-# 0.8.1 Dec 12, 2017
+### 0.8.1 Dec 12, 2017
 
-# 0.7.1 Dec 11, 2017
+### 0.7.1 Dec 11, 2017
 
-# 0.6.1 Nov 30, 2017
+### 0.6.1 Nov 30, 2017
 
-# 0.5.1 Nov 20, 2017
+### 0.5.1 Nov 20, 2017
 
-# 0.4.1 Nov 19, 2017
+### 0.4.1 Nov 19, 2017
 
-# 0.3.1 Nov 19, 2017
+### 0.3.1 Nov 19, 2017
 
-# 0.2.1 Nov 18, 2017
+### 0.2.1 Nov 18, 2017

babel.config.js

@@ -1 +1,5 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
 module.exports = require('@polkadot/dev/config/babel');

docs/examples/keyring/01_create_account/index.js

@@ -1,6 +1,7 @@
+/* eslint-disable header/header */
 /* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 // Import Keyring class and utility function
 const Keyring = require('@polkadot/keyring').default;
 const stringToU8a = require('@polkadot/util/string/toU8a').default;

docs/examples/keyring/02_load_accounts/index.js

@@ -1,6 +1,7 @@
+/* eslint-disable header/header */
 /* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 // Import Keyring class and utility function
 const Keyring = require('@polkadot/keyring').default;
 const stringToU8a = require('@polkadot/util/string/toU8a').default;

docs/examples/keyring/03_validate_address/index.js

@@ -1,12 +1,18 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { encodeAddress, decodeAddress } = require('@polkadot/keyring');
-const { isHex, hexToU8a } = require('@polkadot/util');
+/* eslint-disable header/header */
+
+const { decodeAddress, encodeAddress } = require('@polkadot/keyring');
+const { hexToU8a, isHex } = require('@polkadot/util');
 
 const address = '5GrpknVvGGrGH3EFuURXeMrWHvbpj3VfER1oX5jFtuGbfzCE';
 
 const isValidAddressPolkadotAddress = () => {
   try {
-    encodeAddress(isHex(address) ? hexToU8a(address) : decodeAddress(address));
+    encodeAddress(
+      isHex(address)
+        ? hexToU8a(address)
+        : decodeAddress(address)
+    );
+
     return true;
   } catch (error) {
     return false;

docs/examples/util-crypto/01_encrypt_decrypt_message_nacl/index.js

@@ -1,7 +1,8 @@
+/* eslint-disable header/header */
 /* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable @typescript-eslint/no-var-requires */
-const { naclEncrypt, naclDecrypt } = require('@polkadot/util-crypto');
+
+const { naclDecrypt, naclEncrypt } = require('@polkadot/util-crypto');
 
 async function main () {
   const secret = new Uint8Array(32);

docs/examples/util-crypto/02_sign_verify_message_nacl/index.js

@@ -1,6 +1,7 @@
+/* eslint-disable header/header */
 /* eslint-disable @typescript-eslint/require-await */
 /* eslint-disable @typescript-eslint/unbound-method */
-/* eslint-disable @typescript-eslint/no-var-requires */
+
 const { stringToU8a, u8aToHex } = require('@polkadot/util');
 const { naclEncrypt, naclKeypairFromSeed, naclSign, naclVerify, randomAsU8a } = require('@polkadot/util-crypto');
 
@@ -9,7 +10,7 @@ async function main () {
   const seedAlice = 'Alice'.padEnd(32, ' ');
 
   // Generate new public/secret keypair for Alice from the supplied seed
-  const { secretKey, publicKey } = naclKeypairFromSeed(stringToU8a(seedAlice));
+  const { publicKey, secretKey } = naclKeypairFromSeed(stringToU8a(seedAlice));
 
   // Encrypt message. Create Uint8Array's filled with random bytes of specified length
   const secret = randomAsU8a(32);

docs/examples/util-crypto/03_mnemonic_generate_validate_bip39/index.js

@@ -1,6 +1,8 @@
+/* eslint-disable header/header */
 /* eslint-disable @typescript-eslint/unbound-method */
 /* eslint-disable @typescript-eslint/require-await */
-/* eslint-disable @typescript-eslint/no-var-requires,@typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
 const { mnemonicGenerate, mnemonicToSeed, mnemonicValidate, naclKeypairFromSeed } = require('@polkadot/util-crypto');
 
 async function main () {
@@ -19,7 +21,7 @@ async function main () {
   const seedAlice = mnemonicToSeed(mnemonicAlice);
 
   // Generate new public/secret keypair for Alice from the supplied seed
-  const { secretKey, publicKey } = naclKeypairFromSeed(seedAlice);
+  const { publicKey, secretKey } = naclKeypairFromSeed(seedAlice);
 
   // Encrypt, Sign and Validate the message. See Example 'Sign & Verify Message'
 }

docs/examples/util-crypto/04_generate_multisig_address/README.md

@@ -0,0 +1,5 @@
+# Generate a Multisig Account
+
+Substrate provides a multisig dispatch function in its 
+[Utility pallet](https://crates.parity.io/pallet_utility/index.html). This example generates the 
+address that would correspond to a set of addresses and threshold.

docs/examples/util-crypto/04_generate_multisig_address/index.js

@@ -0,0 +1,40 @@
+/* eslint-disable header/header */
+import { createKeyMulti, encodeAddress, sortAddresses } from '@polkadot/util-crypto';
+
+const SS58Prefix = 0;
+
+// Input the addresses that will make up the multisig account.
+const addresses = [
+  '1nUC7afqmo7zwRFWxDjrUQu9skk6fk99pafb4SiyGSRc8z3',
+  '1ZX2XntfLEHrBPy73DpfQp9rG7pbLyvrFjEpi7mNKQgyga5',
+  '14b1kB7CrqzRUeMsKc26FJ73f8FCpxAX6sNieu9gfYSfJuoL'
+];
+
+// The number of accounts that must approve. Must be greater than 0 and less than
+// or equal to the total number of addresses.
+const threshold = 2;
+
+// The address (as index in `addresses`) that will submit a transaction.
+const index = 0;
+
+function main () {
+  // Address as a byte array.
+  const multiAddress = createKeyMulti(addresses, threshold);
+
+  // Convert byte array to SS58 encoding.
+  const Ss58Address = encodeAddress(multiAddress, SS58Prefix);
+
+  console.log(`\nMultisig Address: ${Ss58Address}`);
+
+  // Take addresses and remove the sender.
+  const otherSignatories = addresses.filter((who) => who !== addresses[index]);
+
+  // Sort them by public key.
+  const otherSignatoriesSorted = sortAddresses(otherSignatories, SS58Prefix);
+
+  console.log(`\nOther Signatories: ${otherSignatoriesSorted}\n`);
+
+  process.exit();
+}
+
+main();

docs/examples/util-crypto/04_generate_multisig_address/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "04_generate_multisig_address",
+  "version": "0.1.0",
+  "description": "Example showing how to generate a multisig address for Substrate's Utility pallet",
+  "main": "index.js",
+  "author": "joepetrowski",
+  "license": "MIT",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@polkadot/util-crypto": "^2.9.0-beta.1"
+  }
+}

jest.config.js

@@ -1,10 +1,14 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
 const config = require('@polkadot/dev/config/jest');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
     '@polkadot/keyring(.*)$': '<rootDir>/packages/keyring/src/$1',
     '@polkadot/util-(crypto)(.*)$': '<rootDir>/packages/util-$1/src/$2',
+    // eslint-disable-next-line sort-keys
     '@polkadot/util(.*)$': '<rootDir>/packages/util/src/$1'
   },
   modulePathIgnorePatterns: [

jest.resolver.js

@@ -1,7 +1,6 @@
 // Copyright 2017-2020 @polkadot/util authors & contributors
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
-/* eslint-disable @typescript-eslint/no-var-requires */
 
 const path = require('path');
 

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "2.3.1"
+  "version": "2.13.1"
 }

package.json

@@ -1,18 +1,19 @@
 {
-  "version": "2.3.1",
+  "repository": "https://github.com/polkadot-js/common",
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "license": "Apache-2",
   "private": true,
-  "engines": {
-    "yarn": "^1.10.1"
-  },
   "workspaces": [
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^3.7.5"
+    "babel-core": "^7.0.0-bridge.0"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
+    "build:release": "polkadot-ci-ghact-build",
     "docs": "polkadot-dev-build-docs",
+    "docs:release": "polkadot-ci-ghact-docs",
     "lint": "polkadot-dev-run-lint",
     "clean": "polkadot-dev-clean-build",
     "postinstall": "polkadot-dev-yarn-only",
@@ -20,8 +21,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.8.4",
-    "@polkadot/dev": "^0.40.16",
-    "@polkadot/ts": "^0.2.3"
-  }
+    "@babel/core": "^7.10.2",
+    "@polkadot/dev": "^0.55.8",
+    "@polkadot/ts": "^0.3.26",
+    "@types/jest": "^25.2.3"
+  },
+  "version": "2.13.1"
 }

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "2.3.1",
+  "version": "2.13.1",
   "description": "Keyring management",
   "main": "index.js",
   "publishConfig": {
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.8.4",
-    "@polkadot/util": "^2.3.1",
-    "@polkadot/util-crypto": "^2.3.1"
+    "@babel/runtime": "^7.10.2",
+    "@polkadot/util": "2.13.1",
+    "@polkadot/util-crypto": "2.13.1"
   }
 }

packages/keyring/src/index.spec.ts

@@ -3,7 +3,7 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import { hexToU8a, stringToU8a } from '@polkadot/util';
-import { cryptoWaitReady, setSS58Format } from '@polkadot/util-crypto';
+import { cryptoWaitReady, setSS58Format, encodeAddress } from '@polkadot/util-crypto';
 
 import Keyring from '.';
 
@@ -17,57 +17,55 @@ describe('keypair', (): void => {
     const publicKeyTwo = new Uint8Array([215, 90, 152, 1, 130, 177, 10, 183, 213, 75, 254, 211, 201, 100, 7, 58, 14, 225, 114, 243, 218, 166, 35, 37, 175, 2, 26, 104, 247, 7, 81, 26]);
     const seedOne = stringToU8a('12345678901234567890123456789012');
     const seedTwo = hexToU8a('0x9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60');
-    let keypair: Keyring;
+    let keyring: Keyring;
 
     beforeEach((): void => {
-      keypair = new Keyring({ type: 'ed25519' });
+      keyring = new Keyring({ ss58Format: 42, type: 'ed25519' });
 
-      keypair.addFromSeed(seedOne, {});
-    });
-
-    afterEach((): void => {
-      setSS58Format(42);
+      keyring.addFromSeed(seedOne, {});
     });
 
     it('adds the pair', (): void => {
       expect(
-        keypair.addFromSeed(seedTwo, {}).publicKey
+        keyring.addFromSeed(seedTwo, {}).publicKey
       ).toEqual(publicKeyTwo);
     });
 
     it('creates a ed25519 pair via mnemonicToSeed', (): void => {
       expect(
-        keypair.addFromUri(
+        keyring.addFromUri(
           'seed sock milk update focus rotate barely fade car face mechanic mercy'
         ).address
       ).toEqual('5DkQP32jP4DVJLWWBRBoZF2tpWjqFrcrTBo6H5NcSk7MxKCC');
     });
 
-    it('adds from a mnemonic', (): void => {
-      setSS58Format(68);
+    it('adds from a mnemonic, with correct ss58', (): void => {
+      setSS58Format(20); // this would not be used
+      keyring.setSS58Format(68); // this would be used
 
-      expect(
-        keypair.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {}).address
-      ).toEqual('7sPsxWPE5DzAyPT3VuoJYw5NTGscx9QYN9oddQx4kALKC3hH');
+      const pair = keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {});
+
+      expect(pair.address).toEqual('7sPsxWPE5DzAyPT3VuoJYw5NTGscx9QYN9oddQx4kALKC3hH');
+      expect(encodeAddress(pair.publicKey)).toEqual('35cDYtPsdG1HUa2n2MaARgJyRz1WKMBZK1DL6c5cX7nugQh1');
     });
 
     it('allows publicKeys retrieval', (): void => {
-      keypair.addFromSeed(seedTwo, {});
+      keyring.addFromSeed(seedTwo, {});
 
       expect(
-        keypair.getPublicKeys()
+        keyring.getPublicKeys()
       ).toEqual([publicKeyOne, publicKeyTwo]);
     });
 
     it('allows retrieval of a specific item', (): void => {
       expect(
-        keypair.getPair(publicKeyOne).publicKey
+        keyring.getPair(publicKeyOne).publicKey
       ).toEqual(publicKeyOne);
     });
 
     it('allows adding from JSON', (): void => {
       expect(
-        keypair.addFromJson(
+        keyring.addFromJson(
           JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}')
         ).publicKey
       ).toEqual(
@@ -77,7 +75,7 @@ describe('keypair', (): void => {
 
     it('signs and verifies', (): void => {
       const MESSAGE = stringToU8a('this is a message');
-      const pair = keypair.getPair(publicKeyOne);
+      const pair = keyring.getPair(publicKeyOne);
       const signature = pair.sign(MESSAGE);
 
       expect(pair.verify(MESSAGE, signature)).toBe(true);
@@ -89,55 +87,51 @@ describe('keypair', (): void => {
     const publicKeyTwo = hexToU8a('0x44a996beb1eef7bdcab976ab6d2ca26104834164ecf28fb375600576fcc6eb0f');
     const seedOne = stringToU8a('12345678901234567890123456789012');
     const seedTwo = hexToU8a('0x9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60');
-    let keypair: Keyring;
+    let keyring: Keyring;
 
     beforeEach((): void => {
-      keypair = new Keyring({ type: 'sr25519' });
+      keyring = new Keyring({ ss58Format: 42, type: 'sr25519' });
 
-      keypair.addFromSeed(seedOne, {});
-    });
-
-    afterEach((): void => {
-      setSS58Format(42);
+      keyring.addFromSeed(seedOne, {});
     });
 
     it('creates with dev phrase when only path specified', (): void => {
       expect(
-        keypair.createFromUri('//Alice').address
+        keyring.createFromUri('//Alice').address
       ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
     });
 
     it('adds the pair', (): void => {
       expect(
-        keypair.addFromSeed(seedTwo, {}).publicKey
+        keyring.addFromSeed(seedTwo, {}).publicKey
       ).toEqual(publicKeyTwo);
     });
 
     it('adds from a mnemonic', (): void => {
-      setSS58Format(68);
+      keyring.setSS58Format(68);
 
       expect(
-        keypair.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {}).address
+        keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card', {}).address
       ).toEqual('7qQGarA4PWjPPVHG4USn1yuuVZvEHN7XZz8o7EbAp48jayZQ');
     });
 
     it('allows publicKeys retrieval', (): void => {
-      keypair.addFromSeed(seedTwo, {});
+      keyring.addFromSeed(seedTwo, {});
 
       expect(
-        keypair.getPublicKeys()
+        keyring.getPublicKeys()
       ).toEqual([publicKeyOne, publicKeyTwo]);
     });
 
     it('allows retrieval of a specific item', (): void => {
       expect(
-        keypair.getPair(publicKeyOne).publicKey
+        keyring.getPair(publicKeyOne).publicKey
       ).toEqual(publicKeyOne);
     });
 
     it('allows adding from JSON', (): void => {
       expect(
-        keypair.addFromJson(
+        keyring.addFromJson(
           JSON.parse('{"address":"5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua","encoded":"0xb4a14995d25ab609f3686e9fa45f1fb237cd833f33f00d4b12c51858ca070d96972e47d73aae5eeb0fc06f923826cf0943fdb02c2c2ee30ef52a7912663053940d1da4da66b3a3f520ae07422c1c94b2d95690fca9d1f4a997623bb2923a8833280e19e7f72c3c5cfa343974e60e2b3dc53b404fdaf330756daad5e4e3","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"0"},"meta":{"isTesting":true,"name":"alice"}}')
         ).publicKey
       ).toEqual(
@@ -147,7 +141,72 @@ describe('keypair', (): void => {
 
     it('signs and verifies', (): void => {
       const MESSAGE = stringToU8a('this is a message');
-      const pair = keypair.getPair(publicKeyOne);
+      const pair = keyring.getPair(publicKeyOne);
+      const signature = pair.sign(MESSAGE);
+
+      expect(pair.verify(MESSAGE, signature)).toBe(true);
+    });
+  });
+
+  describe('ecdsa', (): void => {
+    const seedOne = 'potato act energy ahead stone taxi receive fame gossip equip chest round';
+    const seedTwo = hexToU8a('0x3c74be003bd9a876be439949ccf2b292bd966c94959a689173b295b326cd6da7');
+    const publicKeyOne = hexToU8a('0x02c6b6c664db5ef505477bba1cf2f1789c98796b9bb5fa21abd0ac4589bed980e7');
+    const publicKeyTwo = hexToU8a('0x021da683b913fb28c979ba3e5f1881415cef4b1f58a5d05ed3610a2995e7b4943c');
+    const addressKeyOne = hexToU8a('0x0cfd0dd2c59a9987b9848919163931b6a42283ffd3d91e92c98b522525a7038f');
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42, type: 'ecdsa' });
+
+      keyring.addFromMnemonic(seedOne, {});
+    });
+
+    it('creates with dev phrase when only path specified', (): void => {
+      expect(
+        keyring.createFromUri('//Alice').address
+      ).toEqual('5C7C2Z5sWbytvHpuLTvzKunnnRwQxft1jiqrLD5rhucQ5S9X');
+    });
+
+    it('adds the pair', (): void => {
+      expect(
+        keyring.addFromSeed(seedTwo, {}).publicKey
+      ).toEqual(publicKeyTwo);
+    });
+
+    it('adds from a mnemonic', (): void => {
+      keyring.setSS58Format(68);
+
+      expect(
+        keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card').address
+      ).toEqual('7ooxHV3mz4nnWbK8v7Mxcb71QMpof268eL1A2VrYWUNWJk8P');
+    });
+
+    it('allows publicKeys retrieval', (): void => {
+      keyring.addFromSeed(seedTwo, {});
+
+      expect(
+        keyring.getPublicKeys()
+      ).toEqual([publicKeyOne, publicKeyTwo]);
+    });
+
+    it('allows retrieval of a specific item', (): void => {
+      expect(
+        keyring.getPair(addressKeyOne).publicKey
+      ).toEqual(publicKeyOne);
+    });
+
+    it('allows adding from JSON', (): void => {
+      expect(
+        keyring.addFromJson(
+          JSON.parse('{"address":"5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz","encoded":"0xa192d39b42bc1601bf61df31039a554228593fadf870bc837b658a5114627aca199fff596260c95fe8994c66a47636cf0270aa08f402ba5541038753960d00e6c3af5e239ec58fb1eef3db7d6bc266f4853bdfe4ed17122d9092d879014d53980d2ee57f6f55a88c38836447d8645008e8815379626addc8f81f80cd49a2","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"2"},"meta":{}}')
+        ).address
+      ).toEqual('5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz');
+    });
+
+    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);

packages/keyring/src/index.ts

@@ -7,13 +7,8 @@ import { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-cryp
 
 import Keyring from './keyring';
 
-// eslint-disable-next-line no-useless-catch
-try {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  detectPackage(require('./package.json'), __dirname);
-} catch (error) {
-  throw error;
-}
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+detectPackage(require('./package.json'), typeof __dirname !== 'undefined' && __dirname);
 
 export default Keyring;
 

packages/keyring/src/keyring.ts

@@ -2,11 +2,11 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { KeypairType } from '@polkadot/util-crypto/types';
+import { KeypairType, Keypair } from '@polkadot/util-crypto/types';
 import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$Meta, KeyringOptions } from './types';
 
-import { assert, hexToU8a, isNumber, isHex, stringToU8a } from '@polkadot/util';
-import { decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, mnemonicToMiniSecret, setSS58Format } from '@polkadot/util-crypto';
+import { assert, hexToU8a, isHex, stringToU8a } from '@polkadot/util';
+import { decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import createPair from './pair';
@@ -29,30 +29,22 @@ import Pairs from './pairs';
  * an account may be obtained using `toJson` accompanied by the account passphrase.
  */
 export default class Keyring implements KeyringInstance {
-  private _pairs: Pairs;
+  readonly #pairs: Pairs;
 
-  private _type: KeypairType;
+  readonly #type: KeypairType;
+
+  #ss58?: number;
 
   public decodeAddress = decodeAddress;
 
-  public encodeAddress = encodeAddress;
-
-  public setSS58Format = setSS58Format;
-
   constructor (options: KeyringOptions = {}) {
     options.type = options.type || 'ed25519';
-    options.ss58Format = isNumber(options.ss58Format)
-      ? options.addressPrefix
-      : options.ss58Format;
 
-    assert(options && ['ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519' or 'sr25519', found '${options.type}`);
+    assert(options && ['ecdsa', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);
 
-    this._pairs = new Pairs();
-    this._type = options.type;
-
-    if (isNumber(options.ss58Format)) {
-      setSS58Format(options.ss58Format);
-    }
+    this.#pairs = new Pairs();
+    this.#ss58 = options.ss58Format;
+    this.#type = options.type;
   }
 
   /**
@@ -70,10 +62,10 @@ export default class Keyring implements KeyringInstance {
   }
 
   /**
-   * @description Returns the type of the keyring, either ed25519 of sr25519
+   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
    */
   public get type (): KeypairType {
-    return this._type;
+    return this.#type;
   }
 
   /**
@@ -81,7 +73,7 @@ export default class Keyring implements KeyringInstance {
    * @summary Stores an account, given a keyring pair, as a Key/Value (public key, pair) in Keyring Pair Dictionary
    */
   public addPair (pair: KeyringPair): KeyringPair {
-    return this._pairs.add(pair);
+    return this.#pairs.add(pair);
   }
 
   /**
@@ -95,7 +87,7 @@ export default class Keyring implements KeyringInstance {
   public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean): KeyringPair {
     const publicKey = this.decodeAddress(address, ignoreChecksum);
 
-    return this.addPair(createPair(type, { publicKey, secretKey: new Uint8Array(64) }, meta, encoded));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded));
   }
 
   /**
@@ -133,11 +125,13 @@ export default 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 {
-    const keypair = type === 'sr25519'
-      ? schnorrkelFromSeed(seed)
-      : naclFromSeed(seed);
+    const keypair = {
+      ecdsa: (): Keypair => secp256k1FromSeed(seed),
+      ed25519: (): Keypair => naclFromSeed(seed),
+      sr25519: (): Keypair => schnorrkelFromSeed(seed)
+    }[type]();
 
-    return this.addPair(createPair(type, keypair, meta, null));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, keypair, meta, null));
   }
 
   /**
@@ -153,7 +147,7 @@ export default class Keyring implements KeyringInstance {
 
   /**
    * @name createFromUri
-   * @summry Creates a Keypair from an suri
+   * @summary Creates a Keypair from an suri
    * @description This creates a pair from the suri, but does not add it to the keyring
    */
   public createFromUri (_suri: string, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
@@ -161,8 +155,8 @@ export default class Keyring implements KeyringInstance {
     const suri = _suri.startsWith('//')
       ? `${DEV_PHRASE}${_suri}`
       : _suri;
-    const { password, phrase, path } = keyExtractSuri(suri);
-    let seed;
+    const { password, path, phrase } = keyExtractSuri(suri);
+    let seed: Uint8Array;
 
     if (isHex(phrase, 256)) {
       seed = hexToU8a(phrase);
@@ -183,12 +177,22 @@ export default class Keyring implements KeyringInstance {
       }
     }
 
-    const keypair = type === 'sr25519'
-      ? schnorrkelFromSeed(seed)
-      : naclFromSeed(seed);
-    const derived = keyFromPath(keypair, path, type);
+    const keypair = {
+      ecdsa: (): Keypair => secp256k1FromSeed(seed),
+      ed25519: (): Keypair => naclFromSeed(seed),
+      sr25519: (): Keypair => schnorrkelFromSeed(seed)
+    };
+    const derived = keyFromPath(keypair[type](), path, type);
 
-    return createPair(type, derived, meta, null);
+    return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
+  }
+
+  /**
+   * @name encodeAddress
+   * @description Encodes the input into an ss58 representation
+   */
+  public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
+    return encodeAddress(address, ss58Format || this.#ss58);
   }
 
   /**
@@ -198,7 +202,7 @@ export default class Keyring implements KeyringInstance {
    * a key lookup using the provided account address or public key (after decoding it).
    */
   public getPair (address: string | Uint8Array): KeyringPair {
-    return this._pairs.get(address);
+    return this.#pairs.get(address);
   }
 
   /**
@@ -207,7 +211,7 @@ export default class Keyring implements KeyringInstance {
    * @description Returns an array list of all the keyring pair values that are stored in the keyring pair dictionary.
    */
   public getPairs (): KeyringPair[] {
-    return this._pairs.all();
+    return this.#pairs.all();
   }
 
   /**
@@ -216,7 +220,7 @@ export default class Keyring implements KeyringInstance {
    * @description Returns an array list of all the public keys associated with each of the keyring pair values that are stored in the keyring pair dictionary.
    */
   public getPublicKeys (): Uint8Array[] {
-    return this._pairs
+    return this.#pairs
       .all()
       .map(({ publicKey }): Uint8Array =>
         publicKey
@@ -228,7 +232,15 @@ export default class Keyring implements KeyringInstance {
    * @description Deletes the provided input address or public key from the stored Keyring Pair Dictionary.
    */
   public removePair (address: string | Uint8Array): void {
-    this._pairs.remove(address);
+    this.#pairs.remove(address);
+  }
+
+  /**
+   * @name setSS58Format;
+   * @description Sets the ss58 format for the keyring
+   */
+  public setSS58Format (ss58: number): void {
+    this.#ss58 = ss58;
   }
 
   /**
@@ -240,6 +252,6 @@ export default class Keyring implements KeyringInstance {
    * may backup their account to a JSON file that contains this information.
    */
   public toJson (address: string | Uint8Array, passphrase?: string): KeyringPair$Json {
-    return this._pairs.get(address).toJson(passphrase);
+    return this.#pairs.get(address).toJson(passphrase);
   }
 }

packages/keyring/src/pair/decode.ts

@@ -14,19 +14,7 @@ type DecodeResult = PairInfo & {
   secretKey: Uint8Array;
 };
 
-export default function decode (passphrase?: string, encrypted?: Uint8Array | null): DecodeResult {
-  assert(encrypted, 'No encrypted data available to decode');
-
-  const encoded = passphrase
-    ? (naclDecrypt(
-      encrypted.subarray(NONCE_LENGTH),
-      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(stringToU8a(passphrase), 256, true)
-    ) as Uint8Array)
-    : encrypted;
-
-  assert(encoded, 'Unable to unencrypt using the supplied passphrase');
-
+function decodePkcs8 (encoded: Uint8Array): DecodeResult {
   const header = encoded.subarray(0, PKCS8_HEADER.length);
 
   assert(header.toString() === PKCS8_HEADER.toString(), 'Invalid Pkcs8 header found in body');
@@ -52,3 +40,19 @@ export default function decode (passphrase?: string, encrypted?: Uint8Array | nu
     secretKey
   };
 }
+
+export default function decode (passphrase?: string, encrypted?: Uint8Array | null): DecodeResult {
+  assert(encrypted, 'No encrypted data available to decode');
+
+  const encoded = passphrase
+    ? naclDecrypt(
+      encrypted.subarray(NONCE_LENGTH),
+      encrypted.subarray(0, NONCE_LENGTH),
+      u8aFixLength(stringToU8a(passphrase), 256, true)
+    )
+    : encrypted;
+
+  assert(encoded, 'Unable to unencrypt using the supplied passphrase');
+
+  return decodePkcs8(encoded);
+}

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

@@ -2,7 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { cryptoWaitReady, setSS58Format } from '@polkadot/util-crypto';
+import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';
 
 import { PAIRS } from '../testing';
 import testingPairs from '../testingPairs';
@@ -79,18 +79,28 @@ describe('pair', (): void => {
     const PASS = 'testing';
     const encoded = keyring.alice.encodePkcs8(PASS);
 
-    const pair = createPair('sr25519', { publicKey: keyring.alice.publicKey });
+    const pair = createPair({ toSS58, type: 'sr25519' }, { publicKey: keyring.alice.publicKey });
+
     pair.decodePkcs8(PASS, encoded);
 
     expect(pair.isLocked).toEqual(false);
   });
 
   it('allows derivation on the pair', (): void => {
-    const alice = createPair('sr25519', { publicKey: PAIRS[0].publicKey, secretKey: PAIRS[0].secretKey }, {});
+    const alice = createPair({ toSS58, type: 'sr25519' }, { publicKey: PAIRS[0].publicKey, secretKey: PAIRS[0].secretKey }, {});
     const stash = alice.derive('//stash');
     const soft = alice.derive('//funding/0');
 
     expect(stash.publicKey).toEqual(PAIRS[1].publicKey);
     expect(soft.address).toEqual('5ECQNn7UueWHPFda5qUi4fTmTtyCnPvGnuoyVVSj5CboJh9J');
   });
+
+  it('fails to sign when locked', (): void => {
+    const pair = createPair({ toSS58, type: 'sr25519' }, { publicKey: keyring.alice.publicKey });
+
+    expect(pair.isLocked).toEqual(true);
+    expect((): Uint8Array =>
+      pair.sign(new Uint8Array([0]))
+    ).toThrow('Cannot sign with a locked key pair');
+  });
 });

packages/keyring/src/pair/index.ts

@@ -6,55 +6,79 @@ import { Keypair, KeypairType } from '@polkadot/util-crypto/types';
 import { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
 import { PairInfo } from './types';
 
-import { u8aConcat, assert } from '@polkadot/util';
-import { encodeAddress, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, naclVerify, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVerify } from '@polkadot/util-crypto';
+import { assert, u8aConcat } from '@polkadot/util';
+import { keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, naclVerify, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVerify, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, secp256k1Verify, blake2AsU8a } from '@polkadot/util-crypto';
 
 import decode from './decode';
 import encode from './encode';
 import toJson from './toJson';
 
+interface Setup {
+  toSS58: (publicKey: Uint8Array) => string;
+  type: KeypairType;
+}
+
 const SIG_TYPE_NONE = new Uint8Array();
 const SIG_TYPE_ED25519 = new Uint8Array([0]);
 const SIG_TYPE_SR25519 = new Uint8Array([1]);
-// const SIG_TYPE_ECDSA = new Uint8Array([2]);
+const SIG_TYPE_ECDSA = new Uint8Array([2]);
 
 function isEmpty (u8a: Uint8Array): boolean {
   return u8a.reduce((count, u8): number => count + u8, 0) === 0;
 }
 
-function isSr25519 (type: KeypairType): boolean {
-  return type === 'sr25519';
-}
-
 function fromSeed (type: KeypairType, seed: Uint8Array): Keypair {
-  return isSr25519(type)
-    ? schnorrkelFromSeed(seed)
-    : naclFromSeed(seed);
+  return {
+    ecdsa: (): Keypair => secp256k1FromSeed(seed),
+    ed25519: (): Keypair => naclFromSeed(seed),
+    sr25519: (): Keypair => schnorrkelFromSeed(seed)
+  }[type]();
 }
 
 function multiSignaturePrefix (type: KeypairType): Uint8Array {
-  return isSr25519(type)
-    ? SIG_TYPE_SR25519
-    : SIG_TYPE_ED25519;
+  return {
+    ecdsa: SIG_TYPE_ECDSA,
+    ed25519: SIG_TYPE_ED25519,
+    sr25519: SIG_TYPE_SR25519
+  }[type];
 }
 
 function sign (type: KeypairType, message: Uint8Array, pair: Partial<Keypair>, { withType = false }: SignOptions = {}): Uint8Array {
+  const signature = {
+    ecdsa: (): Uint8Array => secp256k1Sign(message, pair),
+    ed25519: (): Uint8Array => naclSign(message, pair),
+    sr25519: (): Uint8Array => schnorrkelSign(message, pair)
+  }[type]();
+
   return u8aConcat(
     // for multi-signatures, i.e. with indicator, append the signature type as per
     // the MultiSignature enum
     withType
       ? multiSignaturePrefix(type)
       : SIG_TYPE_NONE,
-    isSr25519(type)
-      ? schnorrkelSign(message, pair)
-      : naclSign(message, pair)
+    signature
   );
 }
 
 function verify (type: KeypairType, message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean {
-  return isSr25519(type)
-    ? schnorrkelVerify(message, signature, publicKey)
-    : naclVerify(message, signature, publicKey);
+  return {
+    ecdsa: (): boolean => secp256k1Verify(message, signature, blake2AsU8a(publicKey, 256)),
+    ed25519: (): boolean => naclVerify(message, signature, publicKey),
+    sr25519: (): boolean => schnorrkelVerify(message, signature, publicKey)
+  }[type]();
+}
+
+function getAddress (type: KeypairType, publicKey: Uint8Array): Uint8Array {
+  if (type === 'ecdsa' && publicKey.length > 32) {
+    return blake2AsU8a(publicKey, 256);
+  } else {
+    return publicKey;
+  }
+}
+
+// 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);
 }
 
 /**
@@ -88,23 +112,24 @@ function verify (type: KeypairType, message: Uint8Array, signature: Uint8Array,
  * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
  * property that indicates whether the public key value of the `encoded` property is encoded or not.
  */
-export default function createPair (type: KeypairType, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null): KeyringPair {
+export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null): KeyringPair {
   return {
     get address (): string {
-      return encodeAddress(publicKey);
+      return toSS58(getAddress(type, publicKey));
+    },
+    get isLocked (): boolean {
+      return isLocked(secretKey);
     },
     get meta (): KeyringPair$Meta {
       return meta;
     },
-    get isLocked (): boolean {
-      return !secretKey || secretKey.length === 0 || isEmpty(secretKey);
-    },
     get publicKey (): Uint8Array {
       return publicKey;
     },
     get type (): KeypairType {
       return type;
     },
+    // eslint-disable-next-line sort-keys
     decodePkcs8: (passphrase?: string, _encoded?: Uint8Array | null): void => {
       const decoded = decode(passphrase, _encoded || encoded);
 
@@ -119,12 +144,12 @@ export default function createPair (type: KeypairType, { publicKey, secretKey }:
       }
     },
     derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
-      assert(secretKey, 'Cannot derive on a locked keypair');
+      assert(!isLocked(secretKey), 'Cannot derive on a locked keypair');
 
       const { path } = keyExtractPath(suri);
-      const derived = keyFromPath({ publicKey, secretKey: secretKey }, path, type);
+      const derived = keyFromPath({ publicKey, secretKey }, path, type);
 
-      return createPair(type, derived, meta, null);
+      return createPair({ toSS58, type }, derived, meta, null);
     },
     encodePkcs8: (passphrase?: string): Uint8Array =>
       encode({ publicKey, secretKey }, passphrase),
@@ -134,10 +159,13 @@ export default function createPair (type: KeypairType, { publicKey, secretKey }:
     setMeta: (additional: KeyringPair$Meta): void => {
       meta = { ...meta, ...additional };
     },
-    sign: (message: Uint8Array, options?: SignOptions): Uint8Array =>
-      sign(type, message, { publicKey, secretKey }, options),
+    sign: (message: Uint8Array, options?: SignOptions): Uint8Array => {
+      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');
+
+      return sign(type, message, { publicKey, secretKey }, options);
+    },
     toJson: (passphrase?: string): KeyringPair$Json =>
-      toJson(type, { meta, publicKey }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
+      toJson(type, { address: toSS58(getAddress(type, publicKey)), meta }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
       verify(type, message, signature, publicKey)
   };

packages/keyring/src/pair/nobody.ts

@@ -25,7 +25,6 @@ const json: KeyringPair$Json = {
 
 export default function everybody (): KeyringPair {
   const pair: KeyringPair = {
-    type: 'ed25519',
     address,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     decodePkcs8: (passphrase?: string, encoded?: Uint8Array): void =>
@@ -36,11 +35,11 @@ export default function everybody (): KeyringPair {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     encodePkcs8: (passphrase?: string): Uint8Array =>
       new Uint8Array(0),
-    meta,
     isLocked: true,
     lock: (): void => {
       // no locking, it is always locked
     },
+    meta,
     publicKey,
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     setMeta: (meta: KeyringPair$Meta): void =>
@@ -51,6 +50,7 @@ export default function everybody (): KeyringPair {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     toJson: (passphrase?: string): KeyringPair$Json =>
       json,
+    type: 'ed25519',
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
       false

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

@@ -19,8 +19,8 @@ describe('toJson', (): void => {
         version: '2'
       },
       meta: {
-        name: 'alice',
-        isTesting: true
+        isTesting: true,
+        name: 'alice'
       }
     });
   });

packages/keyring/src/pair/toJson.ts

@@ -6,15 +6,15 @@ import { KeypairType } from '@polkadot/util-crypto/types';
 import { KeyringPair$Json, KeyringPair$Meta } from '../types';
 
 import { u8aToHex } from '@polkadot/util';
-import { encodeAddress } from '@polkadot/util-crypto';
 
-type PairStateJson = KeyringPair$Meta & {
-  publicKey: Uint8Array;
-};
+interface PairStateJson {
+  address: string;
+  meta: KeyringPair$Meta;
+}
 
-export default function toJson (type: KeypairType, { publicKey, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
+export default function toJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
   return {
-    address: encodeAddress(publicKey),
+    address,
     encoded: u8aToHex(encoded),
     encoding: {
       content: ['pkcs8', type],

packages/keyring/src/pairs.ts

@@ -10,24 +10,20 @@ import { decodeAddress } from '@polkadot/util-crypto';
 type KeyringPairMap = Record<string, KeyringPair>;
 
 export default class Pairs implements KeyringPairs {
-  private _map: KeyringPairMap;
-
-  constructor () {
-    this._map = {};
-  }
+  readonly #map: KeyringPairMap = {};
 
   public add (pair: KeyringPair): KeyringPair {
-    this._map[pair.publicKey.toString()] = pair;
+    this.#map[decodeAddress(pair.address).toString()] = pair;
 
     return pair;
   }
 
   public all (): KeyringPair[] {
-    return Object.values(this._map);
+    return Object.values(this.#map);
   }
 
   public get (address: string | Uint8Array): KeyringPair {
-    const pair = this._map[decodeAddress(address).toString()];
+    const pair = this.#map[decodeAddress(address).toString()];
 
     assert(pair, (): string => {
       const formatted: string = isU8a(address) || isHex(address)
@@ -41,6 +37,6 @@ export default class Pairs implements KeyringPairs {
   }
 
   public remove (address: string | Uint8Array): void {
-    delete this._map[decodeAddress(address).toString()];
+    delete this.#map[decodeAddress(address).toString()];
   }
 }

packages/keyring/src/testing.ts

@@ -23,44 +23,44 @@ interface PairDef {
 // adding the keys when only the keyring is used.
 export const PAIRS: PairDef[] = [
   {
-    seed: 'Alice',
+    publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d'),
     secretKey: hexToU8a('0x98319d4ff8a9508c4bb0cf0b5a78d760a0b2082c02775e6e82370816fedfff48925a225d97aa00682d6a59b95b18780c10d7032336e88f3442b42361f4a66011'),
-    publicKey: hexToU8a('0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d')
+    seed: 'Alice'
   },
   {
-    seed: 'Alice//stash',
+    publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f'),
     secretKey: hexToU8a('0xe8da6c9d810e020f5e3c7f5af2dea314cbeaa0d72bc6421e92c0808a0c584a6046ab28e97c3ffc77fe12b5a4d37e8cd4afbfebbf2391ffc7cb07c0f38c023efd'),
-    publicKey: hexToU8a('0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f')
+    seed: 'Alice//stash'
   },
   {
-    seed: 'Bob',
+    publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48'),
     secretKey: hexToU8a('0x081ff694633e255136bdb456c20a5fc8fed21f8b964c11bb17ff534ce80ebd5941ae88f85d0c1bfc37be41c904e1dfc01de8c8067b0d6d5df25dd1ac0894a325'),
-    publicKey: hexToU8a('0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48')
+    seed: 'Bob'
   },
   {
-    seed: 'Bob//stash',
+    publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e'),
     secretKey: hexToU8a('0xc006507cdfc267a21532394c49ca9b754ca71de21e15a1cdf807c7ceab6d0b6c3ed408d9d35311540dcd54931933e67cf1ea10d46f75408f82b789d9bd212fde'),
-    publicKey: hexToU8a('0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e')
+    seed: 'Bob//stash'
   },
   {
-    seed: 'Charlie',
+    publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22'),
     secretKey: hexToU8a('0xa8f2d83016052e5d6d77b2f6fd5d59418922a09024cda701b3c34369ec43a7668faf12ff39cd4e5d92bb773972f41a7a5279ebc2ed92264bed8f47d344f8f18c'),
-    publicKey: hexToU8a('0x90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22')
+    seed: 'Charlie'
   },
   {
-    seed: 'Dave',
+    publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20'),
     secretKey: hexToU8a('0x20e05482ca4677e0edbc58ae9a3a59f6ed3b1a9484ba17e64d6fe8688b2b7b5d108c4487b9323b98b11fe36cb301b084e920f7b7895536809a6d62a451b25568'),
-    publicKey: hexToU8a('0x306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20')
+    seed: 'Dave'
   },
   {
-    seed: 'Eve',
+    publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e'),
     secretKey: hexToU8a('0x683576abfd5dc35273e4264c23095a1bf21c14517bece57c7f0cc5c0ed4ce06a3dbf386b7828f348abe15d76973a72009e6ef86a5c91db2990cb36bb657c6587'),
-    publicKey: hexToU8a('0xe659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e')
+    seed: 'Eve'
   },
   {
-    seed: 'Ferdie',
+    publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c'),
     secretKey: hexToU8a('0xb835c20f450079cf4f513900ae9faf8df06ad86c681884122c752a4b2bf74d4303e4f21bc6cc62bb4eeed5a9cce642c25e2d2ac1464093b50f6196d78e3a7426'),
-    publicKey: hexToU8a('0x1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c')
+    seed: 'Ferdie'
   }
 ];
 
@@ -73,7 +73,7 @@ export const PAIRS: PairDef[] = [
 export default function testKeyring (options: KeyringOptions = {}, isDerived = true): KeyringInstance {
   const keyring = new Keyring(options);
 
-  PAIRS.forEach(({ name, publicKey, secretKey, seed, type }): void => {
+  PAIRS.forEach(({ name, publicKey, secretKey, seed, type = 'sr25519' }): void => {
     const meta = {
       isTesting: true,
       name: name || seed.replace('//', '_').toLowerCase()
@@ -82,7 +82,7 @@ export default function testKeyring (options: KeyringOptions = {}, isDerived = t
     const pair = !isDerived && !name
       ? keyring.addFromUri(seed, meta, options.type)
       : keyring.addPair(
-        createPair(type || 'sr25519', { publicKey, secretKey }, meta)
+        createPair({ toSS58: keyring.encodeAddress, type }, { publicKey, secretKey }, meta)
       );
 
     pair.lock = (): void => {

packages/keyring/src/types.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/class-name-casing */
 // Copyright 2017-2020 @polkadot/keyring authors & contributors
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
@@ -7,16 +6,11 @@ import { Prefix } from '@polkadot/util-crypto/address/types';
 import { KeypairType } from '@polkadot/util-crypto/types';
 
 export interface KeyringOptions {
-  // @deprecated
-  addressPrefix?: Prefix;
   ss58Format?: Prefix;
   type?: KeypairType;
 }
 
-export interface KeyringPair$Meta {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [index: string]: any;
-}
+export type KeyringPair$Meta = Record<string, unknown>;
 
 export type KeyringPair$JsonVersion = '0' | '1' | '2';
 

packages/util-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "2.3.1",
+  "version": "2.13.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,24 +25,25 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.8.4",
-    "@polkadot/util": "^2.3.1",
-    "@polkadot/wasm-crypto": "^1.0.1",
-    "base-x": "^3.0.7",
+    "@babel/runtime": "^7.10.2",
+    "@polkadot/util": "2.13.1",
+    "@polkadot/wasm-crypto": "^1.2.1",
+    "base-x": "^3.0.8",
     "bip39": "^3.0.2",
     "blakejs": "^1.1.0",
-    "bn.js": "^5.1.1",
+    "bn.js": "^5.1.2",
     "bs58": "^4.0.1",
     "elliptic": "^6.5.2",
     "js-sha3": "^0.8.0",
-    "pbkdf2": "^3.0.9",
+    "pbkdf2": "^3.1.1",
     "tweetnacl": "^1.0.3",
     "xxhashjs": "^0.2.2"
   },
   "devDependencies": {
-    "@types/bs58": "^4.0.0",
+    "@types/bn.js": "^4.11.6",
+    "@types/bs58": "^4.0.1",
     "@types/elliptic": "^6.4.12",
     "@types/pbkdf2": "^3.0.0",
-    "@types/xxhashjs": "^0.2.1"
+    "@types/xxhashjs": "^0.2.2"
   }
 }

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

@@ -6,8 +6,8 @@ import { Prefix } from './types';
 
 import bs58 from 'bs58';
 
+import checkChecksum from './checkChecksum';
 import defaults from './defaults';
-import sshash from './sshash';
 
 export default function check (address: string, prefix: Prefix): [boolean, string | null] {
   const decoded = bs58.decode(address);
@@ -18,18 +18,7 @@ export default function check (address: string, prefix: Prefix): [boolean, strin
     return [false, 'Invalid decoded address length'];
   }
 
-  const isPublicKey = decoded.length === 35;
+  const [isValid] = checkChecksum(decoded);
 
-  // non-publicKeys has 1 byte checksums, else default to 2
-  const endPos = decoded.length - (isPublicKey ? 2 : 1);
-
-  // calculate the hash and do the checksum byte checks
-  const hash = sshash(decoded.subarray(0, endPos));
-  const checks = isPublicKey
-    ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-    : decoded[decoded.length - 1] === hash[0];
-
-  return !checks
-    ? [false, 'Invalid decoded address checksum']
-    : [true, null];
+  return [isValid, isValid ? null : 'Invalid decoded address checksum'];
 }

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

@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import sshash from './sshash';
+
+export default function checkChecksum (decoded: Uint8Array): [boolean, number] {
+  const isPublicKey = decoded.length === 35;
+
+  // non-publicKeys has 1 byte checksums, else default to 2
+  const length = decoded.length - (isPublicKey ? 2 : 1);
+
+  // calculate the hash and do the checksum byte checks
+  const hash = sshash(decoded.subarray(0, length));
+
+  // 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];
+}

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

@@ -9,8 +9,8 @@ import { Prefix } from './types';
 import bs58 from 'bs58';
 import { assert, bufferToU8a, isHex, isU8a, u8aToU8a } from '@polkadot/util';
 
+import checkChecksum from './checkChecksum';
 import defaults from './defaults';
-import sshash from './sshash';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export default function decode (encoded: string | Uint8Array, ignoreChecksum?: boolean, ss58Format: Prefix = 99): Uint8Array {
@@ -19,8 +19,7 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
   }
 
   const decoded = bufferToU8a(bs58.decode(encoded));
-  const error = (message: string): string =>
-    `Decoding ${encoded}: ${message}`;
+  const error = (message: string) => `Decoding ${encoded as string}: ${message}`;
 
   // assert(defaults.allowedPrefix.includes(decoded[0] as Prefix), error('Invalid decoded address prefix'));
   assert(defaults.allowedEncodedLengths.includes(decoded.length), error('Invalid decoded address length'));
@@ -30,18 +29,9 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
   //   console.log(`WARN: Expected ${prefix}, found ${decoded[0]}`);
   // }
 
-  const isPublicKey = decoded.length === 35;
+  const [isValid, endPos] = checkChecksum(decoded);
 
-  // non-publicKeys has 1 byte checksums, else default to 2
-  const endPos = decoded.length - (isPublicKey ? 2 : 1);
-
-  // calculate the hash and do the checksum byte checks
-  const hash = sshash(decoded.subarray(0, endPos));
-  const checks = isPublicKey
-    ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-    : decoded[decoded.length - 1] === hash[0];
-
-  assert(ignoreChecksum || checks, error('Invalid decoded address checksum'));
+  assert(ignoreChecksum || isValid, error('Invalid decoded address checksum'));
 
   return decoded.slice(1, endPos);
 }

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

@@ -2,7 +2,8 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import testingPairs from '../../../keyring/src/testingPairs';
+import testingPairs from '@polkadot/keyring/testingPairs';
+
 import encode from './encode';
 
 const keyring = testingPairs({ type: 'ed25519' }, false);

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

@@ -17,10 +17,9 @@ export default function encode (_key: Uint8Array | string, ss58Format: Prefix =
   // decode it, this means we can re-encode an address
   const key = decode(_key);
 
-  assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths}`);
+  assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
 
   const isPublicKey = key.length === 32;
-
   const input = u8aConcat(new Uint8Array([ss58Format]), key);
   const hash = sshash(input);
 

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

@@ -0,0 +1,46 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import testingPairs from '@polkadot/keyring/testingPairs';
+import { addressEq } from '.';
+
+describe('addressEq', (): void => {
+  it('returns false with non-equal', (): void => {
+    expect(
+      addressEq(
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5EnxxUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG'
+      )
+    ).toEqual(false);
+  });
+
+  it('returns true for equal, matching prefix', (): void => {
+    expect(
+      addressEq(
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+      )
+    ).toEqual(true);
+  });
+
+  it('returns true for equal, non-matching prefix', (): void => {
+    expect(
+      addressEq(
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv'
+      )
+    ).toEqual(true);
+  });
+
+  it('returns true for equal, address vs publicKey', (): void => {
+    const keyring = testingPairs({ type: 'sr25519' });
+
+    expect(
+      addressEq(
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        keyring.alice.publicKey
+      )
+    ).toEqual(true);
+  });
+});

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

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aEq } from '@polkadot/util';
+
+import decode from './decode';
+
+/**
+ * @name addressEq
+ * @summary Compares two addresses, either in ss58, Uint8Array or hex format.
+ * @description
+ * For the input values, return true is the underlying public keys do match.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aEq } from '@polkadot/util';
+ *
+ * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
+ * ```
+ */
+export default function addressEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
+  return u8aEq(decode(a), decode(b));
+}

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

@@ -3,13 +3,23 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import checkAddress from './check';
+import checkAddressChecksum from './checkChecksum';
+import createKeyMulti from './keyMulti';
+import createKeySub from './keySub';
 import decodeAddress from './decode';
 import encodeAddress from './encode';
+import addressEq from './eq';
 import setSS58Format from './setSS58Format';
+import sortAddresses from './sort';
 
 export {
+  addressEq,
   checkAddress,
+  checkAddressChecksum,
+  createKeyMulti,
+  createKeySub,
   decodeAddress,
   encodeAddress,
-  setSS58Format
+  setSS58Format,
+  sortAddresses
 };

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

@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { createKeyMulti } from '.';
+
+describe('createKeyMulti', (): void => {
+  it('creates a valid multikey (aligning with Rust, needs sorting)', (): void => {
+    expect(
+      createKeyMulti([
+        new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]),
+        new Uint8Array([3, 0, 0, 0, 0, 0, 0, 0]),
+        new Uint8Array([2, 0, 0, 0, 0, 0, 0, 0])
+      ], 2)
+    ).toEqual(
+      new Uint8Array([67, 151, 196, 155, 179, 207, 47, 123, 90, 2, 35, 54, 162, 111, 241, 226, 88, 148, 54, 193, 252, 195, 93, 101, 16, 5, 93, 101, 186, 186, 254, 79])
+    );
+  });
+});

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

@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import BN from 'bn.js';
+import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
+
+import blake2AsU8a from '../blake2/asU8a';
+import decodeAddress from './decode';
+
+const PREFIX = stringToU8a('modlpy/utilisuba');
+
+export default function createKeyMulti (who: (Uint8Array | string)[], threshold: BigInt | BN | number): Uint8Array {
+  return blake2AsU8a(
+    u8aConcat(
+      PREFIX,
+      compactToU8a(who.length),
+      ...u8aSorted(who.map((who) => decodeAddress(who))),
+      bnToU8a(threshold, { bitLength: 16, isLe: true })
+    )
+  );
+}

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

@@ -0,0 +1,23 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import createKeySub from './keySub';
+
+describe('createKeySub', (): void => {
+  it('matches sub accounts with Rust', (): void => {
+    expect(
+      createKeySub(new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]), 0)
+    ).toEqual(
+      new Uint8Array([234, 236, 28, 96, 177, 168, 152, 193, 71, 179, 226, 102, 179, 155, 188, 240, 90, 182, 21, 175, 47, 47, 250, 179, 178, 0, 81, 222, 70, 56, 52, 234])
+    );
+  });
+
+  it('creates a valid subkey', (): void => {
+    expect(
+      createKeySub('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 1)
+    ).toEqual(
+      new Uint8Array([248, 19, 86, 209, 254, 89, 84, 48, 54, 128, 166, 239, 153, 212, 143, 34, 191, 60, 210, 50, 39, 77, 122, 71, 29, 60, 247, 198, 95, 101, 246, 83])
+    );
+  });
+});

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

@@ -0,0 +1,21 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import BN from 'bn.js';
+import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
+
+import blake2AsU8a from '../blake2/asU8a';
+import decodeAddress from './decode';
+
+const PREFIX = stringToU8a('modlpy/utilisuba');
+
+export default function createKeySub (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
+  return blake2AsU8a(
+    u8aConcat(
+      PREFIX,
+      decodeAddress(who),
+      bnToU8a(index, { bitLength: 16, isLe: true })
+    )
+  );
+}

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

@@ -6,6 +6,10 @@ import { Prefix } from './types';
 
 import defaults from './defaults';
 
+/**
+ * @description Sets the global SS58 format to use for address encoding
+ * @deprecated Use keyring.setSS58Format
+ */
 export default function setSS58Format (prefix: Prefix): void {
   defaults.prefix = prefix;
 }

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

@@ -0,0 +1,21 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { sortAddresses } from '.';
+
+describe('sortAddresses', (): void => {
+  it('sorts addresses by the publicKeys', (): void => {
+    expect(
+      sortAddresses([
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y'
+      ])
+    ).toEqual([
+      '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+      '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y',
+      '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+    ]);
+  });
+});

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

@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Prefix } from './types';
+
+import { u8aSorted } from '@polkadot/util';
+
+import decodeAddress from './decode';
+import encodeAddress from './encode';
+
+export default function sortAddresses (addresses: (Uint8Array | string)[], ss58Format?: Prefix): string[] {
+  return u8aSorted(
+    addresses.map((who) => decodeAddress(who))
+  ).map((u8a) => encodeAddress(u8a, ss58Format));
+}

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

@@ -7,6 +7,8 @@ export const allowedSS58 = [
   0, 1,
   // Kusama
   2, 3,
+  // Kulupu
+  16, 17,
   // Dothereum
   20,
   // Substrate default

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

@@ -43,4 +43,18 @@ describe('blake2AsU8a', (): void => {
       hexToU8a('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923')
     );
   });
+
+  it('has equivalent Wasm/Js outputs on hex inputs', (): void => {
+    const a = blake2AsU8a('0x123456', 256, null, false);
+    const b = blake2AsU8a('0x123456', 256, null, true);
+
+    expect(a).toEqual(b);
+  });
+
+  it('has equivalent Wasm/Js outputs with key inputs', (): void => {
+    const a = blake2AsU8a('0x123456', 256, new Uint8Array([1, 2]), false);
+    const b = blake2AsU8a('0x123456', 256, new Uint8Array([1, 2]), true);
+
+    expect(a).toEqual(b);
+  });
 });

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

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

packages/util-crypto/src/index.ts

@@ -2,10 +2,13 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
+// polyfills
 import './polyfill';
 
-import wasmCrypto from '@polkadot/wasm-crypto';
+// out of order and early in the chain, this also kicks off initialization on require
+export * from './init';
 
+// all internal exports
 export * from './address';
 export * from './blake2';
 export * from './keccak';
@@ -16,20 +19,5 @@ export * from './random';
 export * from './schnorrkel';
 export * from './secp256k1';
 export * from './sha512';
+export * from './signature';
 export * from './xxhash';
-
-export function cryptoWaitReady (): Promise<boolean> {
-  return wasmCrypto
-    .waitReady()
-    .then((): boolean => true)
-    .catch((error): boolean => {
-      console.error('Unable to initialize @polkadot/util-crypto', error);
-
-      return false;
-    });
-}
-
-// start init process immediately
-cryptoWaitReady().catch((): void => {
-  // shouldn't happen, logged above
-});

packages/util-crypto/src/init.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import wasmCrypto from '@polkadot/wasm-crypto';
+
+export function cryptoIsReady (): boolean {
+  return wasmCrypto.isReady();
+}
+
+export function cryptoWaitReady (): Promise<boolean> {
+  return wasmCrypto
+    .waitReady()
+    .then((): boolean => true)
+    .catch((error): boolean => {
+      console.error('Unable to initialize @polkadot/util-crypto', error);
+
+      return false;
+    });
+}
+
+// start init process immediately
+cryptoWaitReady().catch((): void => {
+  // shouldn't happen, logged above
+});

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

@@ -2,8 +2,9 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import BN from 'bn.js';
-import { bnToHex, compactAddLength, hexToU8a, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
+import type BN from 'bn.js';
+
+import { bnToHex, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
 
 import blake2AsU8a from '../blake2/asU8a';
 
@@ -16,15 +17,15 @@ const BN_OPTIONS = {
 };
 
 export default class DeriveJunction {
-  private _chainCode: Uint8Array = new Uint8Array(32);
+  readonly #chainCode: Uint8Array = new Uint8Array(32);
 
-  private _isHard = false;
+  #isHard = false;
 
   public static from (value: string): DeriveJunction {
+    const result = new DeriveJunction();
     const [code, isHard] = value.startsWith('/')
       ? [value.substr(1), true]
       : [value, false];
-    const result = new DeriveJunction();
 
     result.soft(
       RE_NUMBER.test(code)
@@ -38,29 +39,29 @@ export default class DeriveJunction {
   }
 
   public get chainCode (): Uint8Array {
-    return this._chainCode;
+    return this.#chainCode;
   }
 
   public get isHard (): boolean {
-    return this._isHard;
+    return this.#isHard;
   }
 
   public get isSoft (): boolean {
-    return !this._isHard;
+    return !this.#isHard;
   }
 
-  public hard (value: number | BN | string | Uint8Array): DeriveJunction {
+  public hard (value: number | string | BigInt | BN | Uint8Array): DeriveJunction {
     return this.soft(value).harden();
   }
 
   public harden (): DeriveJunction {
-    this._isHard = true;
+    this.#isHard = true;
 
     return this;
   }
 
-  public soft (value: number | BN | string | Uint8Array): DeriveJunction {
-    if (isNumber(value) || isBn(value)) {
+  public soft (value: number | string | BigInt | BN | Uint8Array): DeriveJunction {
+    if (isNumber(value) || isBn(value) || isBigInt(value)) {
       return this.soft(bnToHex(value, BN_OPTIONS));
     } else if (isString(value)) {
       return isHex(value)
@@ -72,14 +73,14 @@ export default class DeriveJunction {
       return this.soft(blake2AsU8a(value));
     }
 
-    this._chainCode.fill(0);
-    this._chainCode.set(value, 0);
+    this.#chainCode.fill(0);
+    this.#chainCode.set(value, 0);
 
     return this;
   }
 
   public soften (): DeriveJunction {
-    this._isHard = false;
+    this.#isHard = false;
 
     return this;
   }

packages/util-crypto/src/key/extractPath.spec.ts

@@ -6,37 +6,32 @@ import keyExtractPath, { ExtractResult } from './extractPath';
 
 describe('keyExtractPath', (): void => {
   it('extracts properly from soft', (): void => {
-    expect(
-      keyExtractPath('/1')
-    ).toEqual({
-      parts: ['/1'],
-      path: [
-        { _isHard: false, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ]
-    });
+    const test = keyExtractPath('/1');
+
+    expect(test.parts).toEqual(['/1']);
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(false);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('extracts properly from hard', (): void => {
-    expect(
-      keyExtractPath('//1')
-    ).toEqual({
-      parts: ['//1'],
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ]
-    });
+    const test = keyExtractPath('//1');
+
+    expect(test.parts).toEqual(['//1']);
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('extracts properly from hard/soft', (): void => {
-    expect(
-      keyExtractPath('//1/2')
-    ).toEqual({
-      parts: ['//1', '/2'],
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) },
-        { _isHard: false, _chainCode: Uint8Array.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ]
-    });
+    const test = keyExtractPath('//1/2');
+
+    expect(test.parts).toEqual(['//1', '/2']);
+    expect(test.path.length).toEqual(2);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    expect(test.path[1].isHard).toEqual(false);
+    expect(test.path[1].chainCode).toEqual(Uint8Array.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('does not extract from invalid paths', (): void => {

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

@@ -13,7 +13,7 @@ export interface ExtractResult {
 }
 
 /**
- * @description Extract derivation juntions from the supplied path
+ * @description Extract derivation junctions from the supplied path
  */
 export default function keyExtractPath (derivePath: string): ExtractResult {
   const parts = derivePath.match(RE_JUNCTION);

packages/util-crypto/src/key/extractSuri.spec.ts

@@ -12,126 +12,115 @@ describe('keyExtractSuri', (): void => {
   });
 
   it('derives on "hello world"', (): void => {
-    expect(
-      keyExtractSuri('hello world')
-    ).toEqual({
-      path: [],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world');
+
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(0);
   });
 
   it('derives on "hello world/1', (): void => {
-    expect(
-      keyExtractSuri('hello world/1')
-    ).toEqual({
-      path: [
-        { _isHard: false, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world/1');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(false);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world/DOT', (): void => {
-    expect(
-      keyExtractSuri('hello world/DOT')
-    ).toEqual({
-      path: [
-        { _isHard: false, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world/DOT');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(false);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world//1', (): void => {
-    expect(
-      keyExtractSuri('hello world//1')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world//1');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world//DOT', (): void => {
-    expect(
-      keyExtractSuri('hello world//DOT')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world//DOT');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world//1/DOT', (): void => {
-    expect(
-      keyExtractSuri('hello world//1/DOT')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) },
-        { _isHard: false, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world//1/DOT');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(2);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    expect(test.path[1].isHard).toEqual(false);
+    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world//DOT/1', (): void => {
-    expect(
-      keyExtractSuri('hello world//DOT/1')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) },
-        { _isHard: false, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world//DOT/1');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(2);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    expect(test.path[1].isHard).toEqual(false);
+    expect(test.path[1].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world///password"', (): void => {
-    expect(
-      keyExtractSuri('hello world///password')
-    ).toEqual({
-      password: 'password',
-      path: [],
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world///password');
+
+    expect(test.password).toEqual('password');
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(0);
   });
 
   it('derives on "hello world//1/DOT///password"', (): void => {
-    expect(
-      keyExtractSuri('hello world//1/DOT///password')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) },
-        { _isHard: false, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      password: 'password',
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world//1/DOT///password');
+
+    expect(test.password).toEqual('password');
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(2);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    expect(test.path[1].isHard).toEqual(false);
+    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on "hello world/1//DOT///password"', (): void => {
-    expect(
-      keyExtractSuri('hello world/1//DOT///password')
-    ).toEqual({
-      path: [
-        { _isHard: false, _chainCode: Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) },
-        { _isHard: true, _chainCode: Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      password: 'password',
-      phrase: 'hello world'
-    });
+    const test = keyExtractSuri('hello world/1//DOT///password');
+
+    expect(test.password).toEqual('password');
+    expect(test.phrase).toEqual('hello world');
+    expect(test.path.length).toEqual(2);
+    expect(test.path[0].isHard).toEqual(false);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    expect(test.path[1].isHard).toEqual(true);
+    expect(test.path[1].chainCode).toEqual(Uint8Array.from([12, 68, 79, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 
   it('derives on actual Alice', (): void => {
-    expect(
-      keyExtractSuri('bottom drive obey lake curtain smoke basket hold race lonely fit walk//Alice')
-    ).toEqual({
-      path: [
-        { _isHard: true, _chainCode: Uint8Array.from([20, 65, 108, 105, 99, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) }
-      ],
-      phrase: 'bottom drive obey lake curtain smoke basket hold race lonely fit walk'
-    });
+    const test = keyExtractSuri('bottom drive obey lake curtain smoke basket hold race lonely fit walk//Alice');
+
+    expect(test.password).not.toBeDefined();
+    expect(test.phrase).toEqual('bottom drive obey lake curtain smoke basket hold race lonely fit walk');
+    expect(test.path.length).toEqual(1);
+    expect(test.path[0].isHard).toEqual(true);
+    expect(test.path[0].chainCode).toEqual(Uint8Array.from([20, 65, 108, 105, 99, 101, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
   });
 });

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

@@ -7,13 +7,18 @@ import { KeypairType, Keypair } from '../types';
 import DeriveJunction from './DeriveJunction';
 import keyHdkdEd15519 from './hdkdEd25519';
 import keyHdkdSr15519 from './hdkdSr25519';
+import keyHdkdEcdsa from './hdkdEcdsa';
+
+const generators = {
+  ecdsa: keyHdkdEcdsa,
+  ed25519: keyHdkdEd15519,
+  sr25519: keyHdkdSr15519
+};
 
 export default function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
-  const isEd25519 = type === 'ed25519';
+  const keyHdkd = generators[type];
 
   return path.reduce((pair, junction): Keypair => {
-    return isEd25519
-      ? keyHdkdEd15519(pair, junction)
-      : keyHdkdSr15519(pair, junction);
+    return keyHdkd(pair, junction);
   }, pair);
 }

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

@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Keypair } from '../types';
+
+import { assert } from '@polkadot/util';
+
+import secp256k1DeriveHard from '../secp256k1/deriveHard';
+import secp256k1KeypairFromSeed from '../secp256k1/keypair/fromSeed';
+import DeriveJunction from './DeriveJunction';
+
+export default function keyHdkdEcdsa (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair {
+  assert(isHard, 'A soft key was found in the path (and is unsupported)');
+
+  return secp256k1KeypairFromSeed(
+    secp256k1DeriveHard(keypair.secretKey.subarray(0, 32), chainCode)
+  );
+}

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

@@ -10,3 +10,4 @@ export { default as keyExtractSuri } from './extractSuri';
 export { default as keyFromPath } from './fromPath';
 export { default as keyHdkdEd25519 } from './hdkdEd25519';
 export { default as keyHdkdSr25519 } from './hdkdEd25519';
+export { default as keyHdkdEcdsa } from './hdkdEcdsa';

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

@@ -11,5 +11,4 @@ import '../polyfill';
 export { default as mnemonicGenerate } from './generate';
 export { default as mnemonicToEntropy } from './toEntropy';
 export { default as mnemonicToMiniSecret } from './toMiniSecret';
-export { default as mnemonicToSeed } from './toSeed';
 export { default as mnemonicValidate } from './validate';

packages/util-crypto/src/mnemonic/toSeed.spec.ts

@@ -1,15 +0,0 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { u8aToHex } from '@polkadot/util';
-
-import toSeed from './toSeed';
-
-describe('mnemonicToSeed', (): void => {
-  it('generates a valid seed', (): void => {
-    expect(
-      u8aToHex(toSeed('seed sock milk update focus rotate barely fade car face mechanic mercy'))
-    ).toEqual('0x3c121e20de068083b49c2315697fb59a2d9e8643c24e5ea7628132c58969a027');
-  });
-});

packages/util-crypto/src/mnemonic/toSeed.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
-// This software may be modified and distributed under the terms
-// of the Apache-2.0 license. See the LICENSE file for details.
-
-import { mnemonicToSeedSync } from 'bip39';
-import { bufferToU8a } from '@polkadot/util';
-import { bip39ToSeed, isReady } from '@polkadot/wasm-crypto';
-
-/**
- * @name toSeed
- * @summary Creates a valid seed from a mnemonic input
- * @example
- * <BR>
- *
- * ```javascript
- * import { mnemonicGenerate, mnemonicToSeed, mnemonicValidate } from '@polkadot/util-crypto';
- *
- * const mnemonic = mnemonicGenerate(); // => string
- * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
- *
- * if (isValidMnemonic) {
- *   console.log(`Seed generated from mnemonic: ${mnemonicToSeed(mnemonic)}`); => u8a
- * }
- * ```
- */
-export default function toSeed (mnemonic: string, password = ''): Uint8Array {
-  return isReady()
-    ? bip39ToSeed(mnemonic, password)
-    : bufferToU8a(mnemonicToSeedSync(mnemonic, password)).subarray(0, 32);
-}

packages/util-crypto/src/nacl/open.spec.ts

@@ -13,8 +13,8 @@ describe('naclOpen', (): void => {
     const receiver = naclKeypairFromString('receiver');
     const senderBox = naclBoxKeypairFromSecret(sender.secretKey);
     const receiverBox = naclBoxKeypairFromSecret(receiver.secretKey);
+    const { nonce, sealed } = naclSeal(message, senderBox.secretKey, receiverBox.publicKey);
 
-    const { sealed, nonce } = naclSeal(message, senderBox.secretKey, receiverBox.publicKey);
     expect(
       naclOpen(sealed, nonce, senderBox.publicKey, receiverBox.secretKey)
     ).toEqual(
@@ -32,17 +32,20 @@ describe('naclOpen', (): void => {
 
     // Receiver sends encrypting public key to receive message to decrypt with his private key
     const receiverIdBoxKey = naclBoxKeypairFromSecret(receiverIdKey.secretKey);
-    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey.publicKey}`);
+
+    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey.publicKey.toString()}`);
 
     // Sender encrypts message to send with the public key the receiver sent and send it to receiver
     const senderIdBoxKey = naclBoxKeypairFromSecret(senderIdKey.secretKey);
     const message = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
-    const { sealed, nonce } = naclSeal(message, senderIdBoxKey.secretKey, receiverIdBoxKey.publicKey);
-    console.log(`Sender sends encrypted message to receiver ${sealed}, ${nonce}`);
+    const { nonce, sealed } = naclSeal(message, senderIdBoxKey.secretKey, receiverIdBoxKey.publicKey);
+
+    console.log(`Sender sends encrypted message to receiver ${sealed.toString()}, ${nonce.toString()}`);
 
     // Receiver opens encrypted message from the sender
     let opened = naclOpen(sealed, nonce, senderIdBoxKey.publicKey, receiverIdBoxKey.secretKey);
-    console.log(`The sealed message is ${opened}`);
+
+    console.log(`The sealed message is ${opened?.toString() || 'null'}`);
 
     // Oh no the Id key is hacked, derive Id key again from another index
     const senderIdKey2 = fromPath(sender, keyExtractPath('//1//1//1//2').path, 'ed25519');
@@ -50,7 +53,8 @@ describe('naclOpen', (): void => {
 
     // Receiver sends encrypting public key to receive message to decrypt with his private key
     const receiverIdBoxKey2 = naclBoxKeypairFromSecret(receiverIdKey2.secretKey);
-    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2.publicKey}`);
+
+    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2.publicKey.toString()}`);
 
     // Sender encrypts message to send with the public key the receiver sent and send it to receiver
     const senderIdBoxKey2 = naclBoxKeypairFromSecret(senderIdKey2.secretKey);
@@ -58,28 +62,33 @@ describe('naclOpen', (): void => {
     let ctx = naclSeal(message2, senderIdBoxKey2.secretKey, receiverIdBoxKey2.publicKey);
     const sealed2 = ctx.sealed;
     const nonce2 = ctx.nonce;
-    console.log(`Sender sends encrypted message to receiver ${sealed}, ${nonce}`);
+
+    console.log(`Sender sends encrypted message to receiver ${sealed.toString()}, ${nonce.toString()}`);
 
     // Receiver opens encrypted message from the sender
     opened = naclOpen(sealed2, nonce2, senderIdBoxKey2.publicKey, receiverIdBoxKey2.secretKey);
-    console.log(`The sealed message is ${opened}`);
+    console.log(`The sealed message is ${opened?.toString() || 'null'}`);
 
     // This time derive key for each message to send and receive
     // Receiver sends encrypting public key to receive message to decrypt with his private key
     const receiverIdBoxKey2One = naclBoxKeypairFromSecret(receiverIdBoxKey2.secretKey);
-    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2One.publicKey}`);
+
+    console.log(`Receiver sends receiver's public key to sender ${receiverIdBoxKey2One.publicKey.toString()}`);
 
     // Sender encrypts message to send with the public key the receiver sent and send it to receiver
     const senderIdBoxKey2One = naclBoxKeypairFromSecret(senderIdBoxKey2.secretKey);
     const message3 = new Uint8Array([1, 2, 3, 4, 5, 4, 3, 2, 1]);
+
     ctx = naclSeal(message3, senderIdBoxKey2One.secretKey, receiverIdBoxKey2One.publicKey);
+
     const sealed3 = ctx.sealed;
     const nonce3 = ctx.nonce;
-    console.log(`Sender sends encrypted message to receiver ${sealed3}, ${nonce3}`);
+
+    console.log(`Sender sends encrypted message to receiver ${sealed3.toString()}, ${nonce3.toString()}`);
 
     // Receiver opens encrypted message from the sender
     opened = naclOpen(sealed2, nonce2, senderIdBoxKey2One.publicKey, receiverIdBoxKey2One.secretKey);
-    console.log(`The sealed message is ${opened}`);
+    console.log(`The sealed message is ${opened?.toString() || 'null'}`);
   });
 
   it('returns null on invalid', (): void => {

packages/util-crypto/src/nacl/seal.spec.ts

@@ -13,11 +13,12 @@ describe('naclSeal', (): void => {
     const receiverBox = naclBoxKeypairFromSecret(receiver.secretKey);
     const senderBoxSecret = senderBox.secretKey;
     const receiverBoxPublic = receiverBox.publicKey;
+
     expect(
       naclSeal(message, senderBoxSecret, receiverBoxPublic, new Uint8Array(24))
     ).toEqual({
-      sealed: new Uint8Array([137, 195, 104, 255, 67, 199, 40, 235, 148, 177, 180, 73, 239, 131, 215, 80, 61, 191, 167, 213, 152, 138, 5, 47, 135]),
-      nonce: new Uint8Array(24)
+      nonce: new Uint8Array(24),
+      sealed: new Uint8Array([137, 195, 104, 255, 67, 199, 40, 235, 148, 177, 180, 73, 239, 131, 215, 80, 61, 191, 167, 213, 152, 138, 5, 47, 135])
     });
   });
 });

packages/util-crypto/src/nacl/seal.ts

@@ -27,7 +27,7 @@ interface Sealed {
  */
 export default function naclSeal (message: Uint8Array, senderBoxSecret: Uint8Array, receiverBoxPublic: Uint8Array, nonce: Uint8Array = randomAsU8a(24)): Sealed {
   return {
-    sealed: nacl.box(message, nonce, receiverBoxPublic, senderBoxSecret),
-    nonce
+    nonce,
+    sealed: nacl.box(message, nonce, receiverBoxPublic, senderBoxSecret)
   };
 }

packages/util-crypto/src/nacl/sign.ts

@@ -23,7 +23,7 @@ import { isReady, ed25519Sign } from '@polkadot/wasm-crypto';
  * ```
  */
 export default function naclSign (message: Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
-  assert(secretKey, 'Expected valid secretKey');
+  assert(secretKey, 'Expected a valid secretKey');
 
   const messageU8a = u8aToU8a(message);
 

packages/util-crypto/src/nacl/verify.spec.ts

@@ -7,7 +7,7 @@ import { waitReady } from '@polkadot/wasm-crypto';
 
 import { naclVerify, naclKeypairFromSeed } from '.';
 
-describe('naclSign', (): void => {
+describe('naclVerify', (): void => {
   let publicKey: Uint8Array;
   let signature: Uint8Array;
 
@@ -51,4 +51,24 @@ describe('naclSign', (): void => {
       )
     ).toEqual(false);
   });
+
+  it('throws error when publicKey lengths do not match', (): void => {
+    expect(
+      () => naclVerify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+        signature,
+        new Uint8Array([1, 2])
+      )
+    ).toThrow(/Invalid publicKey/);
+  });
+
+  it('throws error when signature lengths do not match', (): void => {
+    expect(
+      () => naclVerify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+        new Uint8Array([1, 2]),
+        publicKey
+      )
+    ).toThrow(/Invalid signature/);
+  });
 });

packages/util-crypto/src/nacl/verify.ts

@@ -3,14 +3,14 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import nacl from 'tweetnacl';
-import { u8aToU8a } from '@polkadot/util';
+import { assert, u8aToU8a } from '@polkadot/util';
 import { isReady, ed25519Verify } from '@polkadot/wasm-crypto';
 
 /**
  * @name naclSign
  * @summary Verifies the signature on the supplied message.
  * @description
- * Verifies the `signature` on `message` with the supplied `plublicKey`. Returns `true` on sucess, `false` otherwise.
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
  * @example
  * <BR>
  *
@@ -22,8 +22,11 @@ import { isReady, ed25519Verify } from '@polkadot/wasm-crypto';
  */
 export default function naclVerify (message: Uint8Array | string, signature: Uint8Array | string, publicKey: Uint8Array | string): boolean {
   const messageU8a = u8aToU8a(message);
-  const signatureU8a = u8aToU8a(signature);
   const publicKeyU8a = u8aToU8a(publicKey);
+  const signatureU8a = u8aToU8a(signature);
+
+  assert(publicKeyU8a.length === 32, `Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+  assert(signatureU8a.length === 64, `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
 
   return isReady()
     ? ed25519Verify(signatureU8a, messageU8a, publicKeyU8a)

packages/util-crypto/src/noWasm.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+export function isReady (): boolean {
+  // always false, when true it will try and use non-existent functions
+  return false;
+}
+
+export function waitReady (): Promise<boolean> {
+  // always immediate true, our process is done
+  return Promise.resolve(true);
+}

packages/util-crypto/src/schnorrkel/sign.ts

@@ -14,8 +14,8 @@ import { sr25519Sign } from '@polkadot/wasm-crypto';
  * @description Returns message signature of `message`, using the supplied pair
  */
 export default function schnorrkelSign (message: Uint8Array | string, { publicKey, secretKey }: Partial<Keypair>): Uint8Array {
-  assert(publicKey?.length === 32, 'Expected valid publicKey, 32-bytes');
-  assert(secretKey?.length === 64, 'Expected valid secretKey, 64-bytes');
+  assert(publicKey?.length === 32, 'Expected a valid publicKey, 32-bytes');
+  assert(secretKey?.length === 64, 'Expected a valid secretKey, 64-bytes');
 
   const messageU8a = u8aToU8a(message);
 

packages/util-crypto/src/schnorrkel/signVerify.spec.ts

@@ -29,4 +29,24 @@ describe('sign and verify', (): void => {
 
     expect(verify(MESSAGE, signature, pair.publicKey)).toBe(true);
   });
+
+  it('throws error when publicKey lengths do not match', (): void => {
+    expect(
+      () => verify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+        new Uint8Array(64),
+        new Uint8Array(31)
+      )
+    ).toThrow(/Invalid publicKey/);
+  });
+
+  it('throws error when signature lengths do not match', (): void => {
+    expect(
+      () => verify(
+        new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+        new Uint8Array(65),
+        new Uint8Array(32)
+      )
+    ).toThrow(/Invalid signature/);
+  });
 });

packages/util-crypto/src/schnorrkel/verify.ts

@@ -4,7 +4,7 @@
 
 import '../polyfill';
 
-import { u8aToU8a } from '@polkadot/util';
+import { assert, u8aToU8a } from '@polkadot/util';
 import { sr25519Verify } from '@polkadot/wasm-crypto';
 
 /**
@@ -13,8 +13,11 @@ import { sr25519Verify } from '@polkadot/wasm-crypto';
  */
 export default function schnorrkelVerify (message: Uint8Array | string, signature: Uint8Array | string, publicKey: Uint8Array | string): boolean {
   const messageU8a = u8aToU8a(message);
-  const signatureU8a = u8aToU8a(signature);
   const publicKeyU8a = u8aToU8a(publicKey);
+  const signatureU8a = u8aToU8a(signature);
+
+  assert(publicKeyU8a.length === 32, `Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+  assert(signatureU8a.length === 64, `Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
 
   return sr25519Verify(signatureU8a, messageU8a, publicKeyU8a);
 }

packages/util-crypto/src/secp256k1/deriveHard.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { compactAddLength, stringToU8a, u8aConcat } from '@polkadot/util';
+
+import blake2AsU8a from '../blake2/asU8a';
+
+const HDKD = compactAddLength(stringToU8a('Secp256k1HDKD'));
+
+export default function deriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
+  return blake2AsU8a(u8aConcat(HDKD, seed, chainCode), 256);
+}

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

@@ -2,4 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
+export { default as secp256k1KeypairFromSeed } from './keypair/fromSeed';
 export { default as secp256k1Recover } from './recover';
+export { default as secp256k1Verify } from './verify';
+export { default as secp256k1Sign } from './sign';

packages/util-crypto/src/secp256k1/keypair/fromSeed.spec.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aToHex, hexToU8a } from '@polkadot/util';
+
+import { mnemonicToMiniSecret } from '../../mnemonic';
+import { secp256k1KeypairFromSeed } from '..';
+import tests from './testing';
+
+describe('secp256k1KeypairFromSeed', (): void => {
+  const TEST = hexToU8a('0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae');
+  const RESULT = {
+    publicKey: hexToU8a('0x03fd8c74f795ced92064b86191cb2772b1e3a0947740aa0a5a6e379592471fd85b'),
+    secretKey: hexToU8a('0x4380de832af797688026ce24f85204d508243f201650c1a134929e5458b7fbae')
+  };
+
+  it('generates a valid publicKey/secretKey pair (u8a)', (): void => {
+    expect(secp256k1KeypairFromSeed(TEST)).toEqual(RESULT);
+  });
+
+  tests.forEach(([mnemonic, secretKey, publicKey], index): void => {
+    it(`creates valid against known (${index})`, (): void => {
+      const seed = mnemonicToMiniSecret(mnemonic);
+      const pair = secp256k1KeypairFromSeed(seed);
+
+      expect(u8aToHex(pair.secretKey)).toEqual(secretKey);
+      expect(u8aToHex(pair.publicKey)).toEqual(publicKey);
+    });
+  });
+});

packages/util-crypto/src/secp256k1/keypair/fromSeed.ts

@@ -0,0 +1,25 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Keypair } from '../../types';
+import { assert, hexToU8a } from '@polkadot/util';
+import elliptic from 'elliptic';
+
+const EC = elliptic.ec;
+const ec = new EC('secp256k1');
+
+/**
+ * @name secp256k1KeypairFromSeed
+ * @description Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ */
+export default function secp256k1KeypairFromSeed (seed: Uint8Array): Keypair {
+  assert(seed.length === 32, 'Expected valid 32-byte private key as a seed');
+
+  const key = ec.keyFromPrivate(seed);
+
+  return {
+    publicKey: new Uint8Array(key.getPublic().encodeCompressed('array')),
+    secretKey: hexToU8a(`0x${key.getPrivate('hex')}`)
+  };
+}

packages/util-crypto/src/secp256k1/keypair/testing.ts

@@ -0,0 +1,35 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// mnemonic, secret, public, account_id
+type Test = [string, string, string, string];
+
+const tests: Test[] = [
+  [
+    'life fee table ahead modify maximum dumb such tobacco boss dry nurse',
+    '0xf2360e871c830d397fe221382b503f07ddd8763df81a94bb2504390a2fb91f59',
+    '0x036b0aa6beab469dd2b748a0ff5ddbe3d13df1e15c9d28a2aa057212994e127bea',
+    '0xae8e8fcacbaeb607bcdf0bbd7e615f2b4ef484ee54f19d68a7393fb6db2dd9cd'
+  ],
+  [
+    'tide survey cradle cover column ugly author wait eye state elder blame',
+    '0x5385355a5118ec732b9dbcf1668ba21db38b07cf79082dafa9a7cc4b52e4abb0',
+    '0x03929e4f93cdad265751ad8f6365185d8e937610d19b510400f5867d542d60a313',
+    '0xf80ea815da66c42f870b687e1530770d5a7936ae81a147b009506d85bd6d621c'
+  ],
+  [
+    'laugh fish flee cake approve butter april dynamic myth license ticket lobster',
+    '0x83ec65cf9a8a7442d808aef6f8987599f1ba3be880769bb3a20621b13adbd476',
+    '0x0388299e4cfaa33d180a026bd54a46ad98df129a131320a9d2fd6f80e64bc3db39',
+    '0x35036238dd195f4c2169379354bda6cba5746f67bde03ef59a77a4cea80729bc'
+  ],
+  [
+    'animal thing fork recipe exotic pilot inquiry pledge obey slab obtain reveal',
+    '0x0fd50580eb5a58b0eee60c77656dffa50094b539262366f1227d3babfd7343e5',
+    '0x036edc954685ad89f0a23b0fb1eb2b9c3a8600eee9091c758426dfb2bc7889a7c3',
+    '0x2a94b10d1f28810dc4628e7e424b2d08bd3d17fb08f9416d112f17e86c8fa77c'
+  ]
+];
+
+export default tests;

packages/util-crypto/src/secp256k1/recover.ts

@@ -13,6 +13,7 @@ const ec = new EC('secp256k1');
  */
 export default function secp256k1Recover (message: Uint8Array, signature: Uint8Array, recovery: number): Uint8Array {
   return new Uint8Array(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
     ec
       .recoverPubKey(message, { r: signature.slice(0, 32), s: signature.slice(32, 64) }, recovery)
       .encode(null, true)

packages/util-crypto/src/secp256k1/sign.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Keypair } from '../types';
+import { assert, u8aToU8a, u8aConcat } from '@polkadot/util';
+import { blake2AsU8a } from '../blake2';
+import elliptic from 'elliptic';
+
+const EC = elliptic.ec;
+const ec = new EC('secp256k1');
+
+/**
+ * @name secp256k1Sign
+ * @description Returns message signature of `message`, using the supplied pair
+ */
+export default function secp256k1Sign (message: Uint8Array | string, { secretKey }: Partial<Keypair>): Uint8Array {
+  assert(secretKey?.length === 32, 'Expected valid secp256k1 secretKey, 32-bytes');
+
+  const messageHash = blake2AsU8a(u8aToU8a(message), 256);
+  const key = ec.keyFromPrivate(secretKey);
+  const ecsig = key.sign(messageHash);
+  const rParam = new Uint8Array(ecsig.r.toArray());
+  const sParam = new Uint8Array(ecsig.s.toArray());
+  const recoveryParam = Uint8Array.of(ecsig.recoveryParam || 0);
+
+  return u8aConcat(rParam, sParam, recoveryParam);
+}

packages/util-crypto/src/secp256k1/signVerify.spec.ts

@@ -0,0 +1,36 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { stringToU8a } from '@polkadot/util';
+import { blake2AsU8a } from '../blake2';
+import randomAsU8a from '../random/asU8a';
+import pairFromSeed from './keypair/fromSeed';
+import sign from './sign';
+import verify from './verify';
+
+const MESSAGE = stringToU8a('this is a message');
+
+describe('sign and verify', (): void => {
+  it('verify message signature', (): void => {
+    const address = '0x59f587c045d4d4e9aa1016eae43770fc0551df8a385027723342753a876aeef0';
+    const sig = '0x92fcacf0946bbd10b31dfe16d567ed1d3014e81007dd9e5256e19c0f07eacc1643b151ca29e449a765e16a7ce59b88d800467d6b3412d30ea8ad22307a59664b00';
+    const msg = stringToU8a('secp256k1');
+
+    expect(verify(msg, sig, address)).toBe(true);
+  });
+
+  it('has 65-byte signatures', (): void => {
+    const pair = pairFromSeed(randomAsU8a());
+
+    expect(sign(MESSAGE, pair)).toHaveLength(65);
+  });
+
+  it('can sign and verify a message by random key', (): void => {
+    const pair = pairFromSeed(randomAsU8a());
+    const signature = sign(MESSAGE, pair);
+    const address = blake2AsU8a(pair.publicKey, 256);
+
+    expect(verify(MESSAGE, signature, address)).toBe(true);
+  });
+});

packages/util-crypto/src/secp256k1/verify.ts

@@ -0,0 +1,30 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aToU8a } from '@polkadot/util';
+import { blake2AsU8a } from '../blake2';
+import elliptic from 'elliptic';
+
+const EC = elliptic.ec;
+const ec = new EC('secp256k1');
+
+/**
+ * @name secp256k1Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+export default function secp256k1Verify (message: Uint8Array | string, signature: Uint8Array | string, address: Uint8Array | string): boolean {
+  const signatureU8a = u8aToU8a(signature);
+  const sig = {
+    r: signatureU8a.slice(0, 32),
+    s: signatureU8a.slice(32, 64)
+  };
+  const recovery = signatureU8a[64];
+  const publicKey = new Uint8Array(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    ec.recoverPubKey(blake2AsU8a(message, 256), sig, recovery)
+      .encodeCompressed(null)
+  );
+
+  return Buffer.compare(blake2AsU8a(publicKey, 256), u8aToU8a(address)) === 0;
+}

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

@@ -0,0 +1,9 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @summary Utilities for working with signatures
+ */
+
+export { default as signatureVerify } from './verify';

packages/util-crypto/src/signature/verify.spec.ts

@@ -0,0 +1,99 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { hexToU8a, stringToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
+import { waitReady } from '@polkadot/wasm-crypto';
+
+import { decodeAddress } from '../address';
+import { signatureVerify } from '.';
+
+const ADDR_ED = 'DxN4uvzwPzJLtn17yew6jEffPhXQfdKHTp2brufb98vGbPN';
+const ADDR_SR = 'EK1bFgKm2FsghcttHT7TB7rNyXApFgs9fCbijMGQNyFGBQm';
+const ADDR_EC = 'XyFVXiGaHxoBhXZkSh6NS2rjFyVaVNUo5UiZDqZbuSfUdji';
+const MESSAGE = 'hello world';
+const SIG_ED = '0x299d3bf4c8bb51af732f8067b3a3015c0862a5ff34721749d8ed6577ea2708365d1c5f76bd519009971e41156f12c70abc2533837ceb3bad9a05a99ab923de06';
+const SIG_SR = '0xca01419b5a17219f7b78335658cab3b126db523a5df7be4bfc2bef76c2eb3b1dcf4ca86eb877d0a6cf6df12db5995c51d13b00e005d053b892bd09c594434288';
+const SIG_EC = '0x994638ee586d2c5dbd9bacacbc35d9b7e9018de8f7892f00c900db63bc57b1283e2ee7bc51a9b1c1dae121ac4f4b9e2a41cd1d6bf4bb3e24d7fed6faf6d85e0501';
+const MUL_ED = u8aToHex(u8aConcat(new Uint8Array([0]), hexToU8a(SIG_ED)));
+const MUL_SR = u8aToHex(u8aConcat(new Uint8Array([1]), hexToU8a(SIG_SR)));
+const MUL_EC = u8aToHex(u8aConcat(new Uint8Array([2]), hexToU8a(SIG_EC)));
+
+describe('signatureVerify', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  it('throws on invalid signature length', (): void => {
+    expect(
+      () => signatureVerify(MESSAGE, new Uint8Array(32), ADDR_ED)
+    ).toThrow('Invalid signature length, expected [64..66] bytes, found 32');
+  });
+
+  describe('verifyDetect', (): void => {
+    it('verifies an ed25519 signature', (): void => {
+      expect(signatureVerify(MESSAGE, SIG_ED, ADDR_ED)).toEqual({
+        crypto: 'ed25519',
+        isValid: true
+      });
+    });
+
+    it('verifies an ecdsa signature', (): void => {
+      expect(signatureVerify(MESSAGE, SIG_EC, ADDR_EC)).toEqual({
+        crypto: 'ecdsa',
+        isValid: true
+      });
+    });
+
+    it('verifies an sr25519 signature', (): void => {
+      expect(signatureVerify(MESSAGE, SIG_SR, ADDR_SR)).toEqual({
+        crypto: 'sr25519',
+        isValid: true
+      });
+    });
+
+    it('allows various inputs', (): void => {
+      expect(signatureVerify(stringToU8a(MESSAGE), hexToU8a(SIG_ED), decodeAddress(ADDR_ED))).toEqual({
+        crypto: 'ed25519',
+        isValid: true
+      });
+    });
+
+    it('fails on an invalid signature', (): void => {
+      expect(signatureVerify(MESSAGE, SIG_SR, ADDR_ED)).toEqual({
+        crypto: 'none',
+        isValid: false
+      });
+    });
+  });
+
+  describe('verifyMultisig', (): void => {
+    it('verifies an ed25519 signature', (): void => {
+      expect(signatureVerify(MESSAGE, MUL_ED, ADDR_ED)).toEqual({
+        crypto: 'ed25519',
+        isValid: true
+      });
+    });
+
+    it('verifies an ecdsa signature', (): void => {
+      expect(signatureVerify(MESSAGE, MUL_EC, ADDR_EC)).toEqual({
+        crypto: 'ecdsa',
+        isValid: true
+      });
+    });
+
+    it('verifies an sr25519 signature', (): void => {
+      expect(signatureVerify(MESSAGE, MUL_SR, ADDR_SR)).toEqual({
+        crypto: 'sr25519',
+        isValid: true
+      });
+    });
+
+    it('fails on an invalid signature', (): void => {
+      expect(signatureVerify(MESSAGE, MUL_SR, ADDR_ED)).toEqual({
+        crypto: 'sr25519',
+        isValid: false
+      });
+    });
+  });
+});

packages/util-crypto/src/signature/verify.ts

@@ -0,0 +1,77 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { KeypairType, VerifyResult } from '../types';
+
+import { assert, u8aToU8a } from '@polkadot/util';
+
+import addressDecode from '../address/decode';
+import naclVerify from '../nacl/verify';
+import schnorrkelVerify from '../schnorrkel/verify';
+import secp256k1Verify from '../secp256k1/verify';
+
+const VERIFIERS: [KeypairType, (message: Uint8Array | string, signature: Uint8Array | string, publicKey: Uint8Array | string) => boolean][] = [
+  ['ed25519', naclVerify],
+  ['sr25519', schnorrkelVerify],
+  ['ecdsa', secp256k1Verify]
+];
+
+const CRYPTO_TYPES: KeypairType[] = [
+  'ed25519',
+  'sr25519',
+  'ecdsa'
+];
+
+function verifyDetect (result: VerifyResult, message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array): VerifyResult {
+  result.isValid = VERIFIERS.some(([crypto, verify]): boolean => {
+    try {
+      if (verify(message, signature, publicKey)) {
+        result.crypto = crypto;
+
+        return true;
+      }
+    } catch (error) {
+      // do nothing, result.isValid still set to false
+    }
+
+    return false;
+  });
+
+  return result;
+}
+
+function verifyMultisig (result: VerifyResult, message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array): VerifyResult {
+  assert([0, 1, 2].includes(signature[0]), `Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
+
+  result.crypto = CRYPTO_TYPES[signature[0]] || 'none';
+
+  try {
+    result.isValid = {
+      ecdsa: (): boolean => secp256k1Verify(message, signature.subarray(1), publicKey),
+      ed25519: (): boolean => naclVerify(message, signature.subarray(1), publicKey),
+      none: (): boolean => { throw Error('no verify for `none` crypto type'); },
+      sr25519: (): boolean => schnorrkelVerify(message, signature.subarray(1), publicKey)
+    }[result.crypto]();
+  } catch (error) {
+    // ignore, result.isValid still set to false
+  }
+
+  return result;
+}
+
+export default function signatureVerify (message: Uint8Array | string, signature: Uint8Array | string, addressOrPublicKey: Uint8Array | string): VerifyResult {
+  const signatureU8a = u8aToU8a(signature);
+
+  assert([64, 65, 66].includes(signatureU8a.length), `Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
+
+  const result: VerifyResult = { crypto: 'none', isValid: false };
+  const publicKey = addressDecode(addressOrPublicKey);
+  const isMultisig = [0, 1, 2].includes(signatureU8a[0]) && [65, 66].includes(signatureU8a.length);
+
+  if (isMultisig) {
+    return verifyMultisig(result, message, signatureU8a, publicKey);
+  } else {
+    return verifyDetect(result, message, signatureU8a, publicKey);
+  }
+}

packages/util-crypto/src/types.ts

@@ -12,4 +12,9 @@ export interface Seedpair {
   seed: Uint8Array;
 }
 
-export type KeypairType = 'ed25519' | 'sr25519';
+export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa';
+
+export interface VerifyResult {
+  crypto: 'none' | KeypairType;
+  isValid: boolean;
+}

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util",
-  "version": "2.3.1",
+  "version": "2.13.1",
   "description": "A collection of useful utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,13 +25,11 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util#readme",
   "dependencies": {
-    "@babel/runtime": "^7.8.4",
-    "bn.js": "^5.1.1",
+    "@babel/runtime": "^7.10.2",
+    "@types/bn.js": "^4.11.6",
+    "bn.js": "^5.1.2",
     "camelcase": "^5.3.1",
-    "chalk": "^3.0.0",
+    "chalk": "^4.0.0",
     "ip-regex": "^4.1.0"
-  },
-  "devDependencies": {
-    "@types/bn.js": "^4.11.6"
   }
 }

packages/util/src/array/filter.ts

@@ -21,8 +21,8 @@ import isUndefined from '../is/undefined';
  * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function arrayFilter (array: any[], allowNulls = true): any[] {
-  return array.filter((value): boolean => {
-    return !isUndefined(value) && (allowNulls || !isNull(value));
-  });
+export default function arrayFilter <T = any> (array: T[], allowNulls = true): T[] {
+  return array.filter((value) =>
+    !isUndefined(value) && (allowNulls || !isNull(value))
+  );
 }

packages/util/src/assert.ts

@@ -22,8 +22,7 @@ type MessageFn = () => string;
  * assert(false, () => 'message'); // Error with 'message'
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function assert (condition: any, message: string | MessageFn): asserts condition {
+export default function assert (condition: unknown, message: string | MessageFn): asserts condition {
   if (!condition) {
     throw new Error(
       isFunction(message)

packages/util/src/bn/index.ts

@@ -9,6 +9,7 @@
 export { default as bnFromHex } from './fromHex';
 export { default as bnMax } from './max';
 export { default as bnMin } from './min';
+export { default as bnSqrt } from './sqrt';
 export { default as bnToBn } from './toBn';
 export { default as bnToHex } from './toHex';
 export { default as bnToU8a } from './toU8a';

packages/util/src/bn/max.ts

@@ -7,20 +7,20 @@ import BN from 'bn.js';
 import assert from '../assert';
 
 /**
- * @name max
+ * @name bnMax
  * @summary Finds and returns the highest value in an array of BNs.
  * @example
  * <BR>
  *
  * ```javascript
  * import BN from 'bn.js';
- * import { max } from '@polkadot/util';
+ * import { bnMax } from '@polkadot/util';
  *
- * max([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'
+ * bnMax([new BN(1), new BN(3), new BN(2)]).toString(); // => '3'
  * ```
  */
 export default function max (...items: BN[]): BN {
   assert(items && items.length >= 1, 'Must provide one or more BN arguments');
 
-  return items.reduce((acc: BN, val: BN): BN => BN.max(acc, val), items[0]);
+  return items.reduce((acc: BN, val: BN) => BN.max(acc, val), items[0]);
 }

packages/util/src/bn/min.ts

@@ -7,20 +7,20 @@ import BN from 'bn.js';
 import assert from '../assert';
 
 /**
- * @name min
+ * @name bnMin
  * @summary Finds and returns the smallest value in an array of BNs.
  * @example
  * <BR>
  *
  * ```javascript
  * import BN from 'bn.js';
- * import { min } from '@polkadot/util';
+ * import { bnMin } from '@polkadot/util';
  *
- * min([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'
+ * bnMin([new BN(1), new BN(3), new BN(2)]).toString(); // => '1'
  * ```
  */
 export default function min (...items: BN[]): BN {
   assert(items && items.length >= 1, 'Must provide one or more BN arguments');
 
-  return items.reduce((acc: BN, val: BN): BN => BN.min(acc, val), items[0]);
+  return items.reduce((acc: BN, val: BN) => BN.min(acc, val), items[0]);
 }

packages/util/src/bn/sqrt.spec.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import BN from 'bn.js';
+
+import { bnSqrt } from '.';
+
+describe('bnSqrt', (): void => {
+  it('fails on < 0 roots', (): void => {
+    expect(
+      () => bnSqrt(new BN(-1))
+    ).toThrow(/negative numbers is not supported/);
+  });
+
+  it('finds the sqrt (exact)', (): void => {
+    expect(
+      bnSqrt(new BN(256).mul(new BN(256)))
+    ).toEqual(new BN(256));
+  });
+
+  it('finds the sqrt (round)', (): void => {
+    expect(
+      bnSqrt(new BN(266))
+    ).toEqual(new BN(16));
+  });
+
+  it('find the sqrt for 1', (): void => {
+    expect(
+      bnSqrt(new BN(1))
+    ).toEqual(new BN(1));
+  });
+});

packages/util/src/bn/sqrt.ts

@@ -0,0 +1,39 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import BN from 'bn.js';
+
+import assert from '../assert';
+
+// https://golb.hplar.ch/2018/09/javascript-bigint.html
+function newtonIteration (n: BN, x0: BN): BN {
+  const x1 = n.div(x0).add(x0).shrn(1);
+
+  if (x0.eq(x1) || x0.eq(x1.subn(1))) {
+    return x0;
+  }
+
+  return newtonIteration(n, x1);
+}
+
+/**
+ * @name bnSqrt
+ * @summary Calculates the integer square root of a BN
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnSqrt } from '@polkadot/util';
+ *
+ * bnSqrt(new BN(16)).toString(); // => '4'
+ * ```
+ */
+export default function sqrt (value: BN): BN {
+  assert(value.gten(0), 'square root of negative numbers is not supported');
+
+  return value.ltn(2)
+    ? value
+    : newtonIteration(value, new BN(1));
+}

packages/util/src/bn/toBn.spec.ts

@@ -19,6 +19,12 @@ describe('bnToBn', (): void => {
     ).toEqual(128);
   });
 
+  it('converts BigInt values to BN', (): void => {
+    expect(
+      bnToBn(128821n).toNumber()
+    ).toEqual(128821);
+  });
+
   it('converts number values to BN', (): void => {
     expect(
       bnToBn(128).toNumber()
@@ -40,8 +46,8 @@ describe('bnToBn', (): void => {
   it('converts Compact to BN', (): void => {
     expect(
       bnToBn({
-        toBn: (): BN => new BN(1234),
-        something: 'test'
+        something: 'test',
+        toBn: (): BN => new BN(1234)
       }).toNumber()
     ).toEqual(1234);
   });

packages/util/src/bn/toBn.ts

@@ -6,15 +6,16 @@ import { ToBn } from '../types';
 
 import BN from 'bn.js';
 
+import isBigInt from '../is/bigInt';
 import isToBn from '../is/toBn';
 import isHex from '../is/hex';
 import hexToBn from '../hex/toBn';
 
 /**
  * @name bnToBn
- * @summary Creates a BN value from a BN.js bignumber or number input.
+ * @summary Creates a BN value from a BN, BigInt, string (base 10 or hex) or number input.
  * @description
- * `null` inputs returns a `0x0` result, BN values returns the value, numnbers returns a BN representation.
+ * `null` inputs returns a `0x0` result, BN values returns the value, numbers returns a BN representation.
  * @example
  * <BR>
  *
@@ -26,11 +27,13 @@ import hexToBn from '../hex/toBn';
  * bnToBn(new BN(0x1234)); // => BN(0x1234)
  * ```
  */
-export default function bnToBn <ExtToBn extends ToBn> (value?: ExtToBn | BN | string | number | null): BN {
+export default function bnToBn <ExtToBn extends ToBn> (value?: ExtToBn | BN | BigInt | string | number | null): BN {
   if (!value) {
     return new BN(0);
   } else if (isHex(value)) {
     return hexToBn(value.toString());
+  } else if (isBigInt(value)) {
+    return new BN(value.toString());
   }
 
   return BN.isBN(value)