[CI Skip] release/stable 3.5.1

skip-checks: true
3.5 (#694 )
2020-09-27 08:05:00 +00:00 · 2020-09-27 09:58:54 +02:00 · 2020-09-27 09:49:47 +02:00 · 2020-09-25 15:12:38 +00:00 · 2020-09-25 17:06:04 +02:00 · 2020-09-25 11:17:25 +00:00
398 changed files with 7296 additions and 5775 deletions
@@ -1 +1,4 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 module.exports = require('./babel.config.js');
@@ -1,3 +1,6 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
 const base = require('@polkadot/dev/config/eslint');

 module.exports = {
@@ -7,5 +10,10 @@ module.exports = {
    project: [
      './tsconfig.json'
    ]
+  },
+  rules: {
+    ...base.rules,
+    // this seems very broken atm, false positives
+    '@typescript-eslint/unbound-method': 'off'
  }
 };
@@ -5,7 +5,7 @@ enableProgressBars: false
 nodeLinker: node-modules

 plugins:
-  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.js
+  - path: .yarn/plugins/@yarnpkg/plugin-interactive-tools.cjs
    spec: "@yarnpkg/plugin-interactive-tools"

-yarnPath: .yarn/releases/yarn-rc.js
+yarnPath: .yarn/releases/yarn-2.2.2.cjs
@@ -1,140 +1,338 @@
 # CHANGELOG

+## 3.5.1 Sep 27, 2020
+
+Contributed:
+
+- Add Dock network identifiers (Thanks to https://github.com/lovesh)
+
+Changes:
+
+- Use cross-environment TextDecoder & TextEncoder from the polkadot-js polyfills
+- Add `isBase{32, 58, 64}` to `@polkadot/util-crypto`
+- Add `base64{Pad, Trim}` to add/remove padding characters
+- Add `createFromJson(json)` to keyring (create pair without adding)
+- Balance formatter now outputs 4 numbers after the decimal point
+
+
+## 3.4.1 Aug 31, 2020
+
+Changes:
+
+- Allow for WASM-as-available `mnemonicToBip39` call (used for Ethereum-compatible keypairs)
+- Add `isWasm` utility to check for valid WASM headers
+- `@polkadot/wasm-crypto` 1.4.1
+
+
+## 3.3.1 Aug 24, 2020
+
+Changes:
+
+- Add `addressRaw` to Keyring interface (if address encoding is different to publicKey)
+- Allow for Ethereum pair signing and verification
+
+
+## 3.2.1 Aug 17, 2020
+
+Changes:
+
+- Allow for (optional, default blake2) hasher to secp256k1 sign/verify functions
+- Utilities for secp256k1 publicKey expansion and compression
+- Add basic Ethereum address utils (encode with checksum & checksum verification)
+- Add Ethereum-compatible `mnemonicToBip39` seed creation function
+
+
+## 3.1.1 Aug 10, 2020
+
+Changes:
+
+- Add `deriveAddress(<address>, '/<soft>/<soft-b>')` via sr25519 soft
+- Use `scrypt` from WASM as available (JS fallback in place)
+- Add `base32{Encode, Decode}` utilities (IPFS-compatible alphabet)
+- Support IPFS compatibility flag in base58 encoding/decoding
+- Update to `@polkadot/wasm-crypto` 1.3.1
+
+
+## 3.0.1 Jul 27, 2020
+
+Contributed:
+
+- Add Katal ss58Format (Thanks to https://github.com/retotrinkler)
+
+Changes:
+
+- Adjust JSON pair output with scrypt kdf (version 3 output)
+
+
+## 2.18.1 Jul 13, 2020
+
+Changes:
+
+- Add `base64{Decode, Encode, Validate}` as crypto utils
+- Extract `base58Validate` from base58 decode checks
+- Add `isAscii` to allow detection of printable ASCII sequences (including tab, newline)
+- Add `isUtf8` to allow detection of valid Utf8 sequences
+
+
+## 2.17.1 Jul 6, 2020
+
+Changes:
+
+- Add `encode{Derived, Multi}Address` to encode derived/multi addresses
+- Correctly handle 0 inputs in `numberToU8a`
+- Simplify and flatten base58 dependencies
+
+
+## 2.16.1 Jun 29, 2020
+
+Changes:
+
+- Adjust `addressCheck` and `encodeAddress` function to check for valid base58 alphabets (better error reporting)
+- Rename `createKeySub` to `createKeyDerived` based on changed in Substrate (sub keys now named derived)
+
+
+## 2.15.1 Jun 22, 2020
+
+Changes:
+
+- Adjust keyring to no override 0-prefix (Polkadot live) settings with keychain default
+
+
+## 2.14.1 Jun 16, 2020
+
+Contributed:
+
+- Add `extractTime` utility conversion (Thanks to https://github.com/kwingram25)
+
+
+## 2.13.1 Jun 8, 2020
+
+Changes:
+
+- 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

+Changes:
+
 - 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
+
+Changes:
+
 - 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

+Changes:
+
 - Internal cleanups on typings
 - Support for latest TypeScript, eslint & typescript-eslint

+
 ## 2.10.1 May 14, 2020

+Contributed:
+
 - Add Kulupu ss58 prefix as an allowed value (Thanks to https://github.com/sorpaas)
+
+Changes:
+
 - 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

+Contributed:
+
 - Add support for ECDSA keypairs (Thanks to https://github.com/akru)
+
+Changes:
+
 - 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)
+
+Changes:
+
 - Cleanup `isDevelopment` regex to cater for chains such as `Westend Development`

+
 ## 2.7.1 Mar 31, 2020

+Changes:
+
 - 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
+
+Changes:
+
 - 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
+
+Changes:
+
 - 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

+Changes:
+
 - 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

+Contributed:
+
 - 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)
+
+Changes:
+
 - Update to `@polkadot/wasm-crypto` 1.0
 - Cleanup dependencies to pave the way for using yarn 2 (Explicit instead of implicit)

+
 ## 2.2.1 Feb 06, 2020

+Changes:
+
 - Add resolver for jest requires (tests from src)

+
 ## 2.1.1 Feb 04, 2020

+Changes:
+
 - Update `detectPackage(<package.json>, __dirname?)` with calling folder

+
 ## 2.0.1 Jan 30, 2020

+Changes:
+
 - 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)
 - Remove `chainspec`, `db`, `trie-codec`, `trie-db` and `trie-hash` packages (moved to client)
 - 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

+Contributed:
+
 - Add cross-client encryption/decryption support (Thanks to https://github.com/hskang9)

+
 ## 1.7.1 Nov 27, 2019

+Changes:
+
 - `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

+Changes:
+
 - `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

+Changes:
+
 - 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

 - **Breaking change** To set the `ss58Format`, you should now use `setSS58Format` as opposed to the old `setAddressPrefix`
+
+Changes:
+
 - Renamed `keyring.setAddressPrefix` to `keyring.setSS58Format`
 - Deprecated `addressPrefix` on the keyring options, added the `ss58Format` as a replacement (aligning with chain properties - the old version is still accepted)
 - 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

+Changes:
+
 - 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

+Changes:
+
 - 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

+Changes:
+
 - `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

+Changes:
+
 - `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
+Changes:

 - 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)
@@ -142,7 +340,10 @@
 - 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
+
+Changes:

 - Breaking: External pair interface for keyring has been changed. Instead of
  - `getMeta` use the `meta` getter, i.e. `console.log(pair.meta.name)`
@@ -150,133 +351,176 @@
  - `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
+
+Changes:

 - 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
+
+Changes:

 - 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
+
+Changes:

 - Moving towards 1.0
 - Added bnMin & bnMax functions

-### 0.76.1 Apr 03, 2019
+
+## 0.76.1 Apr 03, 2019
+
+Changes:

 - 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
+
+Changes:

 - Start journey to 1.0

-### 0.42.1 Mar 28, 2019
+
+## 0.42.1 Mar 28, 2019
+
+Changes:

 - 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
+
+Changes:

 - 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
+
+Changes:

 - 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
+
+Changes:

 - 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
+
+Changes:

 - 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
+
+Changes:

 - Swap to publishing -beta.x on merge (non-breaking testing)

-### 0.36.1 Mar 13, 2019
+
+## 0.36.1 Mar 13, 2019
+
+Changes:

 - Add `fromUri` to keyring along with hard & soft key derivation.

-### 0.35.1 Mar 04, 2019
+
+## 0.35.1 Mar 04, 2019
+
+Changes:

 - 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
+
+Changes:

 - 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.32.1 Oct 18, 2018
+## 0.33.1 Nov 22, 2018

-### 0.31.1 Oct 12, 2018
+## 0.32.1 Oct 18, 2018

-### 0.30.1 Sep 11, 2018
+## 0.31.1 Oct 12, 2018

-### 0.29.1 Sep 01, 2018
+## 0.30.1 Sep 11, 2018

-### 0.28.1 Aug 11, 2018
+## 0.29.1 Sep 01, 2018

-### 0.27.1 Aug 06, 2018
+## 0.28.1 Aug 11, 2018

-### 0.26.1 Jun 27, 2018
+## 0.27.1 Aug 06, 2018

-### 0.25.1 Jun 26, 2018
+## 0.26.1 Jun 27, 2018

-### 0.24.1 Jun 22, 2018
+## 0.25.1 Jun 26, 2018

-### 0.23.1 Jun 21, 2018
+## 0.24.1 Jun 22, 2018

-### 0.22.1 May 24, 2018
+## 0.23.1 Jun 21, 2018

-### 0.21.1 May 17, 2018
+## 0.22.1 May 24, 2018

-### 0.20.1 May 16, 2018
+## 0.21.1 May 17, 2018

-### 0.19.1 Apr 19, 2018
+## 0.20.1 May 16, 2018

-### 0.18.1 Mar 20, 2018
+## 0.19.1 Apr 19, 2018

-### 0.17.1 Mar0 8, 2018
+## 0.18.1 Mar 20, 2018

-### 0.16.1 Feb 23, 2018
+## 0.17.1 Mar0 8, 2018

-### 0.15.1 Feb 15, 2018
+## 0.16.1 Feb 23, 2018

-### 0.14.1 Feb 07, 2018
+## 0.15.1 Feb 15, 2018

-### 0.13.1 Jan 25, 2018
+## 0.14.1 Feb 07, 2018

-### 0.12.1 Jan 11, 2018
+## 0.13.1 Jan 25, 2018

-### 0.11.1 Dec 30, 2017
+## 0.12.1 Jan 11, 2018

-### 0.10.1 Dec 17, 2017
+## 0.11.1 Dec 30, 2017

-### 0.9.1 Dec 14, 2017
+## 0.10.1 Dec 17, 2017

-### 0.8.1 Dec 12, 2017
+## 0.9.1 Dec 14, 2017

-### 0.7.1 Dec 11, 2017
+## 0.8.1 Dec 12, 2017

-### 0.6.1 Nov 30, 2017
+## 0.7.1 Dec 11, 2017

-### 0.5.1 Nov 20, 2017
+## 0.6.1 Nov 30, 2017

-### 0.4.1 Nov 19, 2017
+## 0.5.1 Nov 20, 2017

-### 0.3.1 Nov 19, 2017
+## 0.4.1 Nov 19, 2017

-### 0.2.1 Nov 18, 2017
+## 0.3.1 Nov 19, 2017
+
+## 0.2.1 Nov 18, 2017
@@ -1,5 +1,4 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

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

 function copy_folder () {
  SRC="packages/$1/build"
@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0

 const config = require('@polkadot/dev/config/jest');

@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0

 const path = require('path');

@@ -9,5 +9,5 @@
  "packages": [
    "packages/*"
  ],
-  "version": "2.12.2"
+  "version": "3.5.1"
 }
@@ -7,7 +7,8 @@
    "packages/*"
  ],
  "resolutions": {
-    "babel-core": "^7.0.0-bridge.0"
+    "babel-core": "^7.0.0-bridge.0",
+    "typescript": "^4.0.3"
  },
  "scripts": {
    "build": "polkadot-dev-build-ts",
@@ -21,10 +22,13 @@
    "test:one": "polkadot-dev-run-test"
  },
  "devDependencies": {
-    "@babel/core": "^7.9.6",
-    "@polkadot/dev": "^0.55.6",
-    "@polkadot/ts": "^0.3.25",
-    "@types/jest": "^25.2.3"
+    "@babel/core": "^7.11.6",
+    "@polkadot/dev": "^0.55.54",
+    "@polkadot/ts": "^0.3.47",
+    "@types/jest": "^26.0.14",
+    "typedoc": "^0.19.2",
+    "typedoc-plugin-markdown": "^3.0.2",
+    "typedoc-plugin-no-inherit": "^1.2.0"
  },
-  "version": "2.12.2"
+  "version": "3.5.1"
 }
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/keyring",
-  "version": "2.12.2",
+  "version": "3.5.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.9.6",
-    "@polkadot/util": "2.12.2",
-    "@polkadot/util-crypto": "2.12.2"
+    "@babel/runtime": "^7.11.2",
+    "@polkadot/util": "3.5.1",
+    "@polkadot/util-crypto": "3.5.1"
  }
 }
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 // default substrate dev phrase
 const DEV_PHRASE = 'bottom drive obey lake curtain smoke basket hold race lonely fit walk';
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { hexToU8a, stringToU8a } from '@polkadot/util';
 import { cryptoWaitReady, setSS58Format, encodeAddress } from '@polkadot/util-crypto';
@@ -31,6 +30,12 @@ describe('keypair', (): void => {
      ).toEqual(publicKeyTwo);
    });

+    it('creates via a dev seed', (): void => {
+      expect(
+        keyring.addFromUri('//Alice').address
+      ).toEqual('5FA9nQDVg267DEd8m1ZypXLBnvN7SFxYwV7ndqSYGiN9TTpu');
+    });
+
    it('creates a ed25519 pair via mnemonicToSeed', (): void => {
      expect(
        keyring.addFromUri(
@@ -204,6 +209,36 @@ describe('keypair', (): void => {
      ).toEqual('5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz');
    });

+    it('allows creation from JSON', (): void => {
+      keyring.setSS58Format(2);
+      const pair = keyring.createFromJson(
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+      );
+
+      expect(pair.address).toEqual('DHL8HKFuTTR55JzzLmkJRCAfPBbuevKaT9cXikxbEV97Ko8');
+      expect(pair.publicKey).toEqual(hexToU8a('0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad'));
+    });
+
+    it('fails toJson() when password is incorrect', (): void => {
+      const pair = keyring.createFromJson(
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+      );
+
+      expect(
+        () => pair.toJson('invalid')
+      ).toThrow(/Unable to decode using the supplied passphrase/);
+    });
+
+    it('pass toJson() when password is correct', (): void => {
+      const pair = keyring.createFromJson(
+        JSON.parse('{"address":"0x02fde629668eb2bcc7d748f40a7e597f7c7b363498ff3db31f03ce4854937883ad","encoded":"qIhAhKqtf2iyEoWEr8nmBdksSI8EHHCpgJHToqd6Pl8AgAAAAQAAAAgAAADDZ//fj/BRRj+0+bl1KAlYgoPJp6nEUwiw0fVqO2BW4mjEgQ+iWwJEgDf1JUtecbzOlfhTXBzqX/dIYzLgUADrF4EFEPpboCWiU1iN7W/3DM1cOTRVvTGcbdIqW//z3axhz961qzeJVUIFgllwGe/euLUPIlKbIkiN/CsRYdQ=","encoding":{"content":["pkcs8","ecdsa"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"ecdsa","tags":[],"whenCreated":1600925898271}}')
+      );
+
+      expect(
+        () => pair.toJson('testing')
+      ).not.toThrow();
+    });
+
    it('signs and verifies', (): void => {
      const MESSAGE = stringToU8a('this is a message');
      const pair = keyring.getPair(addressKeyOne);
@@ -212,4 +247,148 @@ describe('keypair', (): void => {
      expect(pair.verify(MESSAGE, signature)).toBe(true);
    });
  });
+
+  describe('ethereum', (): void => {
+    const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ type: 'ethereum' });
+    });
+
+    it('adds a pair with the correct address', (): void => {
+      const pair = keyring.createFromUri(PHRASE);
+
+      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
+      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+    });
+
+    it('encodes a pair toJSON', (): void => {
+      const pair = keyring.createFromUri(PHRASE);
+      const json = pair.toJson('password');
+
+      expect(json.address).toEqual('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'ethereum'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+    });
+
+    it('allows adding from JSON', (): void => {
+      const pair = keyring.addFromJson(
+        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}')
+      );
+
+      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
+      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+
+      pair.decodePkcs8('password');
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.publicKey).toEqual(hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077'));
+      expect(pair.address).toBe('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+    });
+
+    it('allows for signing/verification', (): void => {
+      const MESSAGE = stringToU8a('just some test message');
+      const signer = keyring.createFromUri(PHRASE);
+      const verifier = keyring.addFromJson(
+        JSON.parse('{"address":"KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou","encoded":"U8qFEaghhmNV2PgFhjqzmhyUy37Ok7abfFU2MNsBd0sAgAAAAQAAAAgAAAA3+NniKogzNphiMNueB1X0sGA07B6CaXWfpXPx45iSXoTTprwzU5mOoSqUWO0GKHROI72LN+uJ8Yfv6Ll6JOOV3VPKfoVoFmYm+zDrrMPa0gk5E5kUuSijxADcE6zUrliPVr0Ix/qaghu5SJ7RtWDQLBf4Hp86SJ8Gg6gTSSk=","encoding":{"content":["pkcs8","ethereum"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{}}')
+      );
+
+      const signature = signer.sign(MESSAGE);
+
+      expect(verifier.verify(MESSAGE, signature)).toBe(true);
+    });
+  });
+
+  describe('util', (): void => {
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42 });
+    });
+
+    it('can re-encode an address to Polkadot live', (): void => {
+      expect(
+        keyring.encodeAddress('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
+      ).toEqual('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5');
+    });
+
+    it('can re-encode an address to keyring default', (): void => {
+      expect(
+        keyring.encodeAddress('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5')
+      ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
+    });
+  });
+
+  describe('version 2 JSON', (): void => {
+    const PAIR = '{"address":"5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu","encoded":"0xee8f236e2ac3217ce689692a4afc612220dc77fddaed0482f8f95136a7c3e034cccfbc495410a6e9b2439904974ed1d207abeca536ff6985ceb78edeeb3dc343e561c184c488101af8811d1331430b4ccf0e96ef507132e5132964e8564232e7100d973c5bee7b231dd0c8ad5273f3501515a422c8d7ed9d20a73c0ed17c98ee4588e54844bb73052dcad81f7a1094613d63c162fec7446c88b1fae70e","encoding":{"content":["pkcs8","sr25519"],"type":"xsalsa20-poly1305","version":"2"},"meta":{"genesisHash":"0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e","name":"json v2","tags":[],"whenCreated":1595243159596}}';
+    const PASS2 = 'versionTwo';
+    const PASS3 = 'versionThree';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42 });
+    });
+
+    it('can decode from a version 2 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS2);
+
+      const json = pair.toJson(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu');
+      expect(json.encoding).toEqual({
+        content: ['pkcs8', 'sr25519'],
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
+      });
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.address).toEqual('5CczAE5AmGrZ93MeVhha3Ywam7j9dKB7cArnH7gtrXcMFJvu');
+    });
+  });
+
+  describe('version 3 JSON (hex)', (): void => {
+    const PAIR = '{"address":"FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH","encoded":"0xcd238963070cc4d6806053ee1ac500c7add9c28732bb5d434a332f84a91d9be0008000000100000008000000cf630a1113941b350ddd06697e50399183162e5e9a0e893eafc7f5f4893a223dca5055706b9925b56fdb4304192143843da718e11717daf89cf4f4781f94fb443f61432f782d54280af9eec90bd3069c3cc2d957a42b7c18dc2e9497f623735518e0e49b58f8e4db2c09da3a45dbb935659d015fc94b946cba75b606a6ff7f4e823f6b049e2e6892026b49de02d6dbbd64646fe0933f537d9ea53a70be","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"version3","tags":[],"whenCreated":1595277797639}}';
+    const PASS3 = 'version3';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 2 });
+    });
+
+    it('can decode from a version 3 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH');
+    });
+  });
+
+  describe('version 3 JSON (base64)', (): void => {
+    const PAIR = '{"address":"FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH","encoded":"ILjSgYaGvq1zaCz/kx+aqfLaHBjLXz0Qsmr6RnkOVU4AgAAAAQAAAAgAAAB5R2hm5kgXyc0NQYFxvMU4zCdjB+ugs/ibEooqCvuudbaeKn3Ee47NkCqU1ecOJV+eeaVn4W4dRvIpj5kGmQOGsewR+MiQ/B0G9NFh7JXV0qcPlk2QMNW1/mbJrTO4miqL448BSkP7ZOhUV6HFUpMt3B9HwjiRLN8RORcFp0ID/Azs4Jl/xOpXNzbgQGIffWgCIKTxN9N1ku6tdlG4","encoding":{"content":["pkcs8","sr25519"],"type":["scrypt","xsalsa20-poly1305"],"version":"3"},"meta":{"genesisHash":"0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe","name":"version3","tags":[],"whenCreated":1595277797639,"whenEdited":1595278378596}}';
+    const PASS3 = 'version3';
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 2 });
+    });
+
+    it('can decode from a version 3 JSON file', (): void => {
+      const pair = keyring.addFromJson(JSON.parse(PAIR));
+
+      pair.decodePkcs8(PASS3);
+
+      expect(pair.isLocked).toBe(false);
+      expect(pair.address).toBe('FLiSDPCcJ6auZUGXALLj6jpahcP6adVFDBUQznPXUQ7yoqH');
+    });
+  });
 });
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { detectPackage } from '@polkadot/util';
 import { decodeAddress, encodeAddress, setSS58Format } from '@polkadot/util-crypto';
@@ -1,17 +1,23 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeypairType, Keypair } from '@polkadot/util-crypto/types';
-import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$Meta, KeyringOptions } from './types';
+import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, KeyringOptions } from './types';

-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 { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/util';
+import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToBip39, mnemonicToMiniSecret } from '@polkadot/util-crypto';

 import { DEV_PHRASE } from './defaults';
 import createPair from './pair';
 import Pairs from './pairs';

+const keypairFromSeed = {
+  ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
+  ed25519: (seed: Uint8Array): Keypair => naclFromSeed(seed),
+  ethereum: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
+  sr25519: (seed: Uint8Array): Keypair => schnorrkelFromSeed(seed)
+};
+
 /**
 * # @polkadot/keyring
 *
@@ -40,7 +46,7 @@ export default class Keyring implements KeyringInstance {
  constructor (options: KeyringOptions = {}) {
    options.type = options.type || 'ed25519';

-    assert(options && ['ecdsa', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);
+    assert(options && ['ecdsa', 'ethereum', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);

    this.#pairs = new Pairs();
    this.#ss58 = options.ss58Format;
@@ -84,10 +90,10 @@ export default class Keyring implements KeyringInstance {
   * of an account backup), and then generates a keyring pair from them that it passes to
   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
   */
-  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean): KeyringPair {
+  public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean, encType?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
    const publicKey = this.decodeAddress(address, ignoreChecksum);

-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded, encType));
  }

  /**
@@ -97,12 +103,8 @@ export default class Keyring implements KeyringInstance {
   * of an account backup), and then generates a keyring pair from it that it passes to
   * `addPair` to stores in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
   */
-  public addFromJson ({ address, encoded, encoding: { content, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
-    const type = version === '0' || !Array.isArray(content)
-      ? this.type
-      : content[1];
-
-    return this.addFromAddress(address, meta, hexToU8a(encoded), type, ignoreChecksum);
+  public addFromJson (json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
+    return this.addPair(this.createFromJson(json, ignoreChecksum));
  }

  /**
@@ -125,13 +127,7 @@ 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 = {
-      ecdsa: (): Keypair => secp256k1FromSeed(seed),
-      ed25519: (): Keypair => naclFromSeed(seed),
-      sr25519: (): Keypair => schnorrkelFromSeed(seed)
-    }[type]();
-
-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, keypair, meta, null));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, keypairFromSeed[type](seed), meta, null));
  }

  /**
@@ -145,6 +141,27 @@ export default class Keyring implements KeyringInstance {
    );
  }

+  /**
+   * @name createFromJson
+   * @description Creates a pair from a JSON keyfile
+   */
+  public createFromJson ({ address, encoded, encoding: { content, type, version }, meta }: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair {
+    const cryptoType = version === '0' || !Array.isArray(content)
+      ? this.type
+      : content[1];
+    const encType = !Array.isArray(type)
+      ? [type]
+      : type;
+    const publicKey = isHex(address)
+      ? hexToU8a(address)
+      : this.decodeAddress(address, ignoreChecksum);
+    const decoded = isHex(encoded)
+      ? hexToU8a(encoded)
+      : base64Decode(encoded);
+
+    return createPair({ toSS58: this.encodeAddress, type: cryptoType }, { publicKey, secretKey: new Uint8Array() }, meta, decoded, encType);
+  }
+
  /**
   * @name createFromUri
   * @summary Creates a Keypair from an suri
@@ -165,11 +182,9 @@ export default class Keyring implements KeyringInstance {
      const parts = str.split(' ');

      if ([12, 15, 18, 21, 24].includes(parts.length)) {
-        // FIXME This keeps compat with older versions, but breaks compat with subkey
-        // seed = type === 'sr25519'
-        //   ? mnemonicToMiniSecret(phrase, password)
-        //   : mnemonicToSeed(phrase, password);
-        seed = mnemonicToMiniSecret(phrase, password);
+        seed = type === 'ethereum'
+          ? mnemonicToBip39(phrase)
+          : mnemonicToMiniSecret(phrase, password);
      } else {
        assert(str.length <= 32, 'specified phrase is not a valid mnemonic and is invalid as a raw seed at > 32 bytes');

@@ -177,12 +192,8 @@ export default class Keyring implements KeyringInstance {
      }
    }

-    const keypair = {
-      ecdsa: (): Keypair => secp256k1FromSeed(seed),
-      ed25519: (): Keypair => naclFromSeed(seed),
-      sr25519: (): Keypair => schnorrkelFromSeed(seed)
-    };
-    const derived = keyFromPath(keypair[type](), path, type);
+    // FIXME Need to support Ethereum-type derivation paths
+    const derived = keyFromPath(keypairFromSeed[type](seed), path, type);

    return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
  }
@@ -192,7 +203,7 @@ export default class Keyring implements KeyringInstance {
   * @description Encodes the input into an ss58 representation
   */
  public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
-    return encodeAddress(address, ss58Format || this.#ss58);
+    return encodeAddress(address, isUndefined(ss58Format) ? this.#ss58 : ss58Format);
  }

  /**
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import testingPairs from '../testingPairs';

@@ -1,12 +1,13 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

-import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
-import { naclDecrypt } from '@polkadot/util-crypto';
+import { KeyringPair$JsonEncodingTypes } from '../types';
 import { PairInfo } from './types';

-import { NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH } from './defaults';
+import { assert, stringToU8a, u8aFixLength } from '@polkadot/util';
+import { naclDecrypt, scryptEncode, scryptFromU8a } from '@polkadot/util-crypto';
+
+import { ENCODING, NONCE_LENGTH, PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH, SEED_LENGTH, SCRYPT_LENGTH } from './defaults';

 const SEED_OFFSET = PKCS8_HEADER.length;

@@ -41,18 +42,32 @@ function decodePkcs8 (encoded: Uint8Array): DecodeResult {
  };
 }

-export default function decode (passphrase?: string, encrypted?: Uint8Array | null): DecodeResult {
+export default function decode (passphrase?: string, encrypted?: Uint8Array | null, encType: KeyringPair$JsonEncodingTypes[] = ENCODING): DecodeResult {
  assert(encrypted, 'No encrypted data available to decode');
+  assert(passphrase || !encType.includes('xsalsa20-poly1305'), 'Password required to decode encypted data');

-  const encoded = passphrase
-    ? naclDecrypt(
+  let encoded: Uint8Array | null = encrypted;
+
+  if (passphrase) {
+    let password: Uint8Array;
+
+    if (encType.includes('scrypt')) {
+      const { params, salt } = scryptFromU8a(encrypted);
+
+      password = scryptEncode(passphrase, salt, params).password;
+      encrypted = encrypted.subarray(SCRYPT_LENGTH);
+    } else {
+      password = stringToU8a(passphrase);
+    }
+
+    encoded = naclDecrypt(
      encrypted.subarray(NONCE_LENGTH),
      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(stringToU8a(passphrase), 256, true)
-    )
-    : encrypted;
+      u8aFixLength(password, 256, true)
+    );
+  }

-  assert(encoded, 'Unable to unencrypt using the supplied passphrase');
+  assert(encoded, 'Unable to decode using the supplied passphrase');

  return decodePkcs8(encoded);
 }
@@ -1,19 +1,26 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

+import { KeyringPair$JsonEncodingTypes } from '../types';
+
+const ENCODING: KeyringPair$JsonEncodingTypes[] = ['scrypt', 'xsalsa20-poly1305'];
 const NONCE_LENGTH = 24;
 const PKCS8_DIVIDER = new Uint8Array([161, 35, 3, 33, 0]);
 const PKCS8_HEADER = new Uint8Array([48, 83, 2, 1, 1, 48, 5, 6, 3, 43, 101, 112, 4, 34, 4, 32]);
 const PUB_LENGTH = 32;
+const SALT_LENGTH = 32;
 const SEC_LENGTH = 64;
 const SEED_LENGTH = 32;
+const SCRYPT_LENGTH = SALT_LENGTH + (3 * 4);

 export {
+  ENCODING,
  NONCE_LENGTH,
  PKCS8_DIVIDER,
  PKCS8_HEADER,
  PUB_LENGTH,
+  SALT_LENGTH,
  SEC_LENGTH,
-  SEED_LENGTH
+  SEED_LENGTH,
+  SCRYPT_LENGTH
 };
@@ -1,12 +1,11 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import testingPairs from '../testingPairs';
-import { PKCS8_DIVIDER, PKCS8_HEADER, PUB_LENGTH, SEC_LENGTH } from './defaults';
+import { PKCS8_DIVIDER, PKCS8_HEADER, NONCE_LENGTH, PUB_LENGTH, SCRYPT_LENGTH, SEC_LENGTH } from './defaults';

 const PKCS8_LENGTH = PKCS8_DIVIDER.length + PKCS8_HEADER.length + PUB_LENGTH + SEC_LENGTH;
-const ENCODED_LENGTH = 157;
+const ENCODED_LENGTH = 16 + PKCS8_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;

 const keyring = testingPairs({ type: 'ed25519' }, false);

@@ -1,11 +1,10 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { PairInfo } from './types';

-import { stringToU8a, u8aConcat, u8aFixLength, assert } from '@polkadot/util';
-import { naclEncrypt } from '@polkadot/util-crypto';
+import { u8aConcat, assert } from '@polkadot/util';
+import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';

 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';

@@ -23,7 +22,8 @@ export default function encode ({ publicKey, secretKey }: PairInfo, passphrase?:
    return encoded;
  }

-  const { encrypted, nonce } = naclEncrypt(encoded, u8aFixLength(stringToU8a(passphrase), 256, true));
+  const { params, password, salt } = scryptEncode(passphrase);
+  const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));

-  return u8aConcat(nonce, encrypted);
+  return u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
 }
@@ -1,9 +1,10 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkadot/util-crypto';

+import { hexToU8a } from '@polkadot/util';
+
 import { PAIRS } from '../testing';
 import testingPairs from '../testingPairs';
 import createPair from '.';
@@ -23,6 +24,11 @@ describe('pair', (): void => {
    ).toEqual(
      new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
    );
+    expect(
+      keyring.alice.addressRaw
+    ).toEqual(
+      new Uint8Array([209, 114, 167, 76, 218, 76, 134, 89, 18, 195, 43, 160, 168, 10, 87, 174, 105, 171, 174, 65, 14, 92, 203, 89, 222, 232, 78, 47, 68, 50, 219, 79])
+    );
  });

  it('allows signing', (): void => {
@@ -103,4 +109,13 @@ describe('pair', (): void => {
      pair.sign(new Uint8Array([0]))
    ).toThrow('Cannot sign with a locked key pair');
  });
+
+  describe('ethereum', (): void => {
+    it('has a valid address from a known public', (): void => {
+      const pair = createPair({ toSS58, type: 'ethereum' }, { publicKey: hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') });
+
+      expect(pair.address).toEqual('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887');
+      expect(pair.addressRaw).toEqual(hexToU8a('0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887'));
+    });
+  });
 });
@@ -1,13 +1,12 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { Keypair, KeypairType } from '@polkadot/util-crypto/types';
-import { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '../types';
+import { KeyringPair, KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta, SignOptions } from '../types';
 import { PairInfo } from './types';

-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 { assert, u8aConcat, u8aToHex } from '@polkadot/util';
+import { blake2AsU8a, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, naclVerify, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVerify, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, secp256k1Verify, secp256k1Compress } from '@polkadot/util-crypto';

 import decode from './decode';
 import encode from './encode';
@@ -19,61 +18,44 @@ interface Setup {
 }

 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 TYPE_FROM_SEED = {
+  ecdsa: secp256k1FromSeed,
+  ed25519: naclFromSeed,
+  ethereum: secp256k1FromSeed,
+  sr25519: schnorrkelFromSeed
+};
+
+const TYPE_PREFIX = {
+  ecdsa: new Uint8Array([2]),
+  ed25519: new Uint8Array([0]),
+  ethereum: new Uint8Array([2]),
+  sr25519: new Uint8Array([1])
+};
+
+const TYPE_SIGNATURE = {
+  ecdsa: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'blake2'),
+  ed25519: naclSign,
+  ethereum: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'keccak'),
+  sr25519: schnorrkelSign
+};
+
+const TYPE_ADDRESS = {
+  ecdsa: (p: Uint8Array) => p.length > 32 ? blake2AsU8a(p) : p,
+  ed25519: (p: Uint8Array) => p,
+  ethereum: (p: Uint8Array) => keccakAsU8a(secp256k1Expand(p)),
+  sr25519: (p: Uint8Array) => p
+};
+
+const TYPE_VERIFY = {
+  ecdsa: (m: Uint8Array, s: Uint8Array, p: Uint8Array) => secp256k1Verify(m, s, TYPE_ADDRESS.ecdsa(p), 'blake2'),
+  ed25519: naclVerify,
+  ethereum: (m: Uint8Array, s: Uint8Array, p: Uint8Array) => secp256k1Verify(m, s, TYPE_ADDRESS.ethereum(p), 'keccak', true),
+  sr25519: schnorrkelVerify
+};

 function isEmpty (u8a: Uint8Array): boolean {
-  return u8a.reduce((count, u8): number => count + u8, 0) === 0;
-}
-
-function fromSeed (type: KeypairType, seed: Uint8Array): Keypair {
-  return {
-    ecdsa: (): Keypair => secp256k1FromSeed(seed),
-    ed25519: (): Keypair => naclFromSeed(seed),
-    sr25519: (): Keypair => schnorrkelFromSeed(seed)
-  }[type]();
-}
-
-function multiSignaturePrefix (type: KeypairType): Uint8Array {
-  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,
-    signature
-  );
-}
-
-function verify (type: KeypairType, message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean {
-  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;
-  }
+  return u8a.reduce((count, u8) => count + u8, 0) === 0;
 }

 // Not 100% correct, since it can be a Uint8Array, but an invalid one - just say "undefined" is anything non-valid
@@ -112,10 +94,48 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
 * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
 * property that indicates whether the public key value of the `encoded` property is encoded or not.
 */
-export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null): KeyringPair {
+export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+  const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
+    const decoded = decode(passphrase, userEncoded || encoded, encTypes);
+
+    if (decoded.secretKey.length === 64) {
+      publicKey = decoded.publicKey;
+      secretKey = decoded.secretKey;
+    } else {
+      const pair = TYPE_FROM_SEED[type](decoded.secretKey);
+
+      publicKey = pair.publicKey;
+      secretKey = pair.secretKey;
+    }
+  };
+
+  const recode = (passphrase?: string): Uint8Array => {
+    isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
+
+    encoded = encode({ publicKey, secretKey }, passphrase); // re-encode, latest version
+    encTypes = undefined; // swap to defaults, latest version follows
+
+    return encoded;
+  };
+
+  const encodeAddress = (): string => {
+    const raw = TYPE_ADDRESS[type](publicKey);
+
+    return type === 'ethereum'
+      ? ethereumEncode(raw)
+      : toSS58(raw);
+  };
+
  return {
    get address (): string {
-      return toSS58(getAddress(type, publicKey));
+      return encodeAddress();
+    },
+    get addressRaw (): Uint8Array {
+      const raw = TYPE_ADDRESS[type](publicKey);
+
+      return type === 'ethereum'
+        ? raw.slice(-20)
+        : raw;
    },
    get isLocked (): boolean {
      return isLocked(secretKey);
@@ -130,19 +150,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
      return type;
    },
    // eslint-disable-next-line sort-keys
-    decodePkcs8: (passphrase?: string, _encoded?: Uint8Array | null): void => {
-      const decoded = decode(passphrase, _encoded || encoded);
-
-      if (decoded.secretKey.length === 64) {
-        publicKey = decoded.publicKey;
-        secretKey = decoded.secretKey;
-      } else {
-        const pair = fromSeed(type, decoded.secretKey);
-
-        publicKey = pair.publicKey;
-        secretKey = pair.secretKey;
-      }
-    },
+    decodePkcs8,
    derive: (suri: string, meta?: KeyringPair$Meta): KeyringPair => {
      assert(!isLocked(secretKey), 'Cannot derive on a locked keypair');

@@ -152,21 +160,31 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
      return createPair({ toSS58, type }, derived, meta, null);
    },
    encodePkcs8: (passphrase?: string): Uint8Array =>
-      encode({ publicKey, secretKey }, passphrase),
+      recode(passphrase),
    lock: (): void => {
-      secretKey = new Uint8Array(0);
+      secretKey = new Uint8Array();
    },
    setMeta: (additional: KeyringPair$Meta): void => {
      meta = { ...meta, ...additional };
    },
-    sign: (message: Uint8Array, options?: SignOptions): Uint8Array => {
+    sign: (message: Uint8Array, options: SignOptions = {}): Uint8Array => {
      assert(!isLocked(secretKey), 'Cannot sign with a locked key pair');

-      return sign(type, message, { publicKey, secretKey }, options);
+      return u8aConcat(
+        options.withType
+          ? TYPE_PREFIX[type]
+          : SIG_TYPE_NONE,
+        TYPE_SIGNATURE[type](message, { publicKey, secretKey })
+      );
+    },
+    toJson: (passphrase?: string): KeyringPair$Json => {
+      const address = ['ecdsa', 'ethereum'].includes(type)
+        ? u8aToHex(secp256k1Compress(publicKey))
+        : encodeAddress();
+
+      return toJson(type, { address, meta }, recode(passphrase), !!passphrase);
    },
-    toJson: (passphrase?: string): KeyringPair$Json =>
-      toJson(type, { address: toSS58(getAddress(type, publicKey)), meta }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
    verify: (message: Uint8Array, signature: Uint8Array): boolean =>
-      verify(type, message, signature, publicKey)
+      TYPE_VERIFY[type](message, signature, publicKey)
  };
 }
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '../types';

@@ -26,6 +25,7 @@ const json: KeyringPair$Json = {
 export default function everybody (): KeyringPair {
  const pair: KeyringPair = {
    address,
+    addressRaw: publicKey,
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    decodePkcs8: (passphrase?: string, encoded?: Uint8Array): void =>
      undefined,
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import testingPairs from '../testingPairs';

@@ -12,11 +11,11 @@ describe('toJson', (): void => {
      keyring.alice.toJson()
    ).toMatchObject({
      address: '5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua',
-      encoded: '0x3053020101300506032b657004220420416c696365202020202020202020202020202020202020202020202020202020d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4fa123032100d172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f',
+      encoded: 'MFMCAQEwBQYDK2VwBCIEIEFsaWNlICAgICAgICAgICAgICAgICAgICAgICAgICAg0XKnTNpMhlkSwyugqApXrmmrrkEOXMtZ3uhOL0Qy20+hIwMhANFyp0zaTIZZEsMroKgKV65pq65BDlzLWd7oTi9EMttP',
      encoding: {
        content: ['pkcs8', 'ed25519'],
-        type: 'none',
-        version: '2'
+        type: ['none'],
+        version: '3'
      },
      meta: {
        isTesting: true,
@@ -28,13 +27,13 @@ describe('toJson', (): void => {
  it('creates an encoded output with passphrase', (): void => {
    const json = keyring.alice.toJson('testing');

-    expect(json.encoded).toHaveLength(316);
+    expect(json.encoded).toHaveLength(268);
    expect(json).toMatchObject({
      address: '5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua',
      encoding: {
        content: ['pkcs8', 'ed25519'],
-        type: 'xsalsa20-poly1305',
-        version: '2'
+        type: ['scrypt', 'xsalsa20-poly1305'],
+        version: '3'
      }
    });
  });
@@ -1,27 +1,34 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeypairType } from '@polkadot/util-crypto/types';
-import { KeyringPair$Json, KeyringPair$Meta } from '../types';
+import { KeyringPair$Json, KeyringPair$JsonEncodingTypes, KeyringPair$Meta } from '../types';

-import { u8aToHex } from '@polkadot/util';
+import { base64Encode } from '@polkadot/util-crypto';
+
+import { ENCODING } from './defaults';

 interface PairStateJson {
  address: string;
  meta: KeyringPair$Meta;
 }

+// version 2 - nonce, encoded (previous)
+// version 3 - salt, nonce, encoded
+const VERSION = '3';
+
+const ENC_NONE: KeyringPair$JsonEncodingTypes[] = ['none'];
+
 export default function toJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
  return {
    address,
-    encoded: u8aToHex(encoded),
+    encoded: base64Encode(encoded),
    encoding: {
      content: ['pkcs8', type],
      type: isEncrypted
-        ? 'xsalsa20-poly1305'
-        : 'none',
-      version: '2'
+        ? ENCODING
+        : ENC_NONE,
+      version: VERSION
    },
    meta
  };
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 export interface PairInfo {
  publicKey: Uint8Array;
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeyringPairs, KeyringPair } from './types';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 // From https://github.com/paritytech/substrate/wiki/Secret-URI-Test-Vectors

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeyringInstance, KeyringOptions } from './types';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { cryptoWaitReady } from '@polkadot/util-crypto';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { KeyringPair, KeyringOptions } from './types';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from '@polkadot/util-crypto/address/types';
 import { KeypairType } from '@polkadot/util-crypto/types';
@@ -12,11 +11,13 @@ export interface KeyringOptions {

 export type KeyringPair$Meta = Record<string, unknown>;

-export type KeyringPair$JsonVersion = '0' | '1' | '2';
+export type KeyringPair$JsonVersion = '0' | '1' | '2' | '3';
+
+export type KeyringPair$JsonEncodingTypes = 'none' | 'scrypt' | 'xsalsa20-poly1305';

 export interface KeyringPair$JsonEncoding {
  content: ['pkcs8', KeypairType];
-  type: 'xsalsa20-poly1305' | 'none';
+  type: KeyringPair$JsonEncodingTypes | KeyringPair$JsonEncodingTypes[];
  version: KeyringPair$JsonVersion;
 }

@@ -33,6 +34,7 @@ export interface SignOptions {

 export interface KeyringPair {
  readonly address: string;
+  readonly addressRaw: Uint8Array;
  readonly meta: KeyringPair$Meta;
  readonly isLocked: boolean;
  readonly publicKey: Uint8Array;
@@ -70,6 +72,7 @@ export interface KeyringInstance {
  addFromMnemonic (mnemonic: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
  addFromSeed (seed: Uint8Array, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
  addFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
+  createFromJson (json: KeyringPair$Json, ignoreChecksum?: boolean): KeyringPair;
  createFromUri (suri: string, meta?: KeyringPair$Meta, type?: KeypairType): KeyringPair;
  getPair (address: string | Uint8Array): KeyringPair;
  getPairs (): KeyringPair[];
@@ -1,6 +1,6 @@
 {
  "name": "@polkadot/util-crypto",
-  "version": "2.12.2",
+  "version": "3.5.1",
  "description": "A collection of useful crypto utilities for @polkadot",
  "main": "index.js",
  "keywords": [
@@ -25,25 +25,25 @@
  },
  "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
  "dependencies": {
-    "@babel/runtime": "^7.9.6",
-    "@polkadot/util": "2.12.2",
-    "@polkadot/wasm-crypto": "^1.2.1",
+    "@babel/runtime": "^7.11.2",
+    "@polkadot/util": "3.5.1",
+    "@polkadot/wasm-crypto": "^1.4.1",
    "base-x": "^3.0.8",
    "bip39": "^3.0.2",
    "blakejs": "^1.1.0",
-    "bn.js": "^5.1.2",
-    "bs58": "^4.0.1",
-    "elliptic": "^6.5.2",
+    "bn.js": "^5.1.3",
+    "elliptic": "^6.5.3",
    "js-sha3": "^0.8.0",
-    "pbkdf2": "^3.0.17",
+    "pbkdf2": "^3.1.1",
+    "scryptsy": "^2.1.0",
    "tweetnacl": "^1.0.3",
    "xxhashjs": "^0.2.2"
  },
  "devDependencies": {
    "@types/bn.js": "^4.11.6",
-    "@types/bs58": "^4.0.1",
    "@types/elliptic": "^6.4.12",
-    "@types/pbkdf2": "^3.0.0",
+    "@types/pbkdf2": "^3.1.0",
+    "@types/scryptsy": "^2.0.0",
    "@types/xxhashjs": "^0.2.2"
  }
 }
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import checkAddress from './check';

@@ -17,6 +16,12 @@ describe('checkAddress', (): void => {
    ).toEqual([true, null]);
  });

+  it('fails when an invalid base58 character is supplied', (): void => {
+    expect(
+      checkAddress('5EnxIUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)
+    ).toEqual([false, 'Invalid base58 character "I" (0x49) at index 4']);
+  });
+
  it('fails with invalid prefix when checking Substrate against Kusama prefix', (): void => {
    expect(
      checkAddress('5EnxxUmEbw8DkENKiYuZ1DwQuMoB2UWEQJZZXrTsxoz7SpgG', 2)
@@ -1,16 +1,26 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from './types';

-import bs58 from 'bs58';
-
+import base58Decode from '../base58/decode';
 import checkChecksum from './checkChecksum';
 import defaults from './defaults';

+/**
+ * @name checkAddress
+ * @summary Validates an ss58 address.
+ * @description
+ * From the provided input, validate that the address is a valid input.
+ */
 export default function check (address: string, prefix: Prefix): [boolean, string | null] {
-  const decoded = bs58.decode(address);
+  let decoded;
+
+  try {
+    decoded = base58Decode(address);
+  } catch (error) {
+    return [false, (error as Error).message];
+  }

  if (decoded[0] !== prefix) {
    return [false, `Prefix mismatch, expected ${prefix}, found ${decoded[0]}`];
@@ -1,11 +1,10 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import sshash from './sshash';

 export default function checkChecksum (decoded: Uint8Array): [boolean, number] {
-  const isPublicKey = decoded.length === 35;
+  const isPublicKey = [35, 36].includes(decoded.length);

  // non-publicKeys has 1 byte checksums, else default to 2
  const length = decoded.length - (isPublicKey ? 2 : 1);
@@ -1,13 +1,12 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

-import { stringToU8a, u8aToHex } from '@polkadot/util';
+import { stringToU8a, u8aToHex, hexToU8a } from '@polkadot/util';

 import testingPairs, { TestKeyringMap } from '../../../keyring/src/testingPairs';
 import decode from './decode';

-describe('decode', (): void => {
+describe('decodeAddress', (): void => {
  let keyring: TestKeyringMap;

  beforeAll((): void => {
@@ -74,6 +73,14 @@ describe('decode', (): void => {
    ).toEqual(new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]));
  });

+  it('decodes a 33-byte address', (): void => {
+    expect(
+      decode('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou')
+    ).toEqual(
+      hexToU8a('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
+    );
+  });
+
  it.skip('allows invalid prefix (in list)', (): void => {
    expect(
      (): Uint8Array => decode('6GfvWUvHvU8otbZ7sFhXH4eYeMcKdUkL61P3nFy52efEPVUx')
@@ -94,4 +101,10 @@ describe('decode', (): void => {
      (): Uint8Array => decode('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaDwU')
    ).toThrow(/address checksum/);
  });
+
+  it('fails when invalid base58 encoded address is found', (): void => {
+    expect(
+      () => u8aToHex(decode('F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29'))
+    ).toThrow(/Decoding F3opIRbN5ZbjJNU511Kj2TLuzFcDq9BGduA9TgiECafpg29: Invalid base58 character "I" \(0x49\) at index 4/);
+  });
 });
@@ -1,14 +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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from './types';

 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L6

-import bs58 from 'bs58';
-import { assert, bufferToU8a, isHex, isU8a, u8aToU8a } from '@polkadot/util';
+import { assert, isHex, isU8a, u8aToU8a } from '@polkadot/util';

+import base58Decode from '../base58/decode';
 import checkChecksum from './checkChecksum';
 import defaults from './defaults';

@@ -18,11 +17,17 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
    return u8aToU8a(encoded);
  }

-  const decoded = bufferToU8a(bs58.decode(encoded));
-  const error = (message: string) => `Decoding ${encoded as string}: ${message}`;
+  const wrapError = (message: string) => `Decoding ${encoded as string}: ${message}`;
+  let decoded;
+
+  try {
+    decoded = base58Decode(encoded);
+  } catch (error) {
+    throw new Error(wrapError((error as Error).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'));
+  assert(defaults.allowedEncodedLengths.includes(decoded.length), wrapError('Invalid decoded address length'));

  // TODO Unless it is an "use everywhere" prefix, throw an error
  // if (decoded[0] !== prefix) {
@@ -31,7 +36,7 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b

  const [isValid, endPos] = checkChecksum(decoded);

-  assert(ignoreChecksum || isValid, error('Invalid decoded address checksum'));
+  assert(ignoreChecksum || isValid, wrapError('Invalid decoded address checksum'));

  return decoded.slice(1, endPos);
 }
@@ -1,13 +1,12 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { allowedSS58 } from './ss58';

 const defaults = {
-  allowedDecodedLengths: [1, 2, 4, 8, 32],
+  allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
  // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
-  allowedEncodedLengths: [3, 4, 6, 10, 35],
+  allowedEncodedLengths: [3, 4, 6, 10, 35, 36],
  allowedPrefix: allowedSS58,
  prefix: 42
 };
@@ -0,0 +1,24 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { waitReady } from '@polkadot/wasm-crypto';
+
+import derive from './derive';
+
+describe('deriveAddress', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  it('derives a known path', (): void => {
+    expect(
+      derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
+    ).toEqual('5GZ4srnepXvdsuNVoxCGyVZd8ScDm4gkGLTKuaGARy9akjTa');
+  });
+
+  it('fails on hard paths', (): void => {
+    expect(
+      () => derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
+    ).toThrow(/Expected suri to contain a combination of non-hard paths/);
+  });
+});
@@ -0,0 +1,28 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Prefix } from './types';
+
+import { assert } from '@polkadot/util';
+
+import DeriveJunction from '../key/DeriveJunction';
+import { keyExtractPath } from '../key';
+import { schnorrkelDerivePublic } from '../schnorrkel';
+import decode from './decode';
+import encode from './encode';
+
+/**
+ * @name deriveAddress
+ * @summary Creates a sr25519 derived address from the supplied and path.
+ * @description
+ * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
+ */
+export default function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+  const { path } = keyExtractPath(suri);
+
+  assert(path.length && !path.some((path) => path.isHard), 'Expected suri to contain a combination of non-hard paths');
+
+  return encode(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
+    return schnorrkelDerivePublic(publicKey, path.chainCode);
+  }, decode(who)), ss58Format);
+}
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import testingPairs from '@polkadot/keyring/testingPairs';

@@ -21,6 +20,12 @@ describe('encode', (): void => {
    ).toEqual('7sL6eNJj5ZGV5cn3hhV2deRUsivXfBfMH76wCALCqWj1EKzv');
  });

+  it('can re-encode an address to Polkadot live', (): void => {
+    expect(
+      encode('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 0)
+    ).toEqual('15oF4uVJwmo4TdGW7VfQxNLavjCXviqxT9S1MgbjMNHr6Sp5');
+  });
+
  it('fails when non-valid publicKey provided', (): void => {
    expect(
      (): string => encode(
@@ -61,11 +66,17 @@ describe('encode', (): void => {
    ).toEqual('as7QnGMf');
  });

-  it('enodes a 8-byte address', (): void => {
+  it('encodes a 8-byte address', (): void => {
    expect(
      encode(
        new Uint8Array([42, 44, 10, 0, 0, 0, 0, 0]), 68
      )
    ).toEqual('4q7qY5RBG7Z4wv');
  });
+
+  it('encodes an 33-byte address', (): void => {
+    expect(
+      encode('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
+    ).toEqual('KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou');
+  });
 });
@@ -1,14 +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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from './types';

 // Original implementation: https://github.com/paritytech/polka-ui/blob/4858c094684769080f5811f32b081dd7780b0880/src/polkadot.js#L34

-import bs58 from 'bs58';
-import { assert, u8aConcat, u8aToBuffer } from '@polkadot/util';
+import { assert, u8aConcat } from '@polkadot/util';

+import base58Encode from '../base58/encode';
 import decode from './decode';
 import defaults from './defaults';
 import sshash from './sshash';
@@ -19,13 +18,11 @@ export default function encode (_key: Uint8Array | string, ss58Format: Prefix =

  assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);

-  const isPublicKey = key.length === 32;
+  const isPublicKey = [32, 33].includes(key.length);
  const input = u8aConcat(new Uint8Array([ss58Format]), key);
  const hash = sshash(input);

-  return bs58.encode(
-    u8aToBuffer(
-      u8aConcat(input, hash.subarray(0, isPublicKey ? 2 : 1))
-    )
+  return base58Encode(
+    u8aConcat(input, hash.subarray(0, isPublicKey ? 2 : 1))
  );
 }
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import encodeDerivedAddress from './encodeDerived';
+
+describe('encodeDerivedAddress', (): void => {
+  it('creates a valid known derived address', (): void => {
+    expect(
+      encodeDerivedAddress('5GvUh7fGKsdBEh5XpypkfkGuf7j3vXLxH9BdxjxnJNVXRYi1', 0)
+    ).toEqual('5E5XxqPxm7QbEs6twYfp3tyjXidn4kqRrNPH4o6JK9JSLUeD');
+  });
+});
@@ -0,0 +1,20 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Prefix } from './types';
+
+import BN from 'bn.js';
+
+import decode from './decode';
+import encode from './encode';
+import keyDerived from './keyDerived';
+
+/**
+ * @name encodeDerivedAddress
+ * @summary Creates a derived address as used in Substrate utility.
+ * @description
+ * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
+ */
+export default function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyDerived(decode(who), index), ss58Format);
+}
@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import encodeMultiAddress from './encodeMulti';
+
+describe('encodeMultiAddress', (): void => {
+  it('creates a valid known multi address', (): void => {
+    expect(
+      encodeMultiAddress([
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y'
+      ], 2)
+    ).toEqual('5DjYJStmdZ2rcqXbXGX7TW85JsrW6uG4y9MUcLq2BoPMpRA7');
+  });
+});
@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { Prefix } from './types';
+
+import BN from 'bn.js';
+
+import encode from './encode';
+import keyMulti from './keyMulti';
+
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+export default function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyMulti(who, threshold), ss58Format);
+}
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import testingPairs from '@polkadot/keyring/testingPairs';
 import { addressEq } from '.';
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { u8aEq } from '@polkadot/util';

@@ -1,13 +1,15 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import checkAddress from './check';
 import checkAddressChecksum from './checkChecksum';
 import createKeyMulti from './keyMulti';
-import createKeySub from './keySub';
+import createKeyDerived from './keyDerived';
 import decodeAddress from './decode';
+import deriveAddress from './derive';
 import encodeAddress from './encode';
+import encodeDerivedAddress from './encodeDerived';
+import encodeMultiAddress from './encodeMulti';
 import addressEq from './eq';
 import setSS58Format from './setSS58Format';
 import sortAddresses from './sort';
@@ -16,10 +18,13 @@ export {
  addressEq,
  checkAddress,
  checkAddressChecksum,
+  createKeyDerived,
  createKeyMulti,
-  createKeySub,
  decodeAddress,
+  deriveAddress,
  encodeAddress,
+  encodeDerivedAddress,
+  encodeMultiAddress,
  setSS58Format,
  sortAddresses
 };
@@ -1,13 +1,12 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

-import createKeySub from './keySub';
+import createKeyDerived from './keyDerived';

-describe('createKeySub', (): void => {
+describe('createKeyDerived', (): void => {
  it('matches sub accounts with Rust', (): void => {
    expect(
-      createKeySub(new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]), 0)
+      createKeyDerived(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])
    );
@@ -15,7 +14,7 @@ describe('createKeySub', (): void => {

  it('creates a valid subkey', (): void => {
    expect(
-      createKeySub('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', 1)
+      createKeyDerived('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])
    );
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import BN from 'bn.js';
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
@@ -10,7 +9,7 @@ import decodeAddress from './decode';

 const PREFIX = stringToU8a('modlpy/utilisuba');

-export default function createKeySub (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
+export default function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
  return blake2AsU8a(
    u8aConcat(
      PREFIX,
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { createKeyMulti } from '.';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import BN from 'bn.js';
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import encode from './encode';
 import setSS58Format from './setSS58Format';
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from './types';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { sortAddresses } from '.';

@@ -1,6 +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.
+// SPDX-License-Identifier: Apache-2.0

 import { Prefix } from './types';

@@ -1,16 +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.
+// SPDX-License-Identifier: Apache-2.0

 export const allowedSS58 = [
  // Polkadot
  0, 1,
  // Kusama
  2, 3,
+  // Katal Chain
+  4,
  // Kulupu
  16, 17,
  // Dothereum
  20,
+  // Dock testnet and mainnet
+  21, 22,
  // Substrate default
  42, 43,
  // Substrate BBQ (deprecated)
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { stringToU8a, u8aConcat } from '@polkadot/util';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 // FIXME we really want this to map with what is in the allowedSS58 array... i.e. the
 // values there. As of now, we just map to number.
@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// https://github.com/multiformats/js-multibase/blob/master/src/constants.js
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+const BITS_PER_CHAR = 5;
+
+export {
+  BASE32_ALPHABET,
+  BITS_PER_CHAR
+};
@@ -0,0 +1,24 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aToString } from '@polkadot/util';
+
+import { base32Decode } from './';
+
+describe('base32Decode', (): void => {
+  it('decodes a base32', (): void => {
+    expect(
+      u8aToString(
+        base32Decode('irswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb')
+      )
+    ).toEqual('Decentralize everything!!');
+  });
+
+  it('decodes a base32 (ipfsCompat)', (): void => {
+    expect(
+      u8aToString(
+        base32Decode('birswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb', true)
+      )
+    ).toEqual('Decentralize everything!!');
+  });
+});
@@ -0,0 +1,47 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
+
+import { assert } from '@polkadot/util';
+
+import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
+import validate from './validate';
+
+// Build the character lookup table:
+const LOOKUP = BASE32_ALPHABET
+  .split('')
+  .reduce((lookup: Record<string, number>, char: string, index: number): Record<string, number> => {
+    lookup[char] = index;
+
+    return lookup;
+  }, {});
+
+/**
+ * @name base32Decode
+ * @summary Delookup a base32 value.
+ * @description
+ * From the provided input, decode the base32 and return the result as an `Uint8Array`.
+ */
+export default function base32Decode (value: string, ipfsCompat = false): Uint8Array {
+  validate(value, ipfsCompat);
+
+  const out = new Uint8Array(((value.length - (ipfsCompat ? 1 : 0)) * BITS_PER_CHAR / 8) | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+
+  for (let i = (ipfsCompat ? 1 : 0); i < value.length; ++i) {
+    buffer = (buffer << BITS_PER_CHAR) | LOOKUP[value[i]];
+    bits += BITS_PER_CHAR;
+
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 0xff & (buffer >> bits);
+    }
+  }
+
+  assert(!(bits >= BITS_PER_CHAR || 0xff & (buffer << (8 - bits))), 'Unexpected end of data');
+
+  return out;
+}
@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base58Decode } from '../base58';
+import { base32Encode } from './';
+
+describe('base32Encode', (): void => {
+  it('encodes to a base32', (): void => {
+    expect(
+      base32Encode('Decentralize everything!!')
+    ).toEqual('irswgzloorzgc3djpjssazlwmvzhs5dinfxgoijb');
+  });
+
+  it('encodes a base58 to a base32', (): void => {
+    expect(
+      base32Encode(
+        base58Decode('zb2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV', true),
+        true
+      )
+    ).toEqual('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy');
+  });
+});
@@ -0,0 +1,41 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// adapted from https://github.com/multiformats/js-multibase/blob/424709195b46ffb1d6f2f69a7707598ebe751e5e/src/rfc4648.js
+
+import { u8aToU8a } from '@polkadot/util';
+
+import { BASE32_ALPHABET, BITS_PER_CHAR } from './bs32';
+
+const MASK = (1 << BITS_PER_CHAR) - 1;
+
+/**
+ * @name base32Encode
+ * @summary Creates a base32 value.
+ * @description
+ * From the provided input, create the base32 and return the result as a string.
+ */
+export default function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
+  const u8a = u8aToU8a(value);
+  let out = '';
+  let bits = 0;
+  let buffer = 0;
+
+  for (let i = 0; i < u8a.length; ++i) {
+    buffer = (buffer << 8) | u8a[i];
+    bits += 8;
+
+    while (bits > BITS_PER_CHAR) {
+      bits -= BITS_PER_CHAR;
+      out += BASE32_ALPHABET[MASK & (buffer >> bits)];
+    }
+  }
+
+  if (bits) {
+    out += BASE32_ALPHABET[MASK & (buffer << (BITS_PER_CHAR - bits))];
+  }
+
+  return ipfsCompat
+    ? `b${out}`
+    : out;
+}
@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Encode and decode base32 values
+ */
+
+export { default as base32Decode } from './decode';
+export { default as base32Encode } from './encode';
+export { default as base32Validate } from './validate';
+export { default as isBase32 } from './is';
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import validate from './validate';
+
+export default function isBase32 (value?: string | null): boolean {
+  try {
+    return validate(value);
+  } catch (error) {
+    return false;
+  }
+}
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base32Validate } from '.';
+
+describe('base32Validate', (): void => {
+  it('validates ipfs-compat encoded', (): void => {
+    expect(
+      () => base32Validate('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true)
+    ).not.toThrow();
+  });
+});
@@ -0,0 +1,15 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { validateChars } from '../base58/validate';
+import { BASE32_ALPHABET } from './bs32';
+
+/**
+ * @name base32Validate
+ * @summary Validates a base32 value.
+ * @description
+ * Validates the the supplied value is valid base32
+ */
+export default function base32Validate (value?: string | null, ipfsCompat = false): true {
+  return validateChars('base32', BASE32_ALPHABET, value, ipfsCompat ? 'b' : undefined);
+}
@@ -0,0 +1,14 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import baseX from 'base-x';
+
+// https://github.com/cryptocoinjs/base-x#alphabets
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+const bs58 = baseX(BASE58_ALPHABET);
+
+export {
+  BASE58_ALPHABET,
+  bs58
+};
@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { bufferToU8a } from '@polkadot/util';
+
+import { bs58 } from './bs58';
+import validate from './validate';
+
+/**
+ * @name base58Decode
+ * @summary Decodes a base58 value.
+ * @description
+ * From the provided input, decode the base58 and return the result as an `Uint8Array`.
+ */
+export default function base58Decode (value: string, ipfsCompat?: boolean): Uint8Array {
+  validate(value, ipfsCompat);
+
+  return bufferToU8a(bs58.decode(value.substr(ipfsCompat ? 1 : 0)));
+}
@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base32Decode } from '../base32';
+import { base58Encode } from './';
+
+describe('base58Encode', (): void => {
+  it('encodes a base32 to a base38', (): void => {
+    expect(
+      base58Encode(
+        base32Decode('bafkreigh2akiscaildcqabsyg3dfr6chu3fgpregiymsck7e7aqa4s52zy', true),
+        true
+      )
+    ).toEqual('zb2rhk6GMPQF3hfzwXTaNYFLKomMeC6UXdUt6jZKPpeVirLtV');
+  });
+});
@@ -0,0 +1,22 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+
+import { bs58 } from './bs58';
+
+/**
+ * @name base58Encode
+ * @summary Creates a base58 value.
+ * @description
+ * From the provided input, create the base58 and return the result as a string.
+ */
+export default function base58Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat?: boolean): string {
+  const out = bs58.encode(
+    u8aToBuffer(u8aToU8a(value))
+  );
+
+  return ipfsCompat
+    ? `z${out}`
+    : out;
+}
@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Encode and decode base58 values
+ */
+
+export { default as base58Decode } from './decode';
+export { default as base58Encode } from './encode';
+export { default as base58Validate } from './validate';
+export { default as isBase58 } from './is';
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import validate from './validate';
+
+export default function isBase58 (value?: string | null, ipfsCompat?: boolean): boolean {
+  try {
+    return validate(value, ipfsCompat);
+  } catch (error) {
+    return false;
+  }
+}
@@ -0,0 +1,27 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { assert } from '@polkadot/util';
+
+import { BASE58_ALPHABET } from './bs58';
+
+export function validateChars (type: string, alphabet: string, value?: string | null, startChar?: string): true {
+  assert(value, `Expected non-null, non-empty ${type} input`);
+  assert(!startChar || value[0] === startChar, `Expected ${type} to start with '${startChar || ''}'`);
+
+  for (let i = (startChar ? 1 : 0); i < value.length; i++) {
+    assert(alphabet.includes(value[i]), `Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+  }
+
+  return true;
+}
+
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates the the supplied value is valid base58
+ */
+export default function base58Validate (value?: string | null, ipfsCompat = false): true {
+  return validateChars('base58', BASE58_ALPHABET, value, ipfsCompat ? 'z' : undefined);
+}
@@ -0,0 +1,16 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { stringToU8a } from '@polkadot/util';
+
+import { base64Decode } from '.';
+
+describe('base64Decode', (): void => {
+  it('decodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Decode('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toEqual(
+      stringToU8a('hello world Приветствую ми 你好')
+    );
+  });
+});
@@ -0,0 +1,18 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { bufferToU8a } from '@polkadot/util';
+
+import validate from './validate';
+
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+export default function base64Decode (value: string): Uint8Array {
+  validate(value);
+
+  return bufferToU8a(Buffer.from(value, 'base64'));
+}
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64Encode } from '.';
+
+describe('base64Encode', (): void => {
+  it('encodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Encode('hello world Приветствую ми 你好')
+    ).toEqual('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==');
+  });
+});
@@ -0,0 +1,14 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+export default function base58Encode (value: Uint8Array | string | Buffer | number[]): string {
+  return u8aToBuffer(u8aToU8a(value)).toString('base64');
+}
@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @summary Encode and decode base64 values
+ */
+
+export { default as base64Decode } from './decode';
+export { default as base64Encode } from './encode';
+export { default as base64Pad } from './pad';
+export { default as base64Trim } from './trim';
+export { default as base64Validate } from './validate';
+export { default as isBase64 } from './is';
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import validate from './validate';
+
+export default function isBase64 (value?: string | null): boolean {
+  try {
+    return validate(value);
+  } catch (error) {
+    return false;
+  }
+}
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64Pad } from '.';
+
+describe('base64Pad', (): void => {
+  it('pads a utf-8 string', (): void => {
+    expect(
+      base64Pad('YWJjZA')
+    ).toEqual('YWJjZA==');
+  });
+});
@@ -0,0 +1,6 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export default function base64Trim (value: string): string {
+  return value.padEnd(value.length + (value.length % 4), '=');
+}
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64Trim } from '.';
+
+describe('base64Trim', (): void => {
+  it('trims a utf-8 string', (): void => {
+    expect(
+      base64Trim('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toEqual('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ');
+  });
+});
@@ -0,0 +1,10 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export default function base64Trim (value: string): string {
+  while (value.length && value[value.length - 1] === '=') {
+    value = value.slice(0, -1);
+  }
+
+  return value;
+}
@@ -0,0 +1,12 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { base64Validate } from '.';
+
+describe('base64Validate', (): void => {
+  it('validates a mixed base64 utf8 string', (): void => {
+    expect(
+      () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toThrow(/Invalid base64 encoding/);
+  });
+});
@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { assert } from '@polkadot/util';
+
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates the the supplied value is valid base64
+ */
+export default function base64Validate (value?: string | null): true {
+  assert(value, 'Expected non-null, non-empty base64 input');
+  assert(/^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value), 'Invalid base64 encoding');
+
+  return true;
+}
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { hexToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { u8aToHex } from '@polkadot/util';

@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import { hexToU8a } from '@polkadot/util';
 import { waitReady } from '@polkadot/wasm-crypto';
@@ -43,4 +42,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);
+  });
 });
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 import blakejs from 'blakejs';
 import { u8aToU8a } from '@polkadot/util';
