[CI Skip] release/stable 4.1.1

skip-checks: true

.eslintrc.js

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

CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 4.1.1 Nov 16, 2020
+
+Contributed:
+
+- Expand ETH tests, allow for verification against address (Thanks to https://github.com/joelamouche)
+
+Changes:
+
+- Replace pbkdf2 imports with explicit use from sync-only package
+- Adjust secp256k1 imports with shared elliptic
+- Expand crypto tests for explicit wasm vs JS compares in all cases
+
+
 ## 4.0.1 Nov 8, 2020
 
 - **Breaking change** Polyfills are not injected by these libraries anymore to avoid clobbering external globals, the user should provide them if their environment is missing base functionality.

babel.config.js

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

jest.config.js

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/util authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const config = require('@polkadot/dev/config/jest');
+const config = require('@polkadot/dev/config/jest.cjs');
 
 module.exports = Object.assign({}, config, {
   moduleNameMapper: {
@@ -23,5 +23,5 @@ module.exports = Object.assign({}, config, {
     '<rootDir>/packages/x-textencoder/build',
     '<rootDir>/packages/x-ws/build'
   ],
-  resolver: '@polkadot/dev/config/jest-resolver'
+  resolver: '@polkadot/dev/config/jest-resolver.cjs'
 });

package.json

@@ -21,9 +21,9 @@
   },
   "devDependencies": {
     "@babel/core": "^7.12.3",
-    "@polkadot/dev": "^0.59.20",
-    "@polkadot/ts": "^0.3.53",
+    "@polkadot/dev": "^0.60.2",
+    "@polkadot/ts": "^0.3.55",
     "@types/jest": "^26.0.15"
   },
-  "version": "4.0.1"
+  "version": "4.1.1"
 }

packages/keyring/package.json

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

packages/keyring/src/detectPackage.ts

@@ -0,0 +1,7 @@
+// Copyright 2017-2020 @polkadot/keyring authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { detectPackage } from '@polkadot/util';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+detectPackage(require('./package.json'), typeof __dirname !== 'undefined' && __dirname);

packages/keyring/src/index.ts

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

packages/keyring/src/keyring.ts

@@ -8,8 +8,8 @@ import { assert, hexToU8a, isHex, isUndefined, stringToU8a } from '@polkadot/uti
 import { base64Decode, decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToLegacySeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
-import createPair from './pair';
-import Pairs from './pairs';
+import { createPair } from './pair';
+import { Pairs } from './pairs';
 
 const keypairFromSeed = {
   ecdsa: (seed: Uint8Array): Keypair => secp256k1FromSeed(seed),
@@ -34,7 +34,7 @@ const keypairFromSeed = {
  * lookup of a pair for a given account address or public key using `getPair`. JSON metadata associated with
  * an account may be obtained using `toJson` accompanied by the account passphrase.
  */
-export default class Keyring implements KeyringInstance {
+export class Keyring implements KeyringInstance {
   readonly #pairs: Pairs;
 
   readonly #type: KeypairType;

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

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

packages/keyring/src/pair/decode.ts

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

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

@@ -1,13 +1,13 @@
 // Copyright 2017-2020 @polkadot/keyring authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import testingPairs from '../testingPairs';
+import { createTestPairs } from '../testingPairs';
 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 = 16 + PKCS8_LENGTH + NONCE_LENGTH + SCRYPT_LENGTH;
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('encode', (): void => {
   it('returns PKCS8 when no passphrase supplied', (): void => {

packages/keyring/src/pair/encode.ts

@@ -8,7 +8,7 @@ import { naclEncrypt, scryptEncode, scryptToU8a } from '@polkadot/util-crypto';
 
 import { PKCS8_DIVIDER, PKCS8_HEADER } from './defaults';
 
-export default function encode ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
+export function encodePair ({ publicKey, secretKey }: PairInfo, passphrase?: string): Uint8Array {
   assert(secretKey, 'Expected a valid secretKey to be passed to encode');
 
   const encoded = u8aConcat(

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

@@ -6,10 +6,10 @@ import { cryptoWaitReady, encodeAddress as toSS58, setSS58Format } from '@polkad
 import { hexToU8a } from '@polkadot/util';
 
 import { PAIRS } from '../testing';
-import testingPairs from '../testingPairs';
-import createPair from '.';
+import { createTestPairs } from '../testingPairs';
+import { createPair } from '.';
 
-const keyring = testingPairs({ type: 'ed25519' }, false);
+const keyring = createTestPairs({ type: 'ed25519' }, false);
 
 describe('pair', (): void => {
   beforeEach(async (): Promise<void> => {

packages/keyring/src/pair/index.ts

@@ -8,9 +8,9 @@ import { PairInfo } from './types';
 import { assert, u8aConcat, u8aToHex } from '@polkadot/util';
 import { blake2AsU8a, ethereumEncode, keccakAsU8a, keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, secp256k1Expand, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, secp256k1Compress, signatureVerify } from '@polkadot/util-crypto';
 
-import decode from './decode';
-import encode from './encode';
-import toJson from './toJson';
+import { decodePair } from './decode';
+import { encodePair } from './encode';
+import { pairToJson } from './toJson';
 
 interface Setup {
   toSS58: (publicKey: Uint8Array) => string;
@@ -34,9 +34,9 @@ const TYPE_PREFIX = {
 };
 
 const TYPE_SIGNATURE = {
-  ecdsa: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, { hashType: 'blake2' }),
+  ecdsa: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'blake2'),
   ed25519: naclSign,
-  ethereum: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, { hashType: 'keccak' }),
+  ethereum: (m: Uint8Array, p: Partial<Keypair>) => secp256k1Sign(m, p, 'keccak'),
   sr25519: schnorrkelSign
 };
 
@@ -57,7 +57,7 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
 }
 
 /**
- * @name pair
+ * @name createPair
  * @summary Creates a keyring pair object
  * @description Creates a keyring pair object with provided account public key, metadata, and encoded arguments.
  * The keyring pair stores the account state including the encoded address and associated metadata.
@@ -87,9 +87,9 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
  * an `encoded` property that is assigned with the encoded public key in hex format, and an `encoding`
  * property that indicates whether the public key value of the `encoded` property is encoded or not.
  */
-export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
+export function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, encTypes?: KeyringPair$JsonEncodingTypes[]): KeyringPair {
   const decodePkcs8 = (passphrase?: string, userEncoded?: Uint8Array | null): void => {
-    const decoded = decode(passphrase, userEncoded || encoded, encTypes);
+    const decoded = decodePair(passphrase, userEncoded || encoded, encTypes);
 
     if (decoded.secretKey.length === 64) {
       publicKey = decoded.publicKey;
@@ -105,7 +105,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
   const recode = (passphrase?: string): Uint8Array => {
     isLocked(secretKey) && encoded && decodePkcs8(passphrase, encoded);
 
-    encoded = encode({ publicKey, secretKey }, passphrase); // re-encode, latest version
+    encoded = encodePair({ publicKey, secretKey }, passphrase); // re-encode, latest version
     encTypes = undefined; // swap to defaults, latest version follows
 
     return encoded;
@@ -175,9 +175,9 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
         ? u8aToHex(secp256k1Compress(publicKey))
         : encodeAddress();
 
-      return toJson(type, { address, meta }, recode(passphrase), !!passphrase);
+      return pairToJson(type, { address, meta }, recode(passphrase), !!passphrase);
     },
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
-      signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey), type === 'ethereum').isValid
+      signatureVerify(message, signature, TYPE_ADDRESS[type](publicKey)).isValid
   };
 }

packages/keyring/src/pair/nobody.ts

@@ -22,7 +22,7 @@ const json: KeyringPair$Json = {
   meta
 };
 
-export default function everybody (): KeyringPair {
+export function nobody (): KeyringPair {
   const pair: KeyringPair = {
     address,
     addressRaw: publicKey,

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

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

packages/keyring/src/pair/toJson.ts

@@ -19,7 +19,7 @@ const VERSION = '3';
 
 const ENC_NONE: KeyringPair$JsonEncodingTypes[] = ['none'];
 
-export default function toJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
+export function pairToJson (type: KeypairType, { address, meta }: PairStateJson, encoded: Uint8Array, isEncrypted: boolean): KeyringPair$Json {
   return {
     address,
     encoded: base64Encode(encoded),

packages/keyring/src/pairs.ts

@@ -8,7 +8,7 @@ import { decodeAddress } from '@polkadot/util-crypto';
 
 type KeyringPairMap = Record<string, KeyringPair>;
 
-export default class Pairs implements KeyringPairs {
+export class Pairs implements KeyringPairs {
   readonly #map: KeyringPairMap = {};
 
   public add (pair: KeyringPair): KeyringPair {

packages/keyring/src/testing.ts

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

packages/keyring/src/testingPairs.spec.ts

@@ -3,7 +3,7 @@
 
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 
-import testingPairs from './testingPairs';
+import { createTestPairs } from './testingPairs';
 
 describe('testingPairs', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -12,19 +12,19 @@ describe('testingPairs', (): void => {
 
   it('creates without failing', (): void => {
     expect(
-      Object.keys(testingPairs())
+      Object.keys(createTestPairs())
     ).toHaveLength(2 + 0 + 7); // stash, session, pairs
   });
 
   it('has the correct address for Alice (non-HDKD)', (): void => {
     expect(
-      testingPairs({ type: 'ed25519' }, false).alice.address
+      createTestPairs({ type: 'ed25519' }, false).alice.address
     ).toEqual('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua');
   });
 
   it('has the correct address for Alice (HDKD)', (): void => {
     expect(
-      testingPairs({ type: 'ed25519' }).alice.address
+      createTestPairs({ type: 'ed25519' }).alice.address
     ).toEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY');
   });
 });

packages/keyring/src/testingPairs.ts

@@ -3,15 +3,15 @@
 
 import { KeyringPair, KeyringOptions } from './types';
 
-import createKeyring from './testing';
-import nobody from './pair/nobody';
+import { createTestKeyring } from './testing';
+import { nobody } from './pair/nobody';
 
 export interface TestKeyringMap {
   [index: string]: KeyringPair;
 }
 
-export default function testKeyringPairs (options?: KeyringOptions, isDerived = true): TestKeyringMap {
-  const keyring = createKeyring(options, isDerived);
+export function createTestPairs (options?: KeyringOptions, isDerived = true): TestKeyringMap {
+  const keyring = createTestKeyring(options, isDerived);
   const pairs = keyring.getPairs();
   const map: TestKeyringMap = { nobody: nobody() };
 

packages/networks/package.json

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

packages/util-crypto/package.json

@@ -1,42 +1,32 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
+  "sideEffects": false,
   "keywords": [
     "Polkadot"
   ],
   "author": "Jaco Greeff <jacogr@gmail.com>",
-  "maintainers": [
-    "Jaco Greeff <jacogr@gmail.com>"
-  ],
+  "maintainers": [],
   "contributors": [],
   "license": "Apache-2.0",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/polkadot-js/common.git"
-  },
-  "bugs": {
-    "url": "https://github.com/polkadot-js/common/issues"
-  },
+  "repository": "github:polkadot-js/common",
+  "bugs": "https://github.com/polkadot-js/common/issues",
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.12.1",
-    "@polkadot/networks": "4.0.1",
-    "@polkadot/util": "4.0.1",
+    "@babel/runtime": "^7.12.5",
+    "@polkadot/networks": "4.1.1",
+    "@polkadot/util": "4.1.1",
     "@polkadot/wasm-crypto": "^2.0.1",
-    "@polkadot/x-randomvalues": "4.0.1",
+    "@polkadot/x-randomvalues": "4.1.1",
     "base-x": "^3.0.8",
     "blakejs": "^1.1.0",
     "bn.js": "^5.1.3",
     "create-hash": "^1.2.0",
     "elliptic": "^6.5.3",
+    "hash.js": "^1.1.7",
     "js-sha3": "^0.8.0",
-    "pbkdf2": "^3.1.1",
     "scryptsy": "^2.1.0",
     "tweetnacl": "^1.0.3",
     "xxhashjs": "^0.2.2"
@@ -45,11 +35,10 @@
     "@types/bn.js": "^4.11.6",
     "@types/create-hash": "^1.2.2",
     "@types/elliptic": "^6.4.12",
-    "@types/pbkdf2": "^3.1.0",
     "@types/scryptsy": "^2.0.0",
     "@types/xxhashjs": "^0.2.2"
   },
   "peerDependencies": {
-    "@polkadot/util": "4.0.1"
+    "@polkadot/util": "4.1.1"
   }
 }

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

@@ -3,7 +3,7 @@
 
 import { hexToU8a } from '@polkadot/util';
 
-import addressToEvm from './addressToEvm';
+import { addressToEvm } from './addressToEvm';
 
 describe('addressToEvm', (): void => {
   it('creates a valid known EVM address', (): void => {

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

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

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

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

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

@@ -3,9 +3,9 @@
 
 import { Prefix } from './types';
 
-import base58Decode from '../base58/decode';
-import checkChecksum from './checkChecksum';
-import defaults from './defaults';
+import { base58Decode } from '../base58/decode';
+import { checkAddressChecksum } from './checksum';
+import { defaults } from './defaults';
 
 /**
  * @name checkAddress
@@ -13,7 +13,7 @@ import defaults from './defaults';
  * @description
  * From the provided input, validate that the address is a valid input.
  */
-export default function check (address: string, prefix: Prefix): [boolean, string | null] {
+export function checkAddress (address: string, prefix: Prefix): [boolean, string | null] {
   let decoded;
 
   try {
@@ -28,7 +28,7 @@ export default function check (address: string, prefix: Prefix): [boolean, strin
     return [false, 'Invalid decoded address length'];
   }
 
-  const [isValid] = checkChecksum(decoded);
+  const [isValid] = checkAddressChecksum(decoded);
 
   return [isValid, isValid ? null : 'Invalid decoded address checksum'];
 }

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

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

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

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

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

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

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

@@ -3,12 +3,10 @@
 
 import { available } from '@polkadot/networks';
 
-const defaults = {
+export const defaults = {
   allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
   // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
   allowedEncodedLengths: [3, 4, 6, 10, 35, 36],
   allowedPrefix: available.map(({ prefix }) => prefix),
   prefix: 42
 };
-
-export default defaults;

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

@@ -3,7 +3,7 @@
 
 import { waitReady } from '@polkadot/wasm-crypto';
 
-import derive from './derive';
+import { deriveAddress } from '.';
 
 describe('deriveAddress', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -12,13 +12,13 @@ describe('deriveAddress', (): void => {
 
   it('derives a known path', (): void => {
     expect(
-      derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
+      deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '/joe/polkadot/0')
     ).toEqual('5GZ4srnepXvdsuNVoxCGyVZd8ScDm4gkGLTKuaGARy9akjTa');
   });
 
   it('fails on hard paths', (): void => {
     expect(
-      () => derive('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
+      () => deriveAddress('5CZtJLXtVzrBJq1fMWfywDa6XuRwXekGdShPR4b8i9GWSbzB', '//bob')
     ).toThrow(/Expected suri to contain a combination of non-hard paths/);
   });
 });

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

@@ -5,11 +5,11 @@ import { Prefix } from './types';
 
 import { assert } from '@polkadot/util';
 
-import DeriveJunction from '../key/DeriveJunction';
+import { DeriveJunction } from '../key/DeriveJunction';
 import { keyExtractPath } from '../key';
 import { schnorrkelDerivePublic } from '../schnorrkel';
-import decode from './decode';
-import encode from './encode';
+import { decodeAddress } from './decode';
+import { encodeAddress } from './encode';
 
 /**
  * @name deriveAddress
@@ -17,12 +17,12 @@ import encode from './encode';
  * @description
  * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
  */
-export default function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
+export function deriveAddress (who: Uint8Array | string, suri: string, ss58Format?: Prefix): string {
   const { path } = keyExtractPath(suri);
 
   assert(path.length && !path.some((path) => path.isHard), 'Expected suri to contain a combination of non-hard paths');
 
-  return encode(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
+  return encodeAddress(path.reduce((publicKey: Uint8Array, path: DeriveJunction): Uint8Array => {
     return schnorrkelDerivePublic(publicKey, path.chainCode);
-  }, decode(who)), ss58Format);
+  }, decodeAddress(who)), ss58Format);
 }

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

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

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

@@ -7,14 +7,14 @@ import { Prefix } from './types';
 
 import { assert, u8aConcat } from '@polkadot/util';
 
-import base58Encode from '../base58/encode';
-import decode from './decode';
-import defaults from './defaults';
-import sshash from './sshash';
+import { base58Encode } from '../base58/encode';
+import { decodeAddress } from './decode';
+import { defaults } from './defaults';
+import { sshash } from './sshash';
 
-export default function encode (_key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
+export function encodeAddress (_key: Uint8Array | string, ss58Format: Prefix = defaults.prefix): string {
   // decode it, this means we can re-encode an address
-  const key = decode(_key);
+  const key = decodeAddress(_key);
 
   assert(defaults.allowedDecodedLengths.includes(key.length), `Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
 

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

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

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

@@ -5,9 +5,9 @@ import { Prefix } from './types';
 
 import BN from 'bn.js';
 
-import decode from './decode';
-import encode from './encode';
-import keyDerived from './keyDerived';
+import { decodeAddress } from './decode';
+import { encodeAddress } from './encode';
+import { createKeyDerived } from './keyDerived';
 
 /**
  * @name encodeDerivedAddress
@@ -15,6 +15,6 @@ import keyDerived from './keyDerived';
  * @description
  * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
  */
-export default function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
-  return encode(keyDerived(decode(who), index), ss58Format);
+export function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
 }

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

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

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

@@ -5,8 +5,8 @@ import { Prefix } from './types';
 
 import BN from 'bn.js';
 
-import encode from './encode';
-import keyMulti from './keyMulti';
+import { encodeAddress } from './encode';
+import { createKeyMulti } from './keyMulti';
 
 /**
  * @name encodeMultiAddress
@@ -14,6 +14,6 @@ import keyMulti from './keyMulti';
  * @description
  * Creates a Substrate multisig address based on the input address and the required threshold.
  */
-export default function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
-  return encode(keyMulti(who, threshold), ss58Format);
+export function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encodeAddress(createKeyMulti(who, threshold), ss58Format);
 }

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

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

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

@@ -3,7 +3,7 @@
 
 import { u8aEq } from '@polkadot/util';
 
-import decode from './decode';
+import { decodeAddress } from './decode';
 
 /**
  * @name addressEq
@@ -19,6 +19,6 @@ import decode from './decode';
  * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
  * ```
  */
-export default function addressEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
-  return u8aEq(decode(a), decode(b));
+export function addressEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
+  return u8aEq(decodeAddress(a), decodeAddress(b));
 }

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

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

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

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

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

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

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

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

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

@@ -4,12 +4,12 @@
 import BN from 'bn.js';
 import { bnToU8a, stringToU8a, u8aConcat } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
-import decodeAddress from './decode';
+import { blake2AsU8a } from '../blake2/asU8a';
+import { decodeAddress } from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export default function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
+export function createKeyDerived (who: Uint8Array | string, index: BigInt | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

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

@@ -4,12 +4,12 @@
 import BN from 'bn.js';
 import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
-import decodeAddress from './decode';
+import { blake2AsU8a } from '../blake2/asU8a';
+import { decodeAddress } from './decode';
 
 const PREFIX = stringToU8a('modlpy/utilisuba');
 
-export default function createKeyMulti (who: (Uint8Array | string)[], threshold: BigInt | BN | number): Uint8Array {
+export function createKeyMulti (who: (Uint8Array | string)[], threshold: BigInt | BN | number): Uint8Array {
   return blake2AsU8a(
     u8aConcat(
       PREFIX,

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

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

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

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

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

@@ -5,10 +5,10 @@ import { Prefix } from './types';
 
 import { u8aSorted } from '@polkadot/util';
 
-import decodeAddress from './decode';
-import encodeAddress from './encode';
+import { decodeAddress } from './decode';
+import { encodeAddress } from './encode';
 
-export default function sortAddresses (addresses: (Uint8Array | string)[], ss58Format?: Prefix): string[] {
+export function sortAddresses (addresses: (Uint8Array | string)[], ss58Format?: Prefix): string[] {
   return u8aSorted(
     addresses.map((who) => decodeAddress(who))
   ).map((u8a) => encodeAddress(u8a, ss58Format));

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

@@ -3,10 +3,10 @@
 
 import { stringToU8a, u8aConcat } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
+import { blake2AsU8a } from '../blake2/asU8a';
 
 const SS58_PREFIX = stringToU8a('SS58PRE');
 
-export default function hash (key: Uint8Array): Uint8Array {
+export function sshash (key: Uint8Array): Uint8Array {
   return blake2AsU8a(u8aConcat(SS58_PREFIX, key), 512);
 }

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

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

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

@@ -15,7 +15,7 @@ const MASK = (1 << BITS_PER_CHAR) - 1;
  * @description
  * From the provided input, create the base32 and return the result as a string.
  */
-export default function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
+export function base32Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat = false): string {
   const u8a = u8aToU8a(value);
   let out = '';
   let bits = 0;

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

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

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

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

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

@@ -12,6 +12,6 @@ const BASE_CONFIG = { alphabet: BASE32_ALPHABET, ipfsChar: 'b', type: 'base32' }
  * @description
  * Validates the the supplied value is valid base32
  */
-export default function base32Validate (value?: string | null, ipfsCompat?: boolean): true {
+export function base32Validate (value?: string | null, ipfsCompat?: boolean): true {
   return validateChars(BASE_CONFIG, value, ipfsCompat);
 }

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

@@ -4,7 +4,7 @@
 import { bufferToU8a } from '@polkadot/util';
 
 import { bs58 } from './bs58';
-import validate from './validate';
+import { base58Validate } from './validate';
 
 /**
  * @name base58Decode
@@ -12,8 +12,8 @@ import validate from './validate';
  * @description
  * From the provided input, decode the base58 and return the result as an `Uint8Array`.
  */
-export default function base58Decode (value: string, ipfsCompat?: boolean): Uint8Array {
-  validate(value, ipfsCompat);
+export function base58Decode (value: string, ipfsCompat?: boolean): Uint8Array {
+  base58Validate(value, ipfsCompat);
 
   return bufferToU8a(bs58.decode(value.substr(ipfsCompat ? 1 : 0)));
 }

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

@@ -11,7 +11,7 @@ import { bs58 } from './bs58';
  * @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 {
+export function base58Encode (value: Uint8Array | string | Buffer | number[], ipfsCompat?: boolean): string {
   const out = bs58.encode(
     u8aToBuffer(u8aToU8a(value))
   );

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

@@ -5,7 +5,7 @@
  * @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';
+export { base58Decode } from './decode';
+export { base58Encode } from './encode';
+export { base58Validate } from './validate';
+export { isBase58 } from './is';

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

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { testValidator } from '../base32/is';
-import validate from './validate';
+import { base58Validate } from './validate';
 
-export default function isBase58 (value?: string | null, ipfsCompat?: boolean): boolean {
-  return testValidator(validate, value, ipfsCompat);
+export function isBase58 (value?: string | null, ipfsCompat?: boolean): boolean {
+  return testValidator(base58Validate, value, ipfsCompat);
 }

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

@@ -30,6 +30,6 @@ export function validateChars ({ alphabet, ipfsChar, type }: CheckConfig, value?
  * @description
  * Validates the the supplied value is valid base58
  */
-export default function base58Validate (value?: string | null, ipfsCompat?: boolean): true {
+export function base58Validate (value?: string | null, ipfsCompat?: boolean): true {
   return validateChars(BASE_CONFIG, value, ipfsCompat);
 }

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

@@ -3,7 +3,7 @@
 
 import { bufferToU8a } from '@polkadot/util';
 
-import validate from './validate';
+import { base64Validate } from './validate';
 
 /**
  * @name base64Decode
@@ -11,8 +11,8 @@ import validate from './validate';
  * @description
  * From the provided input, decode the base64 and return the result as an `Uint8Array`.
  */
-export default function base64Decode (value: string): Uint8Array {
-  validate(value);
+export function base64Decode (value: string): Uint8Array {
+  base64Validate(value);
 
   return bufferToU8a(Buffer.from(value, 'base64'));
 }

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

@@ -9,6 +9,6 @@ import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
  * @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 {
+export function base64Encode (value: Uint8Array | string | Buffer | number[]): string {
   return u8aToBuffer(u8aToU8a(value)).toString('base64');
 }

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

@@ -5,9 +5,9 @@
  * @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';
+export { base64Decode } from './decode';
+export { base64Encode } from './encode';
+export { base64Pad } from './pad';
+export { base64Trim } from './trim';
+export { base64Validate } from './validate';
+export { isBase64 } from './is';

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

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

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

@@ -1,6 +1,6 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export default function base64Trim (value: string): string {
+export function base64Pad (value: string): string {
   return value.padEnd(value.length + (value.length % 4), '=');
 }

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export default function base64Trim (value: string): string {
+export function base64Trim (value: string): string {
   while (value.length && value[value.length - 1] === '=') {
     value = value.slice(0, -1);
   }

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

@@ -9,7 +9,7 @@ import { assert } from '@polkadot/util';
  * @description
  * Validates the the supplied value is valid base64
  */
-export default function base64Validate (value?: string | null): true {
+export 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');
 

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

@@ -3,7 +3,7 @@
 
 import { u8aToHex } from '@polkadot/util';
 
-import blake2AsU8a from './asU8a';
+import { blake2AsU8a } from './asU8a';
 
 /**
  * @name blake2AsHex
@@ -19,7 +19,7 @@ import blake2AsU8a from './asU8a';
  * blake2AsHex('abc'); // => 0xba80a53f981c4d0d
  * ```
  */
-export default function blake2AsHex (data: Uint8Array | string, bitLength = 256): string {
+export function blake2AsHex (data: Uint8Array | string, bitLength = 256): string {
   return u8aToHex(
     blake2AsU8a(data, bitLength)
   );

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

@@ -11,36 +11,44 @@ describe('blake2AsU8a', (): void => {
     await waitReady();
   });
 
-  it('returns a 64-bit value by default', (): void => {
-    expect(
-      blake2AsU8a('abc')
-    ).toEqual(
-      new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
-    );
+  [false, true].forEach((onlyJs): void => {
+    it(`returns a 64-bit value by default (onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        blake2AsU8a('abc', undefined, undefined, onlyJs)
+      ).toEqual(
+        new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
+      );
+    });
   });
 
-  it('returns a 128-bit value (as specified)', (): void => {
-    expect(
-      blake2AsU8a('abc', 128)
-    ).toEqual(
-      new Uint8Array([207, 74, 183, 145, 198, 43, 141, 43, 33, 9, 201, 2, 117, 40, 120, 22])
-    );
+  [false, true].forEach((onlyJs): void => {
+    it(`returns a 128-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        blake2AsU8a('abc', 128, undefined, onlyJs)
+      ).toEqual(
+        new Uint8Array([207, 74, 183, 145, 198, 43, 141, 43, 33, 9, 201, 2, 117, 40, 120, 22])
+      );
+    });
   });
 
-  it('returns a 256-bit value (as specified)', (): void => {
-    expect(
-      blake2AsU8a('abc', 256)
-    ).toEqual(
-      new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
-    );
+  [false, true].forEach((onlyJs): void => {
+    it(`returns a 256-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        blake2AsU8a('abc', 256, undefined, onlyJs)
+      ).toEqual(
+        new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
+      );
+    });
   });
 
-  it('returns a 512-bit value (as specified)', (): void => {
-    expect(
-      blake2AsU8a('abc', 512)
-    ).toEqual(
-      hexToU8a('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923')
-    );
+  [false, true].forEach((onlyJs): void => {
+    it(`returns a 512-bit value (as specified, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        blake2AsU8a('abc', 512, undefined, onlyJs)
+      ).toEqual(
+        hexToU8a('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923')
+      );
+    });
   });
 
   it('has equivalent Wasm/Js outputs on hex inputs', (): void => {

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

@@ -19,7 +19,7 @@ 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, onlyJs = false): Uint8Array {
+export function blake2AsU8a (data: Uint8Array | string, bitLength = 256, key: Uint8Array | null = null, onlyJs = false): Uint8Array {
   const byteLength = Math.ceil(bitLength / 8);
 
   return isReady() && !onlyJs

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

@@ -5,5 +5,5 @@
  * @summary Create blake2b values with specified bitlengths
  */
 
-export { default as blake2AsHex } from './asHex';
-export { default as blake2AsU8a } from './asU8a';
+export { blake2AsHex } from './asHex';
+export { blake2AsU8a } from './asU8a';

packages/util-crypto/src/crypto.ts

@@ -1,15 +1,14 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import wasmCrypto from '@polkadot/wasm-crypto';
+import { isReady, waitReady } from '@polkadot/wasm-crypto';
 
 export function cryptoIsReady (): boolean {
-  return wasmCrypto.isReady();
+  return isReady();
 }
 
 export function cryptoWaitReady (): Promise<boolean> {
-  return wasmCrypto
-    .waitReady()
+  return waitReady()
     .then((): boolean => true)
     .catch((error): boolean => {
       console.error('Unable to initialize @polkadot/util-crypto', error);

packages/util-crypto/src/cryptoInit.ts

@@ -0,0 +1,9 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { cryptoWaitReady } from './crypto';
+
+// start init process immediately
+cryptoWaitReady().catch((): void => {
+  // shouldn't happen, logged above
+});

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

@@ -14,7 +14,7 @@ function getH160 (u8a: Uint8Array): Uint8Array {
   return u8a.slice(-20);
 }
 
-export default function ethereumEncode (addressOrPublic?: string | Uint8Array): string {
+export function ethereumEncode (addressOrPublic?: string | Uint8Array): string {
   if (!addressOrPublic) {
     return '0x';
   }

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

@@ -1,6 +1,6 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-export { default as ethereumEncode } from './encode';
-export { default as isEthereumAddress } from './isAddress';
-export { default as isEthereumChecksum } from './isChecksum';
+export { ethereumEncode } from './encode';
+export { isEthereumAddress } from './isAddress';
+export { isEthereumChecksum } from './isChecksum';

packages/util-crypto/src/ethereum/isAddress.ts

@@ -3,9 +3,9 @@
 
 import { isHex } from '@polkadot/util';
 
-import isEthereumChecksum from './isChecksum';
+import { isEthereumChecksum } from './isChecksum';
 
-export default function isEthereumAddress (address?: string): boolean {
+export function isEthereumAddress (address?: string): boolean {
   if (!address || address.length !== 42 || !isHex(address)) {
     return false;
   }

packages/util-crypto/src/ethereum/isChecksum.ts

@@ -9,7 +9,7 @@ function isInvalidChar (char: string, byte: number): boolean {
   return (byte > 7 && char !== char.toUpperCase()) || (byte <= 7 && char !== char.toLowerCase());
 }
 
-export default function isEthereumChecksum (_address: string): boolean {
+export function isEthereumChecksum (_address: string): boolean {
   const address = _address.replace('0x', '');
   const hash = u8aToHex(keccakAsU8a(address.toLowerCase()), -1, false);
 

packages/util-crypto/src/index.ts

@@ -1,8 +1,9 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-// out of order and early in the chain, this also kicks off initialization on require
-export * from './init';
+import './cryptoInit';
+
+export * from './crypto';
 
 // all internal exports
 export * from './address';

packages/util-crypto/src/keccak/asHex.ts

@@ -3,7 +3,7 @@
 
 import { u8aToHex } from '@polkadot/util';
 
-import keccakAsU8a from './asU8a';
+import { keccakAsU8a } from './asU8a';
 
 /**
  * @name keccakAsHex
@@ -19,7 +19,7 @@ import keccakAsU8a from './asU8a';
  * keccakAsHex('123'); // => 0x...
  * ```
  */
-export default function keccakAsHex (value: Buffer | Uint8Array | string): string {
+export function keccakAsHex (value: Buffer | Uint8Array | string): string {
   return u8aToHex(
     keccakAsU8a(value)
   );

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

@@ -16,25 +16,27 @@ describe('keccakAsU8a', (): void => {
     '0x2d07364b5c231c56ce63d49430e085ea3033c750688ba532b24029124c26ca5e'
   );
 
-  it('returns an hex representation (string)', (): void => {
-    expect(
-      keccakAsU8a(input)
-    ).toEqual(output);
+  [false, true].forEach((onlyJs): void => {
+    it(`returns an hex representation (string, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        keccakAsU8a(input, onlyJs)
+      ).toEqual(output);
+    });
   });
 
-  it('returns an hex representation (Buffer)', (): void => {
-    expect(
-      keccakAsU8a(
-        Buffer.from(input)
-      )
-    ).toEqual(output);
+  [false, true].forEach((onlyJs): void => {
+    it(`returns an hex representation (Buffer, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        keccakAsU8a(Buffer.from(input), onlyJs)
+      ).toEqual(output);
+    });
   });
 
-  it('returns an hex representation (Uint8Array)', (): void => {
-    expect(
-      keccakAsU8a(
-        stringToU8a(input)
-      )
-    ).toEqual(output);
+  [false, true].forEach((onlyJs): void => {
+    it(`returns an hex representation (Uint8Array, onlyJs=${onlyJs.toString()})`, (): void => {
+      expect(
+        keccakAsU8a(stringToU8a(input), onlyJs)
+      ).toEqual(output);
+    });
   });
 });

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import jssha3 from 'js-sha3';
+import { keccak256 as keccak256Js } from 'js-sha3';
 import { u8aToU8a } from '@polkadot/util';
 import { isReady, keccak256 } from '@polkadot/wasm-crypto';
 
@@ -19,10 +19,10 @@ import { isReady, keccak256 } from '@polkadot/wasm-crypto';
  * keccakAsU8a('123'); // => Uint8Array
  * ```
  */
-export default function keccakAsU8a (value: Buffer | Uint8Array | string): Uint8Array {
-  return isReady()
+export function keccakAsU8a (value: Buffer | Uint8Array | string, onlyJs = false): Uint8Array {
+  return isReady() && !onlyJs
     ? keccak256(u8aToU8a(value))
     : new Uint8Array(
-      jssha3.keccak256.update(u8aToU8a(value)).arrayBuffer()
+      keccak256Js.update(u8aToU8a(value)).arrayBuffer()
     );
 }

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

@@ -5,5 +5,5 @@
  * @summary Create Keccak256 values as hex & Uint8Array output
  */
 
-export { default as keccakAsHex } from './asHex';
-export { default as keccakAsU8a } from './asU8a';
+export { keccakAsHex } from './asHex';
+export { keccakAsU8a } from './asU8a';

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

@@ -5,7 +5,7 @@ import type BN from 'bn.js';
 
 import { bnToHex, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
 
-import blake2AsU8a from '../blake2/asU8a';
+import { blake2AsU8a } from '../blake2/asU8a';
 
 const RE_NUMBER = /^\d+$/;
 
@@ -15,7 +15,7 @@ const BN_OPTIONS = {
   isLe: true
 };
 
-export default class DeriveJunction {
+export class DeriveJunction {
   readonly #chainCode: Uint8Array = new Uint8Array(32);
 
   #isHard = false;

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import keyExtractPath, { ExtractResult } from './extractPath';
+import { keyExtractPath, ExtractResult } from './extractPath';
 
 describe('keyExtractPath', (): void => {
   it('extracts properly from soft', (): void => {

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

@@ -1,9 +1,10 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import DeriveJunction from './DeriveJunction';
 import { assert } from '@polkadot/util';
 
+import { DeriveJunction } from './DeriveJunction';
+
 const RE_JUNCTION = /\/(\/?)([^/]+)/g;
 
 export interface ExtractResult {
@@ -14,7 +15,7 @@ export interface ExtractResult {
 /**
  * @description Extract derivation junctions from the supplied path
  */
-export default function keyExtractPath (derivePath: string): ExtractResult {
+export function keyExtractPath (derivePath: string): ExtractResult {
   const parts = derivePath.match(RE_JUNCTION);
   const path: DeriveJunction[] = [];
   let constructed = '';

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

@@ -1,7 +1,7 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import keyExtractSuri, { ExtractResult } from './extractSuri';
+import { keyExtractSuri, ExtractResult } from './extractSuri';
 
 describe('keyExtractSuri', (): void => {
   it('does not extract from invalid suri', (): void => {

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

@@ -3,8 +3,8 @@
 
 import { assert, isNull } from '@polkadot/util';
 
-import DeriveJunction from './DeriveJunction';
-import keyExtractPath from './extractPath';
+import { DeriveJunction } from './DeriveJunction';
+import { keyExtractPath } from './extractPath';
 
 export interface ExtractResult {
   password?: string;
@@ -17,7 +17,7 @@ const RE_CAPTURE = /^(\w+( \w+)*)((\/\/?[^/]+)*)(\/\/\/(.*))?$/;
 /**
  * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
  */
-export default function keyExtract (suri: string): ExtractResult {
+export function keyExtractSuri (suri: string): ExtractResult {
   // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
   const matches = suri.match(RE_CAPTURE);
 

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

@@ -3,20 +3,20 @@
 
 import { KeypairType, Keypair } from '../types';
 
-import DeriveJunction from './DeriveJunction';
-import keyHdkdEd15519 from './hdkdEd25519';
-import keyHdkdSr15519 from './hdkdSr25519';
-import keyHdkdEcdsa from './hdkdEcdsa';
+import { DeriveJunction } from './DeriveJunction';
+import { keyHdkdEd25519 } from './hdkdEd25519';
+import { keyHdkdSr25519 } from './hdkdSr25519';
+import { keyHdkdEcdsa } from './hdkdEcdsa';
 
 const generators = {
   ecdsa: keyHdkdEcdsa,
-  ed25519: keyHdkdEd15519,
+  ed25519: keyHdkdEd25519,
   // FIXME This is Substrate-compatible, not Ethereum-compatible
   ethereum: keyHdkdEcdsa,
-  sr25519: keyHdkdSr15519
+  sr25519: keyHdkdSr25519
 };
 
-export default function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
+export function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
   const keyHdkd = generators[type];
 
   return path.reduce((pair, junction): Keypair => {

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

@@ -5,11 +5,11 @@ import { Keypair } from '../types';
 
 import { assert } from '@polkadot/util';
 
-import secp256k1DeriveHard from '../secp256k1/deriveHard';
-import secp256k1KeypairFromSeed from '../secp256k1/keypair/fromSeed';
-import DeriveJunction from './DeriveJunction';
+import { secp256k1DeriveHard } from '../secp256k1/deriveHard';
+import { secp256k1KeypairFromSeed } from '../secp256k1/keypair/fromSeed';
+import { DeriveJunction } from './DeriveJunction';
 
-export default function keyHdkdEcdsa (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair {
+export function keyHdkdEcdsa (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair {
   assert(isHard, 'A soft key was found in the path (and is unsupported)');
 
   return secp256k1KeypairFromSeed(

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

@@ -5,11 +5,11 @@ import { Keypair } from '../types';
 
 import { assert } from '@polkadot/util';
 
-import naclDeriveHard from '../nacl/deriveHard';
-import naclKeypairFromSeed from '../nacl/keypair/fromSeed';
-import DeriveJunction from './DeriveJunction';
+import { naclDeriveHard } from '../nacl/deriveHard';
+import { naclKeypairFromSeed } from '../nacl/keypair/fromSeed';
+import { DeriveJunction } from './DeriveJunction';
 
-export default function keyHdkdEd25519 (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair {
+export function keyHdkdEd25519 (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair {
   assert(isHard, 'A soft key was found in the path (and is unsupported)');
 
   return naclKeypairFromSeed(

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

@@ -3,11 +3,11 @@
 
 import { Keypair } from '../types';
 
-import schnorrkelDeriveHard from '../schnorrkel/deriveHard';
-import schnorrkelDeriveSoft from '../schnorrkel/deriveSoft';
-import DeriveJunction from './DeriveJunction';
+import { schnorrkelDeriveHard } from '../schnorrkel/deriveHard';
+import { schnorrkelDeriveSoft } from '../schnorrkel/deriveSoft';
+import { DeriveJunction } from './DeriveJunction';
 
-export default function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
+export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
   return isSoft
     ? schnorrkelDeriveSoft(keypair, chainCode)
     : schnorrkelDeriveHard(keypair, chainCode);

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

@@ -4,9 +4,9 @@
 /**
  * @summary Create keys from paths, seeds and password
  */
-export { default as keyExtractPath } from './extractPath';
-export { default as keyExtractSuri } from './extractSuri';
-export { default as keyFromPath } from './fromPath';
-export { default as keyHdkdEd25519 } from './hdkdEd25519';
-export { default as keyHdkdSr25519 } from './hdkdEd25519';
-export { default as keyHdkdEcdsa } from './hdkdEcdsa';
+export { keyExtractPath } from './extractPath';
+export { keyExtractSuri } from './extractSuri';
+export { keyFromPath } from './fromPath';
+export { keyHdkdEd25519 } from './hdkdEd25519';
+export { keyHdkdSr25519 } from './hdkdSr25519';
+export { keyHdkdEcdsa } from './hdkdEcdsa';

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

@@ -13,11 +13,11 @@
 //   - Remove setting of wordlost passing of wordlist in functions
 //   - Remove mnemonicToSeed (we only use the sync variant)
 
-import createHash from 'create-hash';
-import { pbkdf2Sync } from 'pbkdf2';
+import { sha256 } from 'hash.js';
 import { assert, u8aToU8a } from '@polkadot/util';
 
-import randomAsU8a from '../random/asU8a';
+import { pbkdf2Encode } from '../pbkdf2';
+import { randomAsU8a } from '../random/asU8a';
 import DEFAULT_WORDLIST from './bip39-en';
 
 const INVALID_MNEMONIC = 'Invalid mnemonic';
@@ -39,9 +39,7 @@ function bytesToBinary (bytes: number[]): string {
 function deriveChecksumBits (entropyBuffer: Uint8Array): string {
   const ENT = entropyBuffer.length * 8;
   const CS = ENT / 32;
-  const hash = createHash('sha256')
-    .update(entropyBuffer)
-    .digest();
+  const hash = sha256().update(entropyBuffer).digest();
 
   return bytesToBinary(Array.from(hash)).slice(0, CS);
 }
@@ -50,11 +48,11 @@ function salt (password?: string): string {
   return 'mnemonic' + (password || '');
 }
 
-export function mnemonicToSeedSync (mnemonic: string, password?: string): Buffer {
+export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8Array {
   const mnemonicBuffer = Buffer.from(normalize(mnemonic), 'utf8');
   const saltBuffer = Buffer.from(salt(normalize(password)), 'utf8');
 
-  return pbkdf2Sync(mnemonicBuffer, saltBuffer, 2048, 64, 'sha512');
+  return pbkdf2Encode(mnemonicBuffer, saltBuffer).password;
 }
 
 export function mnemonicToEntropy (mnemonic: string): Uint8Array {

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

@@ -1,8 +1,8 @@
 // Copyright 2017-2020 @polkadot/util-crypto authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import generate, { WordCount } from './generate';
-import validate from './validate';
+import { mnemonicGenerate, WordCount } from './generate';
+import { mnemonicValidate } from './validate';
 import { cryptoWaitReady } from '..';
 
 describe('mnemonicGenerate', (): void => {
@@ -12,15 +12,15 @@ describe('mnemonicGenerate', (): void => {
 
   it('generates a valid mnemonic (default strength)', (): void => {
     expect(
-      validate(generate())
+      mnemonicValidate(mnemonicGenerate())
     ).toEqual(true);
   });
 
   [false, true].forEach((onlyJs): void => {
     ([12, 15, 18, 21, 24] as WordCount[]).forEach((num: WordCount): void => {
       it(`generates a valid mnemonic (${num} words, onlyJs=${onlyJs.toString()})`, (): void => {
-        const mnemonic = generate(num, onlyJs);
-        const isValid = validate(mnemonic);
+        const mnemonic = mnemonicGenerate(num, onlyJs);
+        const isValid = mnemonicValidate(mnemonic);
 
         expect(mnemonic.split(' ')).toHaveLength(num);
         expect(isValid).toEqual(true);
@@ -30,14 +30,12 @@ describe('mnemonicGenerate', (): void => {
 
   [true, false].forEach((onlyJs): void => {
     it(`generates not deterministic (onlyJs=${onlyJs.toString()})`, (): void => {
-      [false, true].forEach((onlyJs): void => {
-        const m1 = generate(24, onlyJs);
-        const m2 = generate(24, onlyJs);
+      const m1 = mnemonicGenerate(24, onlyJs);
+      const m2 = mnemonicGenerate(24, onlyJs);
 
-        expect(m1 === m2).toEqual(false);
-        expect(validate(m1)).toEqual(true);
-        expect(validate(m2)).toEqual(true);
-      });
+      expect(m1 === m2).toEqual(false);
+      expect(mnemonicValidate(m1)).toEqual(true);
+      expect(mnemonicValidate(m2)).toEqual(true);
     });
   });
 });

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

@@ -28,7 +28,7 @@ const STRENGTH_MAP = {
  * const mnemonic = mnemonicGenerate(); // => string
  * ```
  */
-export default function mnemonicGenerate (numWords: WordCount = 12, onlyJs = false): string {
+export function mnemonicGenerate (numWords: WordCount = 12, onlyJs = false): string {
   return isReady() && !onlyJs
     ? bip39Generate(numWords)
     : generateMnemonic(STRENGTH_MAP[numWords]);

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

@@ -4,8 +4,8 @@
 /**
  * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
  */
-export { default as mnemonicGenerate } from './generate';
-export { default as mnemonicToEntropy } from './toEntropy';
-export { default as mnemonicToLegacySeed } from './toLegacySeed';
-export { default as mnemonicToMiniSecret } from './toMiniSecret';
-export { default as mnemonicValidate } from './validate';
+export { mnemonicGenerate } from './generate';
+export { mnemonicToEntropy } from './toEntropy';
+export { mnemonicToLegacySeed } from './toLegacySeed';
+export { mnemonicToMiniSecret } from './toMiniSecret';
+export { mnemonicValidate } from './validate';

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

@@ -3,7 +3,7 @@
 
 import { u8aToHex } from '@polkadot/util';
 
-import toEntropy from './toEntropy';
+import { mnemonicToEntropy } from './toEntropy';
 import tests from '../schnorrkel/keypair/testing';
 import { cryptoWaitReady } from '..';
 
@@ -13,9 +13,10 @@ describe('mnemonicToEntropy', (): void => {
   });
 
   tests.forEach(([mnemonic, entropy], index): void => {
-    it(`Created correct entropy for ${index}`, (): void => {
-      expect(u8aToHex(toEntropy(mnemonic))).toEqual(entropy);
-      expect(u8aToHex(toEntropy(mnemonic, true))).toEqual(entropy);
+    [false, true].forEach((onlyJs): void => {
+      it(`Created correct entropy for ${index} (onlyJs = ${onlyJs.toString()})`, (): void => {
+        expect(u8aToHex(mnemonicToEntropy(mnemonic, onlyJs))).toEqual(entropy);
+      });
     });
   });
 });

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

@@ -3,10 +3,10 @@
 
 import { bip39ToEntropy, isReady } from '@polkadot/wasm-crypto';
 
-import { mnemonicToEntropy } from './bip39';
+import { mnemonicToEntropy as jsToEntropy } from './bip39';
 
-export default function toEntropy (mnemonic: string, onlyJs = false): Uint8Array {
+export function mnemonicToEntropy (mnemonic: string, onlyJs = false): Uint8Array {
   return isReady() && !onlyJs
     ? bip39ToEntropy(mnemonic)
-    : mnemonicToEntropy(mnemonic);
+    : jsToEntropy(mnemonic);
 }