@@ -20,10 +19,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);
 }
@@ -1,6 +1,5 @@
 // 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.
+// SPDX-License-Identifier: Apache-2.0

 /**
 * @summary Create blake2b values with specified bitlengths
@@ -0,0 +1,57 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { keccakAsU8a } from '../keccak';
+import { ethereumEncode } from './';
+
+describe('formatAddress', () => {
+  describe('address to address encoding', (): void => {
+    const ADDRESS = '0x00a329c0648769A73afAc7F9381E08FB43dBEA72';
+
+    it('returns 0x for no address', () => {
+      expect(ethereumEncode()).toBe('0x');
+    });
+
+    it('returns fails on invalid address', () => {
+      expect(
+        () => ethereumEncode('0xnotaddress')
+      ).toThrow(/Invalid address or publicKey passed/);
+    });
+
+    it('converts lowercase to the checksummed address', () => {
+      expect(ethereumEncode(ADDRESS.toLowerCase())).toBe(ADDRESS);
+    });
+
+    it('converts uppercase to the checksummed address', () => {
+      expect(ethereumEncode(ADDRESS.toUpperCase().replace('0X', '0x'))).toBe(ADDRESS);
+    });
+
+    it('returns formatted address on checksum input', () => {
+      expect(ethereumEncode(ADDRESS)).toBe(ADDRESS);
+    });
+  });
+
+  describe('from publicKey', (): void => {
+    const ADDRESS = '0x4119b2e6c3Cb618F4f0B93ac77f9BeeC7FF02887';
+
+    it('encodes a compressed publicKey', (): void => {
+      expect(
+        ethereumEncode('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077')
+      ).toEqual(ADDRESS);
+    });
+
+    it('encodes an expanded publicKey', (): void => {
+      expect(
+        ethereumEncode('0x04b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af')
+      ).toEqual(ADDRESS);
+    });
+
+    it('encodes a pre-hashed key', (): void => {
+      expect(
+        ethereumEncode(
+          keccakAsU8a('0xb9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb1307763fe926c273235fd979a134076d00fd1683cbd35868cb485d4a3a640e52184af')
+        )
+      ).toEqual(ADDRESS);
+    });
+  });
+});
@@ -0,0 +1,35 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { assert, u8aToHex, u8aToU8a } from '@polkadot/util';
+
+import { keccakAsU8a } from '../keccak';
+import { secp256k1Expand } from '../secp256k1';
+
+function getH160 (u8a: Uint8Array): Uint8Array {
+  if ([33, 65].includes(u8a.length)) {
+    u8a = keccakAsU8a(secp256k1Expand(u8a));
+  }
+
+  return u8a.slice(-20);
+}
+
+export default function ethereumEncode (addressOrPublic?: string | Uint8Array): string {
+  if (!addressOrPublic) {
+    return '0x';
+  }
+
+  const u8aAddress = u8aToU8a(addressOrPublic);
+
+  assert([20, 32, 33, 65].includes(u8aAddress.length), 'Invalid address or publicKey passed');
+
+  const address = u8aToHex(getH160(u8aAddress), -1, false);
+  const hash = u8aToHex(keccakAsU8a(address), -1, false);
+  let result = '';
+
+  for (let index = 0; index < 40; index++) {
+    result = `${result}${parseInt(hash[index], 16) > 7 ? address[index].toUpperCase() : address[index]}`;
+  }
+
+  return `0x${result}`;
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Github Actions	b46308fa8f	[CI Skip] release/stable 3.5.1 skip-checks: true	2020-09-27 08:05:00 +00:00
Jaco Greeff	c366e637e9	3.5 (#694 ) * 3.5 * Update CHANGELOG.md	2020-09-27 09:58:54 +02:00
Jaco Greeff	81acc81ef7	Change decimals, move unit (#695 ) * Change decimals, move unit * CHANGELOG	2020-09-27 09:49:47 +02:00
Github Actions	eb7270ff3f	[CI Skip] release/beta 3.5.0-beta.15 skip-checks: true	2020-09-25 15:12:38 +00:00
Jaco Greeff	30198d1a6d	Don't decode on unlocked	2020-09-25 17:06:04 +02:00
Github Actions	2fc078d994	[CI Skip] release/beta 3.5.0-beta.14 skip-checks: true	2020-09-25 11:17:25 +00:00
Jaco Greeff	bd1735cafb	Keypair recoding should decode, then encode (#693 ) * Keypair recoding should decode, then encode * Add tests, align createFromJson naming	2020-09-25 13:11:34 +02:00
Github Actions	ca73e5bc4d	[CI Skip] release/beta 3.5.0-beta.13 skip-checks: true	2020-09-24 13:29:20 +00:00
Jaco Greeff	aff78c2e30	Adjust KeyringInstance	2020-09-24 15:23:14 +02:00
Github Actions	fbd454eb5a	[CI Skip] release/beta 3.5.0-beta.12 skip-checks: true	2020-09-24 10:59:49 +00:00
Jaco Greeff	ce964d2f12	Bump deps (#692 ) * Bump deps * Linting	2020-09-24 12:53:57 +02:00
Github Actions	2c26bc61da	[CI Skip] release/beta 3.5.0-beta.11 skip-checks: true	2020-09-24 06:30:00 +00:00
Jaco Greeff	4111122cba	JSON pair creation without addition (#691 ) * JSON pair creation without addition * Linting * create test	2020-09-24 08:23:41 +02:00
Github Actions	e1e95dc6b3	[CI Skip] release/beta 3.5.0-beta.10 skip-checks: true	2020-09-20 08:11:31 +00:00
Jaco Greeff	e7c665e5da	Add isBase{32, 58, 64} utils (#689 ) * Add isBase{32, 58, 64} utils * Allow empty inputs * Add base64{Trim, Pad} * isBase64 * Update assert messages * Cleaup ifsCompat checks	2020-09-20 10:05:38 +02:00
Github Actions	301eb587cb	[CI Skip] release/beta 3.5.0-beta.9 skip-checks: true	2020-09-18 13:15:50 +00:00
Jaco Greeff	5c886b0f81	TextEncoder/TextDecoder from polkadot-js (#686 )	2020-09-18 15:09:25 +02:00
Jaco Greeff	56a79924a0	SPDX (#687 )	2020-09-17 16:13:39 +02:00
Github Actions	beef1b38ed	[CI Skip] release/beta 3.5.0-beta.8 skip-checks: true	2020-09-16 07:02:28 +00:00
Jaco Greeff	ce46a68187	Bump deps (#684 )	2020-09-16 08:56:19 +02:00
Github Actions	94dc2d76b3	[CI Skip] release/beta 3.5.0-beta.7 skip-checks: true	2020-09-13 11:22:21 +00:00
Jaco Greeff	dcdde1cf4b	Bump deps (#682 )	2020-09-13 13:13:09 +02:00
Github Actions	e3a9099b58	[CI Skip] release/beta 3.5.0-beta.6 skip-checks: true	2020-09-09 16:52:47 +00:00
Jaco Greeff	fb03ff3994	Bump deps (#681 )	2020-09-09 18:46:23 +02:00
Github Actions	1d42fbf2bf	[CI Skip] release/beta 3.5.0-beta.5 skip-checks: true	2020-09-09 07:53:48 +00:00
Lovesh Harchandani	c0e4b1b93e	Add Dock network id for address generation (#640 ) Taking 21 and 22 for testnet and mainnet Signed-off-by: lovesh <lovesh.bond@gmail.com>	2020-09-09 09:47:33 +02:00
Github Actions	139f3f90b0	[CI Skip] release/beta 3.5.0-beta.4 skip-checks: true	2020-09-08 14:45:23 +00:00
Jaco Greeff	cf6fae8e1d	ed25519 from dev mnemonic test (#680 )	2020-09-08 16:39:01 +02:00
Github Actions	f8d69736c1	[CI Skip] release/beta 3.5.0-beta.3 skip-checks: true	2020-09-08 08:41:43 +00:00
Jaco Greeff	a4322cb99a	Rewrite yarn.lock (#679 )	2020-09-08 10:35:33 +02:00
Github Actions	9445006127	[CI Skip] release/beta 3.5.0-beta.2 skip-checks: true	2020-09-06 16:15:20 +00:00
Jaco Greeff	aeeaa91752	Bump deps (#677 )	2020-09-06 18:09:35 +02:00
Github Actions	52fb4ac863	[CI Skip] release/beta 3.5.0-beta.1 skip-checks: true	2020-09-05 06:06:51 +00:00
Jaco Greeff	2a000a2a14	Bump deps (#676 )	2020-09-05 08:00:53 +02:00
Github Actions	97fe3b2ea3	[CI Skip] release/beta 3.5.0-beta.0 skip-checks: true	2020-09-03 12:50:58 +00:00
Jaco Greeff	9b8a782d58	Bump dev (#675 )	2020-09-03 14:44:24 +02:00
Github Actions	b56e40ea5b	[CI Skip] release/stable 3.4.1 skip-checks: true	2020-08-31 07:08:33 +00:00
Jaco Greeff	37d1bcb6eb	3.4 (#674 )	2020-08-31 09:00:57 +02:00
Github Actions	f2b8c1fb4e	[CI Skip] release/beta 3.4.0-beta.3 skip-checks: true	2020-08-28 12:19:52 +00:00
Jaco Greeff	92cc8fc4e3	Add isWasm util (#673 )	2020-08-28 14:12:22 +02:00
Github Actions	701bd9335d	[CI Skip] release/beta 3.4.0-beta.2 skip-checks: true	2020-08-27 11:26:48 +00:00
Jaco Greeff	d176c74715	Bump wasm to 1.4.1 (#672 )	2020-08-27 13:19:36 +02:00
Github Actions	0bf7c799f3	[CI Skip] release/beta 3.4.0-beta.1 skip-checks: true	2020-08-26 08:52:16 +00:00
Jaco Greeff	2f7d5cd4e1	Bump deps (#670 ) * Bump deps * Bump crypto * Bump berry * Debump markdown plugin * Explicit add of typedoc plugins * Bump dev (typedoc exec) * Bump md	2020-08-26 10:46:33 +02:00
Github Actions	c42b517293	[CI Skip] release/beta 3.4.0-beta.0 skip-checks: true	2020-08-25 19:22:10 +00:00
Jaco Greeff	e5dd55e419	Allow for WASM-as-available mnemonicToBip39 call (#669 )	2020-08-25 21:16:22 +02:00
Github Actions	83fdd11c59	[CI Skip] release/stable 3.3.1 skip-checks: true	2020-08-24 07:11:21 +00:00
Jaco Greeff	08de8ce25a	3.3 (#668 )	2020-08-24 09:05:24 +02:00
Github Actions	800bafc00c	[CI Skip] release/beta 3.3.0-beta.2 skip-checks: true	2020-08-22 11:38:10 +00:00
Jaco Greeff	3b383b97ca	Add addressRaw to keyring interface (#667 ) * addressRaw to keyring interface * Typos * nobody * Slice -20 for Ethereum * addressRaw tests	2020-08-22 13:32:14 +02:00
Github Actions	b381c09ecf	[CI Skip] release/beta 3.3.0-beta.1 skip-checks: true	2020-08-18 09:45:16 +00:00
Jaco Greeff	a53008fd67	Bump deps (#665 )	2020-08-18 11:39:52 +02:00
Github Actions	899056c5a2	[CI Skip] release/beta 3.3.0-beta.0 skip-checks: true	2020-08-17 17:59:41 +00:00
Jaco Greeff	8554d47030	Ethereum keypair signing & verification (#664 ) * Ethereum keypair signing & verification * Verify against hashes expanded * Adjust via flags * ss58 encoding for 33-byte publicKey * ecdsa types stores address as raw publicKey * Adjust for hash lengths * Adjust expand/compress specs	2020-08-17 19:52:44 +02:00
Github Actions	9808f58540	[CI Skip] release/stable 3.2.1 skip-checks: true	2020-08-17 10:23:06 +00:00
Jaco Greeff	7228100835	3.2 (#663 )	2020-08-17 12:17:44 +02:00
Github Actions	08c1b413d2	[CI Skip] release/beta 3.2.0-beta.4 skip-checks: true	2020-08-17 09:34:41 +00:00
Jaco Greeff	27ae11860d	Add Ethereum-compatible seed from mnemonic (#662 ) * Add Ethereum-compatible seed from mnemonic * Change encode signature to allow publicKeys * Make CC happier	2020-08-17 11:28:59 +02:00
Github Actions	9cc984e8ae	[CI Skip] release/beta 3.2.0-beta.3 skip-checks: true	2020-08-14 10:48:37 +00:00
Jaco Greeff	d352782927	Ethereum keypair support (#661 ) * Ethereum keypair support * keypair support from seed * Signature verification * Cleanups * Cleanup encode (no extra toLower) * u8aToU8a * Simulate random failure with range * Cleanup BN conversions	2020-08-14 12:41:56 +02:00
Jaco Greeff	6e4a5281ed	Bump deps (#660 )	2020-08-12 17:02:26 +02:00
Github Actions	d11f6d9307	[CI Skip] release/beta 3.2.0-beta.2 skip-checks: true	2020-08-11 14:49:56 +00:00
Jaco Greeff	61b57687af	Ethereum address utils (#659 ) * Ethereum address utils * export in base	2020-08-11 16:46:01 +02:00
Github Actions	3ab1623a40	[CI Skip] release/beta 3.2.0-beta.1 skip-checks: true	2020-08-11 14:25:08 +00:00
Jaco Greeff	f5acd60253	Actually expose base32* functions (#658 )	2020-08-11 16:20:39 +02:00
Github Actions	c4d368d2b5	[CI Skip] release/beta 3.2.0-beta.0 skip-checks: true	2020-08-11 06:59:01 +00:00
Jaco Greeff	e487d0a454	- Allow for hasher to secp256k1 sign/verify functions (#657 )	2020-08-11 08:54:52 +02:00
Github Actions	99ffcc52ec	[CI Skip] release/stable 3.1.1 skip-checks: true	2020-08-10 04:51:43 +00:00
Jaco Greeff	64510af8d3	3.1 (#655 )	2020-08-10 06:47:53 +02:00
Github Actions	52b14db475	[CI Skip] release/beta 3.1.0-beta.8 skip-checks: true	2020-08-09 12:45:13 +00:00
Jaco Greeff	c5fe5cd8d4	Bump @polkadot/wasm (#654 )	2020-08-09 14:41:40 +02:00
Github Actions	bdfc614ad5	[CI Skip] release/beta 3.1.0-beta.7 skip-checks: true	2020-08-09 12:29:56 +00:00
Jaco Greeff	0d03eac307	Add deriveAddress (#653 )	2020-08-09 14:26:37 +02:00
Github Actions	6c84edcb9d	[CI Skip] release/beta 3.1.0-beta.6 skip-checks: true	2020-08-09 11:31:44 +00:00
Jaco Greeff	9d145e72b8	Base32 encoding/decoding (#652 ) * Base32 encoding/decoding * Attribution * LOOKUP * Share base32/58 alphabet validation * Apply suggestions from code review	2020-08-09 13:27:47 +02:00
Github Actions	4529bc37b5	[CI Skip] release/beta 3.1.0-beta.5 skip-checks: true	2020-08-08 07:07:37 +00:00
Jaco Greeff	038ef42fe5	Bump deps (#651 )	2020-08-08 09:03:58 +02:00
Github Actions	1871d36a97	[CI Skip] release/beta 3.1.0-beta.4 skip-checks: true	2020-08-06 12:19:34 +00:00
Jaco Greeff	45c2afae07	Bump berry (#650 ) * Bump berry * Rewrite	2020-08-06 14:15:37 +02:00
Github Actions	51edae2f67	[CI Skip] release/beta 3.1.0-beta.3 skip-checks: true	2020-08-05 14:32:25 +00:00
Jaco Greeff	437314e5ea	Bump wasm-crypto (#649 ) * Bump wasm-crypto * Rewrite yarn.lock	2020-08-05 16:28:22 +02:00
Jaco Greeff	ce6f9d8bc8	Scrypt via wasm-crypto (#647 ) * Scrypt via wasm-crypto * Bump wasm-crypto	2020-08-05 16:07:38 +02:00
Github Actions	0cf65e1671	[CI Skip] release/beta 3.1.0-beta.2 skip-checks: true	2020-07-31 13:52:39 +00:00
Brad Larson	a0251ff650	[FIX] Adjust error message (#646 ) I ran into a case where the secret value provided had trailing whitespace, and when the code ran, it logged that secret value as part of the stack trace. This change will make it harder for users to accidentally leak key material.	2020-07-31 15:48:31 +02:00
Github Actions	9696badcd1	[CI Skip] release/beta 3.1.0-beta.1 skip-checks: true	2020-07-31 08:07:03 +00:00
Jaco Greeff	08817d199d	Bump deps (#645 )	2020-07-31 10:02:57 +02:00
Github Actions	df69a02e6f	[CI Skip] release/beta 3.1.0-beta.0 skip-checks: true	2020-07-30 14:02:55 +00:00
Jaco Greeff	e845132d89	Bump deps (#644 )	2020-07-30 15:58:17 +02:00
Github Actions	21e9b9a033	[CI Skip] release/stable 3.0.1 skip-checks: true	2020-07-27 06:21:35 +00:00
Jaco Greeff	db61ea3077	3.0 release (#643 )	2020-07-27 08:17:28 +02:00
Github Actions	d4a3d2392e	[CI Skip] release/beta 3.0.0-beta.4 skip-checks: true	2020-07-27 06:09:08 +00:00
Jaco Greeff	88ecda706d	3.0 (#642 ) * 3.0 * Bump dev	2020-07-27 08:05:04 +02:00
Github Actions	184fb1f12e	[CI Skip] release/beta 3.0.0-beta.3 skip-checks: true	2020-07-22 15:45:42 +00:00
Reto Trinkler	91340577df	Adding 4 as address type of ss58 for Katal Chain (#639 )	2020-07-22 17:41:49 +02:00
Github Actions	36729678e2	[CI Skip] release/beta 3.0.0-beta.2 skip-checks: true	2020-07-21 07:06:23 +00:00
Jaco Greeff	1c6b4bfc34	Dev bump	2020-07-21 09:02:25 +02:00
Github Actions	bbfd175579	[CI Skip] release/beta 3.0.0-beta.1 skip-checks: true	2020-07-21 06:21:56 +00:00
Jaco Greeff	0a6bd41444	Keyring JSON with kdf (#637 ) * Keyring JSON with pbkdf2 * pbkdf2 from wasm * Encode/decode defaults adjusted * v2 decoding test * Recode refreshes defaults * Use scrypt for kdf * test conversions * Fix params * Cleanup decoding pass * Swap encoding to base64 * Update for base64 encoding * 3.0.0	2020-07-21 08:17:46 +02:00
Github Actions	ab21274c36	[CI Skip] release/beta 2.19.0-beta.2 skip-checks: true	2020-07-17 12:30:08 +00:00
Jaco Greeff	d4e6ad5553	Bump dev	2020-07-17 14:26:11 +02:00
Github Actions	49dbd757df	[CI Skip] release/beta 2.19.0-beta.1 skip-checks: true	2020-07-17 12:07:35 +00:00
Jaco Greeff	20e82cc45b	Dev bump	2020-07-17 14:03:36 +02:00
Github Actions	6a7fa80c55	[CI Skip] release/beta 2.19.0-beta.0 skip-checks: true	2020-07-17 06:39:13 +00:00
Jaco Greeff	12e34cd3e8	Bump deps (#635 )	2020-07-17 08:35:10 +02:00
Github Actions	0a598fdf92	[CI Skip] release/stable 2.18.1 skip-checks: true	2020-07-13 08:51:33 +00:00
Jaco Greeff	659b896ee7	2.18 (#634 )	2020-07-13 10:47:53 +02:00
Github Actions	7cda007a30	[CI Skip] release/beta 2.18.0-beta.3 skip-checks: true	2020-07-09 07:19:51 +00:00
Jaco Greeff	2288c4da8a	Base64 utils (#632 )	2020-07-09 09:16:24 +02:00
Github Actions	fbfc21be1c	[CI Skip] release/beta 2.18.0-beta.2 skip-checks: true	2020-07-08 13:39:52 +00:00
Jaco Greeff	787beb2aea	Add isUtf8 (#631 )	2020-07-08 15:35:43 +02:00
Github Actions	6234e16c37	[CI Skip] release/beta 2.18.0-beta.1 skip-checks: true	2020-07-08 11:58:35 +00:00
Jaco Greeff	e9cbc0a0d9	Bump deps (#630 )	2020-07-08 13:54:57 +02:00
Github Actions	166eeb8852	[CI Skip] release/beta 2.18.0-beta.0 skip-checks: true	2020-07-08 09:18:38 +00:00
Jaco Greeff	b321f92161	Add isAscii (#629 )	2020-07-08 11:14:55 +02:00
Github Actions	cf7d9d9ff5	[CI Skip] release/stable 2.17.1 skip-checks: true	2020-07-06 04:41:13 +00:00
Jaco Greeff	fb5b3c1663	2.17 (#628 )	2020-07-06 06:37:16 +02:00
Github Actions	46bbc45145	[CI Skip] release/beta 2.17.0-beta.3 skip-checks: true	2020-07-04 08:12:18 +00:00
Jaco Greeff	dc8b4a6447	Add encode{Derived, Multi}Address (#627 ) * Add encode{Derived, Multi}Address * Tests for encode* * CHANGELOG	2020-07-04 10:08:40 +02:00
Github Actions	8ec38eca4a	[CI Skip] release/beta 2.17.0-beta.2 skip-checks: true	2020-07-02 05:36:03 +00:00
Jaco Greeff	24b533689c	Handle 0 on numberToU8a (#626 ) * Handle 0 on numberToU8a * Remove old test (replaced) * base58 CHANGELOG	2020-07-02 07:32:25 +02:00
Github Actions	5421e06fc9	[CI Skip] release/beta 2.17.0-beta.1 skip-checks: true	2020-07-02 05:29:40 +00:00
Jaco Greeff	7115efd94f	Simplify base58 dependency tree (#624 )	2020-07-02 07:26:04 +02:00
Github Actions	92f88222c4	[CI Skip] release/beta 2.17.0-beta.0 skip-checks: true	2020-07-02 05:12:02 +00:00
Jaco Greeff	bc7aba71a6	Bump deps (#625 )	2020-07-02 07:08:40 +02:00
Github Actions	1d8b8b3204	[CI Skip] release/stable 2.16.1 skip-checks: true	2020-06-29 05:19:13 +00:00
Jaco Greeff	4a2e090ef8	2.16 (#623 )	2020-06-29 07:15:21 +02:00
Github Actions	8cf8d5b7e8	[CI Skip] release/beta 2.16.0-beta.0 skip-checks: true	2020-06-26 12:49:47 +00:00
Jaco Greeff	8d355ff6fc	Local base58 alphabet check for better errors (#622 ) * Local base58 alphabet check for better errors * Rewrite yarn.lock * Align error return values * Split base58{Encode, Decode} * base58Encode input types * Function names, some docs	2020-06-26 14:46:19 +02:00
Github Actions	72456bb2bd	[CI Skip] release/stable 2.15.1 skip-checks: true	2020-06-22 09:33:14 +00:00
Jaco Greeff	87f3fd2827	2.15 (#621 )	2020-06-22 11:29:33 +02:00
Github Actions	7254aab68d	[CI Skip] release/beta 2.15.0-beta.0 skip-checks: true	2020-06-19 15:39:36 +00:00
Jaco Greeff	95d7160ad0	Test for 0 prefix (#620 ) * Test for 0 prefix * Add test for keyring encodeAddress (& fix) * Test other branch of ?: check	2020-06-19 17:35:48 +02:00
Github Actions	611b1be481	[CI Skip] release/stable 2.14.1 skip-checks: true	2020-06-16 06:02:06 +00:00
Jaco Greeff	73b35fc188	2.14 (#618 )	2020-06-16 07:58:33 +02:00
Github Actions	6c30d5b9fd	[CI Skip] release/beta 2.14.0-beta.0 skip-checks: true	2020-06-08 15:58:49 +00:00
Keith Ingram	56d151fe66	Add BN consts and timeToString (#610 ) * Add BN consts and timeToString * docs * lint * fixes * lint * lint * add tests, ms * fix * test	2020-06-09 03:55:21 +12:00
Github Actions	cd20fe6c8b	[CI Skip] release/stable 2.13.1 skip-checks: true	2020-06-08 14:03:31 +00:00
Jaco Greeff	28f8ca73aa	2.13 (#616 )	2020-06-08 15:59:47 +02:00
Github Actions	f4a8bfc0c0	[CI Skip] release/beta 2.13.0-beta.5 skip-checks: true	2020-06-08 12:33:10 +00:00
Jaco Greeff	94b058d6a3	Align bnToHex signature with bnToU8a (#615 )	2020-06-08 14:29:40 +02:00
Github Actions	3d7ddb85a2	[CI Skip] release/beta 2.13.0-beta.4 skip-checks: true	2020-06-08 11:35:08 +00:00
Jaco Greeff	f7a2bb895f	Fix blake2 U8a JS with hex inputs (#614 ) * Fix blake2 U8a JS with hex inputs * Apply suggestions from code review	2020-06-08 13:31:10 +02:00
Github Actions	c1bfcc00b6	[CI Skip] release/beta 2.13.0-beta.3 skip-checks: true	2020-06-06 08:08:42 +00:00
Jaco Greeff	b16d8e7c26	Bump deps (#612 )	2020-06-06 10:05:02 +02:00
Github Actions	2a4b363fcd	[CI Skip] release/beta 2.13.0-beta.2 skip-checks: true	2020-06-05 20:17:13 +00:00
Jaco Greeff	de689b8e6f	Bump deps (#611 )	2020-06-05 22:13:55 +02:00
Github Actions	2e72ab920b	[CI Skip] release/beta 2.13.0-beta.1 skip-checks: true	2020-06-02 09:44:29 +00:00
Jaco Greeff	565e6baecd	Linting	2020-06-02 11:40:25 +02:00
Jaco Greeff	1e15203b6c	Reset to beta	2020-06-02 11:24:23 +02:00