[CI Skip] 2.11.1

skip-checks: true

.eslintignore

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

CHANGELOG.md

@@ -1,3 +1,22 @@
+# 2.11.1 May 26, 2020
+
+- Internal cleanups on typings
+- Support for latest TypeScript, eslint & typescript-eslint
+
+# 2.10.1 May 14, 2020
+
+- Add Kulupu ss58 prefix as an allowed value (Thanks to https://github.com/sorpaas)
+- Make the `TextEncoder` polyfill handle non-compliant Buffer implementations (newer versions of Jest)
+- `DeriveJunction` now also allows for BigInt values (aligning with number types elsewhere)
+- Small code-flow optimizations
+
+# 2.9.1 Apr 30, 2020
+
+- Add support for ECDSA keypairs (Thanks to https://github.com/akru)
+- Added `createKeyMulti` & `createKeySub` to create utility sub & multi keys
+- Added `u8aSorted` to sort `Uint8Arrays`
+- Added `sortAddresses` to sort addresses based on their internal representation
+
 # 2.8.1 Apr 9, 2020
 
 - Keypair will now throw an error when attempting to sign/derive using a locked pair (Thanks to https://github.com/h4x3rotab)

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

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

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

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

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

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

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "2.8.1"
+  "version": "2.11.1"
 }

package.json

@@ -7,7 +7,7 @@
     "packages/*"
   ],
   "resolutions": {
-    "typescript": "^3.8.3"
+    "babel-core": "^7.0.0-bridge.0"
   },
   "scripts": {
     "build": "polkadot-dev-build-ts",
@@ -21,9 +21,9 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.9.0",
-    "@polkadot/dev": "^0.52.8",
-    "@polkadot/ts": "^0.3.18",
-    "@types/jest": "^25.2.1"
+    "@babel/core": "^7.9.6",
+    "@polkadot/dev": "^0.54.1",
+    "@polkadot/ts": "^0.3.23",
+    "@types/jest": "^25.2.3"
   }
 }

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "2.8.1",
+  "version": "2.11.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.2",
-    "@polkadot/util": "2.8.1",
-    "@polkadot/util-crypto": "2.8.1"
+    "@babel/runtime": "^7.9.6",
+    "@polkadot/util": "2.11.1",
+    "@polkadot/util-crypto": "2.11.1"
   }
 }

packages/keyring/src/index.spec.ts

@@ -147,4 +147,69 @@ describe('keypair', (): void => {
       expect(pair.verify(MESSAGE, signature)).toBe(true);
     });
   });
+
+  describe('ecdsa', (): void => {
+    const seedOne = 'potato act energy ahead stone taxi receive fame gossip equip chest round';
+    const seedTwo = hexToU8a('0x3c74be003bd9a876be439949ccf2b292bd966c94959a689173b295b326cd6da7');
+    const publicKeyOne = hexToU8a('0x02c6b6c664db5ef505477bba1cf2f1789c98796b9bb5fa21abd0ac4589bed980e7');
+    const publicKeyTwo = hexToU8a('0x021da683b913fb28c979ba3e5f1881415cef4b1f58a5d05ed3610a2995e7b4943c');
+    const addressKeyOne = hexToU8a('0x0cfd0dd2c59a9987b9848919163931b6a42283ffd3d91e92c98b522525a7038f');
+    let keyring: Keyring;
+
+    beforeEach((): void => {
+      keyring = new Keyring({ ss58Format: 42, type: 'ecdsa' });
+
+      keyring.addFromMnemonic(seedOne, {});
+    });
+
+    it('creates with dev phrase when only path specified', (): void => {
+      expect(
+        keyring.createFromUri('//Alice').address
+      ).toEqual('5C7C2Z5sWbytvHpuLTvzKunnnRwQxft1jiqrLD5rhucQ5S9X');
+    });
+
+    it('adds the pair', (): void => {
+      expect(
+        keyring.addFromSeed(seedTwo, {}).publicKey
+      ).toEqual(publicKeyTwo);
+    });
+
+    it('adds from a mnemonic', (): void => {
+      keyring.setSS58Format(68);
+
+      expect(
+        keyring.addFromMnemonic('moral movie very draw assault whisper awful rebuild speed purity repeat card').address
+      ).toEqual('7ooxHV3mz4nnWbK8v7Mxcb71QMpof268eL1A2VrYWUNWJk8P');
+    });
+
+    it('allows publicKeys retrieval', (): void => {
+      keyring.addFromSeed(seedTwo, {});
+
+      expect(
+        keyring.getPublicKeys()
+      ).toEqual([publicKeyOne, publicKeyTwo]);
+    });
+
+    it('allows retrieval of a specific item', (): void => {
+      expect(
+        keyring.getPair(addressKeyOne).publicKey
+      ).toEqual(publicKeyOne);
+    });
+
+    it('allows adding from JSON', (): void => {
+      expect(
+        keyring.addFromJson(
+          JSON.parse('{"address":"5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz","encoded":"0xa192d39b42bc1601bf61df31039a554228593fadf870bc837b658a5114627aca199fff596260c95fe8994c66a47636cf0270aa08f402ba5541038753960d00e6c3af5e239ec58fb1eef3db7d6bc266f4853bdfe4ed17122d9092d879014d53980d2ee57f6f55a88c38836447d8645008e8815379626addc8f81f80cd49a2","encoding":{"content":"pkcs8","type":"xsalsa20-poly1305","version":"2"},"meta":{}}')
+        ).address
+      ).toEqual('5DzMsaYFhmpRdErWrP6K6PD7UXzYoeETToSBUrZSvxasqWRz');
+    });
+
+    it('signs and verifies', (): void => {
+      const MESSAGE = stringToU8a('this is a message');
+      const pair = keyring.getPair(addressKeyOne);
+      const signature = pair.sign(MESSAGE);
+
+      expect(pair.verify(MESSAGE, signature)).toBe(true);
+    });
+  });
 });

packages/keyring/src/keyring.ts

@@ -2,11 +2,11 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import { KeypairType } from '@polkadot/util-crypto/types';
+import { KeypairType, Keypair } from '@polkadot/util-crypto/types';
 import { KeyringInstance, KeyringPair, KeyringPair$Json, KeyringPair$Meta, KeyringOptions } from './types';
 
 import { assert, hexToU8a, isHex, stringToU8a } from '@polkadot/util';
-import { decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
+import { decodeAddress, encodeAddress, keyExtractSuri, keyFromPath, naclKeypairFromSeed as naclFromSeed, schnorrkelKeypairFromSeed as schnorrkelFromSeed, secp256k1KeypairFromSeed as secp256k1FromSeed, mnemonicToMiniSecret } from '@polkadot/util-crypto';
 
 import { DEV_PHRASE } from './defaults';
 import createPair from './pair';
@@ -40,7 +40,7 @@ export default class Keyring implements KeyringInstance {
   constructor (options: KeyringOptions = {}) {
     options.type = options.type || 'ed25519';
 
-    assert(options && ['ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519' or 'sr25519', found '${options.type}`);
+    assert(options && ['ecdsa', 'ed25519', 'sr25519'].includes(options.type || 'undefined'), `Expected a keyring type of either 'ed25519', 'sr25519' or 'ecdsa', found '${options.type}`);
 
     this.#pairs = new Pairs();
     this.#ss58 = options.ss58Format;
@@ -62,7 +62,7 @@ export default class Keyring implements KeyringInstance {
   }
 
   /**
-   * @description Returns the type of the keyring, either ed25519 of sr25519
+   * @description Returns the type of the keyring, ed25519, sr25519 or ecdsa
    */
   public get type (): KeypairType {
     return this.#type;
@@ -87,7 +87,7 @@ export default class Keyring implements KeyringInstance {
   public addFromAddress (address: string | Uint8Array, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null, type: KeypairType = this.type, ignoreChecksum?: boolean): KeyringPair {
     const publicKey = this.decodeAddress(address, ignoreChecksum);
 
-    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array(64) }, meta, encoded));
+    return this.addPair(createPair({ toSS58: this.encodeAddress, type }, { publicKey, secretKey: new Uint8Array() }, meta, encoded));
   }
 
   /**
@@ -125,9 +125,11 @@ export default class Keyring implements KeyringInstance {
    * `addPair` to store in a keyring pair dictionary the public key of the generated pair as a key and the pair as the associated value.
    */
   public addFromSeed (seed: Uint8Array, meta: KeyringPair$Meta = {}, type: KeypairType = this.type): KeyringPair {
-    const keypair = type === 'sr25519'
-      ? schnorrkelFromSeed(seed)
-      : naclFromSeed(seed);
+    const keypair = {
+      ecdsa: (): Keypair => secp256k1FromSeed(seed),
+      ed25519: (): Keypair => naclFromSeed(seed),
+      sr25519: (): Keypair => schnorrkelFromSeed(seed)
+    }[type]();
 
     return this.addPair(createPair({ toSS58: this.encodeAddress, type }, keypair, meta, null));
   }
@@ -154,7 +156,7 @@ export default class Keyring implements KeyringInstance {
       ? `${DEV_PHRASE}${_suri}`
       : _suri;
     const { password, path, phrase } = keyExtractSuri(suri);
-    let seed;
+    let seed: Uint8Array;
 
     if (isHex(phrase, 256)) {
       seed = hexToU8a(phrase);
@@ -175,10 +177,12 @@ export default class Keyring implements KeyringInstance {
       }
     }
 
-    const keypair = type === 'sr25519'
-      ? schnorrkelFromSeed(seed)
-      : naclFromSeed(seed);
-    const derived = keyFromPath(keypair, path, type);
+    const keypair = {
+      ecdsa: (): Keypair => secp256k1FromSeed(seed),
+      ed25519: (): Keypair => naclFromSeed(seed),
+      sr25519: (): Keypair => schnorrkelFromSeed(seed)
+    };
+    const derived = keyFromPath(keypair[type](), path, type);
 
     return createPair({ toSS58: this.encodeAddress, type }, derived, meta, null);
   }
@@ -187,8 +191,8 @@ export default class Keyring implements KeyringInstance {
    * @name encodeAddress
    * @description Encodes the input into an ss58 representation
    */
-  public encodeAddress = (key: Uint8Array | string, ss58Format?: number): string => {
-    return encodeAddress(key, ss58Format || this.#ss58);
+  public encodeAddress = (address: Uint8Array | string, ss58Format?: number): string => {
+    return encodeAddress(address, ss58Format || this.#ss58);
   }
 
   /**

packages/keyring/src/pair/index.ts

@@ -7,7 +7,7 @@ import { KeyringPair, KeyringPair$Json, KeyringPair$Meta, SignOptions } from '..
 import { PairInfo } from './types';
 
 import { assert, u8aConcat } from '@polkadot/util';
-import { keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, naclVerify, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVerify } from '@polkadot/util-crypto';
+import { keyExtractPath, keyFromPath, naclKeypairFromSeed as naclFromSeed, naclSign, naclVerify, schnorrkelKeypairFromSeed as schnorrkelFromSeed, schnorrkelSign, schnorrkelVerify, secp256k1KeypairFromSeed as secp256k1FromSeed, secp256k1Sign, secp256k1Verify, blake2AsU8a } from '@polkadot/util-crypto';
 
 import decode from './decode';
 import encode from './encode';
@@ -21,45 +21,59 @@ 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 SIG_TYPE_ECDSA = new Uint8Array([2]);
 
 function isEmpty (u8a: Uint8Array): boolean {
   return u8a.reduce((count, u8): number => count + u8, 0) === 0;
 }
 
-function isSr25519 (type: KeypairType): boolean {
-  return type === 'sr25519';
-}
-
 function fromSeed (type: KeypairType, seed: Uint8Array): Keypair {
-  return isSr25519(type)
-    ? schnorrkelFromSeed(seed)
-    : naclFromSeed(seed);
+  return {
+    ecdsa: (): Keypair => secp256k1FromSeed(seed),
+    ed25519: (): Keypair => naclFromSeed(seed),
+    sr25519: (): Keypair => schnorrkelFromSeed(seed)
+  }[type]();
 }
 
 function multiSignaturePrefix (type: KeypairType): Uint8Array {
-  return isSr25519(type)
-    ? SIG_TYPE_SR25519
-    : SIG_TYPE_ED25519;
+  return {
+    ecdsa: SIG_TYPE_ECDSA,
+    ed25519: SIG_TYPE_ED25519,
+    sr25519: SIG_TYPE_SR25519
+  }[type];
 }
 
 function sign (type: KeypairType, message: Uint8Array, pair: Partial<Keypair>, { withType = false }: SignOptions = {}): Uint8Array {
+  const signature = {
+    ecdsa: (): Uint8Array => secp256k1Sign(message, pair),
+    ed25519: (): Uint8Array => naclSign(message, pair),
+    sr25519: (): Uint8Array => schnorrkelSign(message, pair)
+  }[type]();
+
   return u8aConcat(
     // for multi-signatures, i.e. with indicator, append the signature type as per
     // the MultiSignature enum
     withType
       ? multiSignaturePrefix(type)
       : SIG_TYPE_NONE,
-    isSr25519(type)
-      ? schnorrkelSign(message, pair)
-      : naclSign(message, pair)
+    signature
   );
 }
 
 function verify (type: KeypairType, message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean {
-  return isSr25519(type)
-    ? schnorrkelVerify(message, signature, publicKey)
-    : naclVerify(message, signature, publicKey);
+  return {
+    ecdsa: (): boolean => secp256k1Verify(message, signature, blake2AsU8a(publicKey, 256)),
+    ed25519: (): boolean => naclVerify(message, signature, publicKey),
+    sr25519: (): boolean => schnorrkelVerify(message, signature, publicKey)
+  }[type]();
+}
+
+function getAddress (type: KeypairType, publicKey: Uint8Array): Uint8Array {
+  if (type === 'ecdsa' && publicKey.length > 32) {
+    return blake2AsU8a(publicKey, 256);
+  } else {
+    return publicKey;
+  }
 }
 
 // Not 100% correct, since it can be a Uint8Array, but an invalid one - just say "undefined" is anything non-valid
@@ -101,7 +115,7 @@ function isLocked (secretKey?: Uint8Array): secretKey is undefined {
 export default function createPair ({ toSS58, type }: Setup, { publicKey, secretKey }: PairInfo, meta: KeyringPair$Meta = {}, encoded: Uint8Array | null = null): KeyringPair {
   return {
     get address (): string {
-      return toSS58(publicKey);
+      return toSS58(getAddress(type, publicKey));
     },
     get isLocked (): boolean {
       return isLocked(secretKey);
@@ -151,7 +165,7 @@ export default function createPair ({ toSS58, type }: Setup, { publicKey, secret
       return sign(type, message, { publicKey, secretKey }, options);
     },
     toJson: (passphrase?: string): KeyringPair$Json =>
-      toJson(type, { meta, publicKey }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
+      toJson(type, { address: toSS58(getAddress(type, publicKey)), meta }, encode({ publicKey, secretKey }, passphrase), !!passphrase),
     verify: (message: Uint8Array, signature: Uint8Array): boolean =>
       verify(type, message, signature, publicKey)
   };

packages/keyring/src/pair/toJson.ts

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

packages/keyring/src/pairs.ts

@@ -13,7 +13,7 @@ export default class Pairs implements KeyringPairs {
   readonly #map: KeyringPairMap = {};
 
   public add (pair: KeyringPair): KeyringPair {
-    this.#map[pair.publicKey.toString()] = pair;
+    this.#map[decodeAddress(pair.address).toString()] = pair;
 
     return pair;
   }

packages/keyring/src/types.ts

@@ -10,10 +10,7 @@ export interface KeyringOptions {
   type?: KeypairType;
 }
 
-export interface KeyringPair$Meta {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [index: string]: any;
-}
+export type KeyringPair$Meta = Record<string, unknown>;
 
 export type KeyringPair$JsonVersion = '0' | '1' | '2';
 

packages/util-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "2.8.1",
+  "version": "2.11.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,13 +25,13 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.9.2",
-    "@polkadot/util": "2.8.1",
+    "@babel/runtime": "^7.9.6",
+    "@polkadot/util": "2.11.1",
     "@polkadot/wasm-crypto": "^1.2.1",
     "base-x": "^3.0.8",
     "bip39": "^3.0.2",
     "blakejs": "^1.1.0",
-    "bn.js": "^5.1.1",
+    "bn.js": "^5.1.2",
     "bs58": "^4.0.1",
     "elliptic": "^6.5.2",
     "js-sha3": "^0.8.0",
@@ -44,6 +44,6 @@
     "@types/bs58": "^4.0.1",
     "@types/elliptic": "^6.4.12",
     "@types/pbkdf2": "^3.0.0",
-    "@types/xxhashjs": "^0.2.1"
+    "@types/xxhashjs": "^0.2.2"
   }
 }

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

@@ -20,7 +20,7 @@ export default function decode (encoded: string | Uint8Array, ignoreChecksum?: b
 
   const decoded = bufferToU8a(bs58.decode(encoded));
   const error = (message: string): string =>
-    `Decoding ${encoded}: ${message}`;
+    `Decoding ${encoded as string}: ${message}`;
 
   // assert(defaults.allowedPrefix.includes(decoded[0] as Prefix), error('Invalid decoded address prefix'));
   assert(defaults.allowedEncodedLengths.includes(decoded.length), error('Invalid decoded address length'));

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

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

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

@@ -4,14 +4,20 @@
 
 import checkAddress from './check';
 import checkAddressChecksum from './checkChecksum';
+import createKeyMulti from './keyMulti';
+import createKeySub from './keySub';
 import decodeAddress from './decode';
 import encodeAddress from './encode';
 import setSS58Format from './setSS58Format';
+import sortAddresses from './sort';
 
 export {
   checkAddress,
   checkAddressChecksum,
+  createKeyMulti,
+  createKeySub,
   decodeAddress,
   encodeAddress,
-  setSS58Format
+  setSS58Format,
+  sortAddresses
 };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,8 +2,9 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import BN from 'bn.js';
-import { bnToHex, compactAddLength, hexToU8a, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
+import type BN from 'bn.js';
+
+import { bnToHex, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from '@polkadot/util';
 
 import blake2AsU8a from '../blake2/asU8a';
 
@@ -21,10 +22,10 @@ export default class DeriveJunction {
   #isHard = false;
 
   public static from (value: string): DeriveJunction {
+    const result = new DeriveJunction();
     const [code, isHard] = value.startsWith('/')
       ? [value.substr(1), true]
       : [value, false];
-    const result = new DeriveJunction();
 
     result.soft(
       RE_NUMBER.test(code)
@@ -49,7 +50,7 @@ export default class DeriveJunction {
     return !this.#isHard;
   }
 
-  public hard (value: number | BN | string | Uint8Array): DeriveJunction {
+  public hard (value: number | string | BigInt | BN | Uint8Array): DeriveJunction {
     return this.soft(value).harden();
   }
 
@@ -59,8 +60,8 @@ export default class DeriveJunction {
     return this;
   }
 
-  public soft (value: number | BN | string | Uint8Array): DeriveJunction {
-    if (isNumber(value) || isBn(value)) {
+  public soft (value: number | string | BigInt | BN | Uint8Array): DeriveJunction {
+    if (isNumber(value) || isBn(value) || isBigInt(value)) {
       return this.soft(bnToHex(value, BN_OPTIONS));
     } else if (isString(value)) {
       return isHex(value)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -10,11 +10,14 @@ import { signatureVerify } from '.';
 
 const ADDR_ED = 'DxN4uvzwPzJLtn17yew6jEffPhXQfdKHTp2brufb98vGbPN';
 const ADDR_SR = 'EK1bFgKm2FsghcttHT7TB7rNyXApFgs9fCbijMGQNyFGBQm';
+const ADDR_EC = 'XyFVXiGaHxoBhXZkSh6NS2rjFyVaVNUo5UiZDqZbuSfUdji';
 const MESSAGE = 'hello world';
 const SIG_ED = '0x299d3bf4c8bb51af732f8067b3a3015c0862a5ff34721749d8ed6577ea2708365d1c5f76bd519009971e41156f12c70abc2533837ceb3bad9a05a99ab923de06';
 const SIG_SR = '0xca01419b5a17219f7b78335658cab3b126db523a5df7be4bfc2bef76c2eb3b1dcf4ca86eb877d0a6cf6df12db5995c51d13b00e005d053b892bd09c594434288';
+const SIG_EC = '0x994638ee586d2c5dbd9bacacbc35d9b7e9018de8f7892f00c900db63bc57b1283e2ee7bc51a9b1c1dae121ac4f4b9e2a41cd1d6bf4bb3e24d7fed6faf6d85e0501';
 const MUL_ED = u8aToHex(u8aConcat(new Uint8Array([0]), hexToU8a(SIG_ED)));
 const MUL_SR = u8aToHex(u8aConcat(new Uint8Array([1]), hexToU8a(SIG_SR)));
+const MUL_EC = u8aToHex(u8aConcat(new Uint8Array([2]), hexToU8a(SIG_EC)));
 
 describe('signatureVerify', (): void => {
   beforeEach(async (): Promise<void> => {
@@ -24,7 +27,7 @@ describe('signatureVerify', (): void => {
   it('throws on invalid signature length', (): void => {
     expect(
       () => signatureVerify(MESSAGE, new Uint8Array(32), ADDR_ED)
-    ).toThrow('Invalid signature length, expected 64 or 65 bytes, found 32');
+    ).toThrow('Invalid signature length, expected [64..66] bytes, found 32');
   });
 
   describe('verifyDetect', (): void => {
@@ -35,6 +38,13 @@ describe('signatureVerify', (): void => {
       });
     });
 
+    it('verifies an ecdsa signature', (): void => {
+      expect(signatureVerify(MESSAGE, SIG_EC, ADDR_EC)).toEqual({
+        crypto: 'ecdsa',
+        isValid: true
+      });
+    });
+
     it('verifies an sr25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, SIG_SR, ADDR_SR)).toEqual({
         crypto: 'sr25519',
@@ -58,16 +68,6 @@ describe('signatureVerify', (): void => {
   });
 
   describe('verifyMultisig', (): void => {
-    it('throws with invalid multisig indicator', (): void => {
-      const u8aSig = hexToU8a(MUL_ED);
-
-      u8aSig[0] = 69;
-
-      expect(
-        () => signatureVerify(MESSAGE, u8aSig, ADDR_ED)
-      ).toThrow('Unknown crypto type, expected signature prefix of 0 or 1, found 69');
-    });
-
     it('verifies an ed25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_ED, ADDR_ED)).toEqual({
         crypto: 'ed25519',
@@ -75,6 +75,13 @@ describe('signatureVerify', (): void => {
       });
     });
 
+    it('verifies an ecdsa signature', (): void => {
+      expect(signatureVerify(MESSAGE, MUL_EC, ADDR_EC)).toEqual({
+        crypto: 'ecdsa',
+        isValid: true
+      });
+    });
+
     it('verifies an sr25519 signature', (): void => {
       expect(signatureVerify(MESSAGE, MUL_SR, ADDR_SR)).toEqual({
         crypto: 'sr25519',

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

@@ -9,10 +9,18 @@ import { assert, u8aToU8a } from '@polkadot/util';
 import addressDecode from '../address/decode';
 import naclVerify from '../nacl/verify';
 import schnorrkelVerify from '../schnorrkel/verify';
+import secp256k1Verify from '../secp256k1/verify';
 
 const VERIFIERS: [KeypairType, (message: Uint8Array | string, signature: Uint8Array | string, publicKey: Uint8Array | string) => boolean][] = [
   ['ed25519', naclVerify],
-  ['sr25519', schnorrkelVerify]
+  ['sr25519', schnorrkelVerify],
+  ['ecdsa', secp256k1Verify]
+];
+
+const CRYPTO_TYPES: KeypairType[] = [
+  'ed25519',
+  'sr25519',
+  'ecdsa'
 ];
 
 function verifyDetect (result: VerifyResult, message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array): VerifyResult {
@@ -34,18 +42,17 @@ function verifyDetect (result: VerifyResult, message: Uint8Array | string, signa
 }
 
 function verifyMultisig (result: VerifyResult, message: Uint8Array | string, signature: Uint8Array, publicKey: Uint8Array): VerifyResult {
-  assert([0, 1].includes(signature[0]), `Unknown crypto type, expected signature prefix of 0 or 1, found ${signature[0]}`);
+  assert([0, 1, 2].includes(signature[0]), `Unknown crypto type, expected signature prefix [0..2], found ${signature[0]}`);
 
-  const isEd25519 = signature[0] === 0;
-
-  result.crypto = isEd25519
-    ? 'ed25519'
-    : 'sr25519';
+  result.crypto = CRYPTO_TYPES[signature[0]] || 'none';
 
   try {
-    result.isValid = isEd25519
-      ? naclVerify(message, signature.subarray(1), publicKey)
-      : schnorrkelVerify(message, signature.subarray(1), publicKey);
+    result.isValid = {
+      ecdsa: (): boolean => secp256k1Verify(message, signature.subarray(1), publicKey),
+      ed25519: (): boolean => naclVerify(message, signature.subarray(1), publicKey),
+      none: (): boolean => { throw Error('no verify for `none` crypto type'); },
+      sr25519: (): boolean => schnorrkelVerify(message, signature.subarray(1), publicKey)
+    }[result.crypto]();
   } catch (error) {
     // ignore, result.isValid still set to false
   }
@@ -56,12 +63,16 @@ function verifyMultisig (result: VerifyResult, message: Uint8Array | string, sig
 export default function signatureVerify (message: Uint8Array | string, signature: Uint8Array | string, addressOrPublicKey: Uint8Array | string): VerifyResult {
   const signatureU8a = u8aToU8a(signature);
 
-  assert([64, 65].includes(signatureU8a.length), `Invalid signature length, expected 64 or 65 bytes, found ${signatureU8a.length}`);
+  assert([64, 65, 66].includes(signatureU8a.length), `Invalid signature length, expected [64..66] bytes, found ${signatureU8a.length}`);
 
   const result: VerifyResult = { crypto: 'none', isValid: false };
   const publicKey = addressDecode(addressOrPublicKey);
 
-  return signatureU8a.length === 65
-    ? verifyMultisig(result, message, signatureU8a, publicKey)
-    : verifyDetect(result, message, signatureU8a, publicKey);
+  const multisig = [0, 1, 2].includes(signatureU8a[0]) && [65, 66].includes(signatureU8a.length);
+
+  if (multisig) {
+    return verifyMultisig(result, message, signatureU8a, publicKey);
+  } else {
+    return verifyDetect(result, message, signatureU8a, publicKey);
+  }
 }

packages/util-crypto/src/types.ts

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

packages/util/package.json

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

packages/util/src/array/filter.ts

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

packages/util/src/assert.ts

@@ -22,7 +22,7 @@ type MessageFn = () => string;
  * assert(false, () => 'message'); // Error with 'message'
  * ```
  */
-export default function assert (condition: boolean | object | string | number | undefined | null, message: string | MessageFn): asserts condition {
+export default function assert (condition: unknown, message: string | MessageFn): asserts condition {
   if (!condition) {
     throw new Error(
       isFunction(message)

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

@@ -21,7 +21,7 @@ describe('bnToBn', (): void => {
 
   it('converts BigInt values to BN', (): void => {
     expect(
-      bnToBn(128_821n).toNumber()
+      bnToBn(128821n).toNumber()
     ).toEqual(128821);
   });
 

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

@@ -10,7 +10,7 @@ describe('bnToU8a', (): void => {
   it('converts null values to 0x00', (): void => {
     expect(
       bnToU8a(null, -1, false)
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('converts null values to 0x00000000 (bitLength)', (): void => {

packages/util/src/bn/toU8a.ts

@@ -43,7 +43,7 @@ function bnToU8a (value: BN | BigInt | number | null, arg1: number | Options = {
 
   if (!value) {
     return _options.bitLength === -1
-      ? new Uint8Array([])
+      ? new Uint8Array()
       : new Uint8Array(byteLength);
   }
 

packages/util/src/buffer/toU8a.spec.ts

@@ -8,7 +8,7 @@ describe('bufferToU8a', (): void => {
   it('returns an empty buffer when null provided', (): void => {
     expect(
       bufferToU8a(null)
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('returns a Uint8Buffer with the correct values', (): void => {

packages/util/src/buffer/toU8a.ts

@@ -17,9 +17,5 @@
  * ```
  */
 export default function bufferToU8a (buffer?: Buffer | number[] | null): Uint8Array {
-  if (!buffer) {
-    return new Uint8Array([]);
-  }
-
-  return new Uint8Array(buffer);
+  return new Uint8Array(buffer || []);
 }

packages/util/src/format/formatBalance.spec.ts

@@ -23,7 +23,7 @@ describe('formatBalance', (): void => {
 
     it('formats BigInt numbers', (): void => {
       expect(
-        formatBalance(123_456_789_000n, { decimals: 15, withSi: true })
+        formatBalance(123456789000n, { decimals: 15, withSi: true })
       ).toEqual('123.456µ Unit');
     });
 

packages/util/src/format/formatNumber.spec.ts

@@ -27,7 +27,7 @@ describe('formatNumber', (): void => {
 
   it('formats BigInt numbers', (): void => {
     expect(
-      formatNumber(123_456_789n)
+      formatNumber(123456789n)
     ).toEqual('123,456,789');
   });
 

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

@@ -53,6 +53,12 @@ describe('hexToBn', (): void => {
     ).toBe(-1234);
   });
 
+  it('handles negative numbers (LE, 128)', (): void => {
+    expect(
+      hexToBn('0x00009c584c491ff2ffffffffffffffff', { isLe: true, isNegative: true }).toString()
+    ).toEqual('-1000000000000000000');
+  });
+
   it('handles starting zeros correctly (BE)', (): void => {
     expect(
       hexToBn('0x0000000000000100', { isLe: false }).toNumber()

packages/util/src/hex/toU8a.ts

@@ -23,7 +23,7 @@ import hexStripPrefix from './stripPrefix';
  */
 export default function hexToU8a (_value?: string | null, bitLength = -1): Uint8Array {
   if (!_value) {
-    return new Uint8Array([]);
+    return new Uint8Array();
   }
 
   assert(isHex(_value), `Expected hex value to convert, found '${_value}'`);

packages/util/src/is/bigInt.spec.ts

@@ -7,13 +7,13 @@ import { isBigInt } from '.';
 describe('isBigInt', (): void => {
   it('returns true when a BigInt value', (): void => {
     expect(
-      isBigInt(123_456n)
+      isBigInt(123456n)
     ).toEqual(true);
   });
 
   it('returns true when a BigInt value', (): void => {
     expect(
-      isBigInt(BigInt(123_456))
+      isBigInt(BigInt(123456))
     ).toEqual(true);
   });
 

packages/util/src/is/bigInt.ts

@@ -16,6 +16,6 @@
  * console.log('isBigInt', isBigInt(123_456n)); // => true
  * ```
  */
-export default function isBigInt (value: BigInt | object | string | number | undefined | null): value is BigInt {
+export default function isBigInt (value: unknown): value is BigInt {
   return typeof value === 'bigint';
 }

packages/util/src/is/bn.ts

@@ -19,6 +19,6 @@ import BN from 'bn.js';
  * console.log('isBn', isBn(new BN(1))); // => true
  * ```
  */
-export default function isBn (value: object | string | number | undefined | null): value is BN {
+export default function isBn (value: unknown): value is BN {
   return BN.isBN(value);
 }

packages/util/src/is/boolean.ts

@@ -16,7 +16,6 @@
  * isBoolean(false); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isBoolean (value: any): value is boolean {
+export default function isBoolean (value: unknown): value is boolean {
   return typeof value === 'boolean';
 }

packages/util/src/is/buffer.ts

@@ -18,7 +18,6 @@ import isInstanceOf from './instanceOf';
  * console.log('isBuffer', isBuffer(Buffer.from([]))); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isBuffer (value: any): value is Buffer {
+export default function isBuffer (value: unknown): value is Buffer {
   return isInstanceOf(value, Buffer);
 }

packages/util/src/is/error.ts

@@ -18,7 +18,6 @@ import isInstanceOf from './instanceOf';
  * console.log('isError', isError(new Error('message'))); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isError (value: any): value is Error {
+export default function isError (value: unknown): value is Error {
   return isInstanceOf(value, Error);
 }

packages/util/src/is/function.ts

@@ -16,7 +16,7 @@
  * isFunction(() => false); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isFunction (value: any): value is Function {
+// eslint-disable-next-line @typescript-eslint/ban-types
+export default function isFunction (value: unknown): value is Function {
   return typeof value === 'function';
 }

packages/util/src/is/hex.ts

@@ -21,13 +21,13 @@ const HEX_REGEX = /^0x[a-fA-F0-9]+$/;
  * isHex('0x1234', 8); // => false
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types
-export default function isHex (value: any, bitLength = -1, ignoreLength = false): value is string | String {
+// eslint-disable-next-line @typescript-eslint/ban-types
+export default function isHex (value: unknown, bitLength = -1, ignoreLength = false): value is string | String {
   const isValidHex = value === '0x' || (isString(value) && HEX_REGEX.test(value.toString()));
 
   if (isValidHex && bitLength !== -1) {
-    return value.length === (2 + Math.ceil(bitLength / 4));
+    return (value as string).length === (2 + Math.ceil(bitLength / 4));
   }
 
-  return isValidHex && (ignoreLength || (value.length % 2 === 0));
+  return isValidHex && (ignoreLength || ((value as string).length % 2 === 0));
 }

packages/util/src/is/instanceOf.ts

@@ -16,7 +16,7 @@
  * console.log('isInstanceOf', isInstanceOf(new Array(0), Array)); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isInstanceOf (value: any, clazz: any): boolean {
+// eslint-disable-next-line @typescript-eslint/ban-types
+export default function isInstanceOf (value: unknown, clazz: Function): boolean {
   return value instanceof clazz;
 }

packages/util/src/is/jsonObject.ts

@@ -31,17 +31,15 @@ interface ObjectIndexed {
  * isJsonObject('not an object'); // => false
  * ```
  */
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isJsonObject (value: any): value is ObjectIndexed {
-  value = typeof value !== 'string'
+export default function isJsonObject (value: unknown): value is ObjectIndexed {
+  const str = typeof value !== 'string'
     ? JSON.stringify(value)
     : value;
 
   try {
-    value = JSON.parse(value);
+    const obj = JSON.parse(str) as unknown;
 
-    return (typeof value === 'object' && value !== null);
+    return (typeof obj === 'object' && obj !== null);
   } catch (e) {
     return false;
   }

packages/util/src/is/null.ts

@@ -16,7 +16,6 @@
  * console.log('isNull', isNull(null)); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isNull (value?: any): value is null {
+export default function isNull (value?: unknown): value is null {
   return value === null;
 }

packages/util/src/is/number.ts

@@ -16,7 +16,6 @@
  * console.log('isNumber', isNumber(1234)); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isNumber (value: any): value is number {
+export default function isNumber (value: unknown): value is number {
   return typeof value === 'number';
 }

packages/util/src/is/object.ts

@@ -22,7 +22,6 @@ interface ObjectIndexed {
  * isObject('something'); // => false
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isObject (value: any): value is ObjectIndexed {
+export default function isObject (value: unknown): value is ObjectIndexed {
   return typeof value === 'object';
 }

packages/util/src/is/observable.ts

@@ -24,7 +24,6 @@ interface Observable {
  * console.log('isObservable', isObservable(...));
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isObservable (value: any): value is Observable {
+export default function isObservable (value: unknown): value is Observable {
   return isObject(value) && isFunction((value as Observable).next);
 }

packages/util/src/is/string.ts

@@ -16,7 +16,7 @@
  * console.log('isString', isString('test')); // => true
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/ban-types
-export default function isString (value: any): value is string | String {
+// eslint-disable-next-line @typescript-eslint/ban-types
+export default function isString (value: unknown): value is string | String {
   return typeof value === 'string' || value instanceof String;
 }

packages/util/src/is/toBn.ts

@@ -6,7 +6,6 @@ import { ToBn } from '../types';
 
 import isFunction from './function';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isToBn (value?: any): value is ToBn {
+export default function isToBn (value?: unknown): value is ToBn {
   return !!value && isFunction((value as ToBn).toBn);
 }

packages/util/src/is/u8a.spec.ts

@@ -19,7 +19,7 @@ describe('isUint8Array', (): void => {
 
   it('returns true on Uint8Array values', (): void => {
     expect(
-      isU8a(new Uint8Array([]))
+      isU8a(new Uint8Array())
     ).toEqual(true);
   });
 });

packages/util/src/is/u8a.ts

@@ -18,7 +18,6 @@ import isInstanceOf from './instanceOf';
  * console.log('isU8a', isU8a([])); // => false
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isU8a (value?: any): value is Uint8Array {
+export default function isU8a (value?: unknown): value is Uint8Array {
   return isInstanceOf(value, Uint8Array);
 }

packages/util/src/is/undefined.ts

@@ -17,6 +17,6 @@
  * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function isUndefined (value?: any): value is undefined {
+export default function isUndefined (value?: unknown): value is undefined {
   return typeof value === 'undefined';
 }

packages/util/src/logger.spec.ts

@@ -8,10 +8,8 @@ import { logger } from '.';
 import { format } from './logger';
 
 describe('logger', (): void => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let dateMatch: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let prefixMatch: any;
+  let dateMatch: unknown;
+  let prefixMatch: unknown;
   let l: Logger;
   let ln: Logger;
   let spy: Partial<Console>;
@@ -34,7 +32,9 @@ describe('logger', (): void => {
     };
     global.console = spy as Console;
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     dateMatch = expect.stringMatching(/20[0-9]{2}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}/);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     prefixMatch = expect.stringMatching(/TEST:/);
   });
 
@@ -146,8 +146,7 @@ describe('logger', (): void => {
   });
 
   it('does not debug log when no process.env', (): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    process.env = undefined as any;
+    process.env = undefined as unknown as NodeJS.ProcessEnv;
 
     l = logger('test');
     l.debug('test');

packages/util/src/logger.ts

@@ -31,22 +31,17 @@ const chalked = {
   warn: chalk.yellow
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function formatObject (value: Record<string, any>): any {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const result: Record<string, any> = {};
+function formatObject (value: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return Object.keys(value).reduce((result, key): Record<string, any> => {
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  return Object.keys(value).reduce((result, key): Record<string, unknown> => {
     result[key] = format(value[key]);
 
     return result;
   }, result);
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function format (value: any): any {
+export function format (value: unknown): unknown {
   if (Array.isArray(value)) {
     return value.map(format);
   }
@@ -72,6 +67,7 @@ export function format (value: any): any {
 
 function apply (log: LogType, type: string, values: Logger$Data): void {
   if (values.length === 1 && isFunction(values[0])) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/ban-types
     const fnResult = (values[0] as Function)();
 
     return apply(log, type, Array.isArray(fnResult) ? fnResult : [fnResult]);

packages/util/src/number/toU8a.spec.ts

@@ -8,25 +8,25 @@ describe('numberToU8a', (): void => {
   it('converts 0 to empty', (): void => {
     expect(
       numberToU8a(0)
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('converts undefined to empty', (): void => {
     expect(
       numberToU8a()
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('converts null to empty', (): void => {
     expect(
       numberToU8a(null)
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('converts NaN to empty', (): void => {
     expect(
       numberToU8a(NaN)
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('converts values to the u8a', (): void => {

packages/util/src/number/toU8a.ts

@@ -21,7 +21,7 @@ import numberToHex from './toHex';
  */
 export default function numberToU8a (value?: number | null, bitLength = -1): Uint8Array {
   if (!value || isNaN(value)) {
-    return new Uint8Array([]);
+    return new Uint8Array();
   }
 
   return hexToU8a(

packages/util/src/polyfill/fill.spec.ts

@@ -2,7 +2,6 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-/* eslint-disable @typescript-eslint/ban-ts-ignore */
 /* eslint-disable no-extend-native */
 /* eslint-disable @typescript-eslint/unbound-method */
 
@@ -15,8 +14,10 @@ describe('Array.fill', (): void => {
     arrayFill = Array.prototype.fill;
     u8aFill = Uint8Array.prototype.fill;
 
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     Array.prototype.fill = null;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     Uint8Array.prototype.fill = null;
 

packages/util/src/polyfill/fill.ts

@@ -13,9 +13,11 @@ if (!Array.prototype.fill) {
       throw new TypeError('this is null or not defined');
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const A = Object(this);
 
     // Steps 3-5.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const len = A.length >>> 0;
 
     // Steps 6-7.
@@ -38,17 +40,19 @@ if (!Array.prototype.fill) {
 
     // Step 12.
     while (k < final) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
       A[k] = value;
       k++;
     }
 
     // Step 13.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return A;
   };
 }
 
 if (!Uint8Array.prototype.fill) {
-  // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
   Uint8Array.prototype.fill = Array.prototype.fill;
 }

packages/util/src/polyfill/padEnd.spec.ts

@@ -10,7 +10,7 @@ describe('String padEnd', (): void => {
   beforeEach((): void => {
     stringEnd = String.prototype.padEnd;
 
-    // eslint-disable-next-line no-extend-native,@typescript-eslint/no-explicit-any
+    // eslint-disable-next-line no-extend-native,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
     String.prototype.padEnd = null as any;
 
     require('./padEnd');

packages/util/src/polyfill/padStart.spec.ts

@@ -10,7 +10,7 @@ describe('String padStart', (): void => {
   beforeEach((): void => {
     stringStart = String.prototype.padStart;
 
-    // eslint-disable-next-line no-extend-native,@typescript-eslint/no-explicit-any
+    // eslint-disable-next-line no-extend-native,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment
     String.prototype.padStart = null as any;
 
     require('./padStart');

packages/util/src/polyfill/setPrototypeOf.spec.ts

@@ -3,16 +3,14 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 /* eslint-disable no-proto */
-/* eslint-disable @typescript-eslint/ban-ts-ignore */
-/* eslint-disable @typescript-eslint/unbound-method */
 
 describe('setPrototypeOf', (): void => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let orig: (o: any, proto: object | null) => any;
+  let orig: (o: Record<string, unknown>, proto: Record<string, unknown> | null) => Record<string, unknown>;
 
   beforeEach((): void => {
     orig = Object.setPrototypeOf;
 
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     Object.setPrototypeOf = null;
 
@@ -27,6 +25,7 @@ describe('setPrototypeOf', (): void => {
     const obj = {};
     const proto = { foo: 'bar' };
 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     expect(Object.setPrototypeOf(obj, proto).__proto__).toBe(proto);
   });
 });

packages/util/src/polyfill/setPrototypeOf.ts

@@ -2,13 +2,10 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-/* eslint-disable @typescript-eslint/unbound-method */
-
 // React Native does not have Object.setPrototypeOf
 if (!Object.setPrototypeOf) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Object.setPrototypeOf = function (obj: any, proto: object | null): void {
-    // eslint-disable-next-line no-proto
+  Object.setPrototypeOf = function (obj: Record<string, unknown>, proto: Record<string, unknown> | null): Record<string, unknown> {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,no-proto
     obj.__proto__ = proto;
 
     return obj;

packages/util/src/polyfill/textDecoder.spec.ts

@@ -6,32 +6,32 @@ describe('TextDecoder', (): void => {
   let origTD: TextDecoder;
 
   beforeEach((): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     origTD = (global as any).TextDecoder;
   });
 
   afterEach((): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextDecoder = origTD;
   });
 
   it('polyfills with no exceptions (without TextDecoder)', (): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextDecoder = null;
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     expect(require('./textDecoder')).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     expect((global as any).TextDecoder).toBeDefined();
   });
 
   it('polyfills with no exceptions (with TextDecoder)', (): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextDecoder = require('util').TextDecoder;
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     expect(require('./textDecoder')).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     expect((global as any).TextDecoder).toBeDefined();
   });
 });

packages/util/src/polyfill/textDecoder.ts

@@ -4,8 +4,11 @@
 
 if (typeof TextDecoder === 'undefined') {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (global as any).TextDecoder = require('util').TextDecoder;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-var-requires
+    const { TextDecoder: UTD } = require('util') as { TextDecoder: { new(): TextDecoder } };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-member-access
+    (global as any).TextDecoder = UTD;
   } catch (error) {
     // noop
   }

packages/util/src/polyfill/textEncoder.spec.ts

@@ -6,32 +6,32 @@ describe('TextEncoder', (): void => {
   let origTE: TextEncoder;
 
   beforeEach((): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     origTE = (global as any).TextEncoder;
   });
 
   afterEach((): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextEncoder = origTE;
   });
 
   it('polyfills with no exceptions (without TextEncoder)', (): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextEncoder = null;
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     expect(require('./textEncoder')).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     expect((global as any).TextEncoder).toBeDefined();
   });
 
   it('polyfills with no exceptions (with TextEncoder)', (): void => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     (global as any).TextEncoder = require('util').TextEncoder;
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     expect(require('./textEncoder')).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
     expect((global as any).TextEncoder).toBeDefined();
   });
 });

packages/util/src/polyfill/textEncoder.ts

@@ -4,8 +4,24 @@
 
 if (typeof TextEncoder === 'undefined') {
   try {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (global as any).TextEncoder = require('util').TextEncoder;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-var-requires
+    const { TextEncoder: UTE } = require('util') as { TextEncoder: { new(): TextEncoder } };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-member-access
+    (global as any).TextEncoder = class {
+      #encoder: TextEncoder;
+
+      constructor () {
+        this.#encoder = new UTE();
+      }
+
+      // For a Jest 26.0.1 environment, Buffer !== Uint8Array
+      encode (value: string): Uint8Array {
+        const encoded = this.#encoder.encode(value);
+
+        return Uint8Array.from(encoded);
+      }
+    };
   } catch (error) {
     // noop
   }

packages/util/src/promisify.spec.ts

@@ -22,7 +22,7 @@ describe('promisify', (): void => {
       .then((): void => {
         throw new Error('Received unexpected result');
       })
-      .catch((error): void => {
+      .catch((error: Error): void => {
         expect(error.message).toEqual('test reject');
       });
   });
@@ -38,7 +38,7 @@ describe('promisify', (): void => {
 
   it('handles functions with parameters (reject)', (): Promise<void> => {
     const fn = (a: number, b: boolean, c: string, cb: (error: Error | null, result?: [number, boolean, string]) => void): void =>
-      cb(new Error(`test reject: ${a},${b},${c}`));
+      cb(new Error(`test reject: ${a},${b.toString()},${c}`));
 
     return promisify(null, fn, 3, 'string', true).catch((error: Error): void => {
       expect(error.message).toEqual('test reject: 3,string,true');

packages/util/src/promisify.ts

@@ -2,8 +2,6 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 /**
  * @name promisify
  * @summary Wraps an async callback into a `Promise`
@@ -19,9 +17,10 @@
  * await promisify(null, (cb) => cb(new Error('error!'))); // rejects with `error!`
  * ```
  */
-export default function promisify (self: any, fn: Function, ...params: any[]): Promise<any> {
+// eslint-disable-next-line @typescript-eslint/ban-types,@typescript-eslint/explicit-module-boundary-types,@typescript-eslint/no-explicit-any
+export default function promisify <R = any> (self: unknown, fn: Function, ...params: any[]): Promise<R> {
   return new Promise((resolve, reject): void => {
-    const handler = (error: Error | null, result?: any): void => {
+    const handler = (error: Error | null, result?: R): void => {
       if (error) {
         reject(error);
       } else {
@@ -29,6 +28,6 @@ export default function promisify (self: any, fn: Function, ...params: any[]): P
       }
     };
 
-    fn.apply(self, [...params, handler]);
+    fn.apply(self, params.concat(handler));
   });
 }

packages/util/src/string/shorten.spec.ts

@@ -14,18 +14,6 @@ describe('stringShorten', (): void => {
   it('returns the shortened value when > maxLength', (): void => {
     expect(
       stringShorten('0123456789', 3)
-    ).toEqual('012..789');
-  });
-
-  it('returns undefined as undefined', (): void => {
-    expect(
-      stringShorten()
-    ).toEqual('undefined');
-  });
-
-  it('returns non-string values as strings', (): void => {
-    expect(
-      stringShorten(12345678, 2)
-    ).toEqual('12..78');
+    ).toEqual('012…789');
   });
 });

packages/util/src/string/shorten.ts

@@ -6,7 +6,7 @@
  * @name stringShorten
  * @summary Returns a string with maximum length
  * @description
- * Checks the string against the `prefixLength`, if longer than dopuble this, shortens it by placing `..` in the middle of it
+ * Checks the string against the `prefixLength`, if longer than double this, shortens it by placing `..` in the middle of it
  * @example
  * <BR>
  *
@@ -17,12 +17,10 @@
  * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export default function stringShorten (_value?: any, prefixLength = 6): string {
-  const value = `${_value}`;
-
+export default function stringShorten (value: string, prefixLength = 6): string {
   if (value.length <= 2 + 2 * prefixLength) {
     return value;
   }
 
-  return `${value.substr(0, prefixLength)}..${value.slice(-prefixLength)}`;
+  return `${value.substr(0, prefixLength)}…${value.slice(-prefixLength)}`;
 }

packages/util/src/string/toU8a.spec.ts

@@ -8,7 +8,7 @@ describe('stringToU8a', (): void => {
   it('decodes to an empty string for undefined', (): void => {
     expect(
       stringToU8a()
-    ).toEqual(new Uint8Array([]));
+    ).toEqual(new Uint8Array());
   });
 
   it('encodes the string correctly', (): void => {

packages/util/src/string/toU8a.ts

@@ -39,5 +39,5 @@ try {
 export default function stringToU8a (value?: string): Uint8Array {
   return value
     ? encoder.encode(value)
-    : new Uint8Array([]);
+    : new Uint8Array();
 }

packages/util/src/types.ts

@@ -2,7 +2,7 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import BN from 'bn.js';
+import type BN from 'bn.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export interface Constructor<T = any> {

packages/util/src/u8a/concat.ts

@@ -22,9 +22,8 @@ import u8aToU8a from './toU8a';
  * ```
  */
 export default function u8aConcat (..._list: (Uint8Array | string)[]): Uint8Array {
-  const list: Uint8Array[] = _list.map(u8aToU8a);
-  const length = list.reduce((total, item): number => total + item.length, 0);
-  const result = new Uint8Array(length);
+  const list = _list.map(u8aToU8a);
+  const result = new Uint8Array(list.reduce((total, item): number => total + item.length, 0));
   let offset = 0;
 
   return list.reduce((result, item): Uint8Array => {

packages/util/src/u8a/index.ts

@@ -8,6 +8,7 @@
 
 export { default as u8aConcat } from './concat';
 export { default as u8aFixLength } from './fixLength';
+export { default as u8aSorted } from './sorted';
 export { default as u8aToBn } from './toBn';
 export { default as u8aToBuffer } from './toBuffer';
 export { default as u8aToHex } from './toHex';

packages/util/src/u8a/sorted.spec.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aSorted } from '.';
+
+describe('u8aSorted', (): void => {
+  it('sorts a simple set of u8a', (): void => {
+    expect(
+      u8aSorted([new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6]), new Uint8Array([2, 3, 4])])
+    ).toEqual([new Uint8Array([1, 2, 3]), new Uint8Array([2, 3, 4]), new Uint8Array([4, 5, 6])]);
+  });
+
+  it('sorts a simple set of u8a (not the same lengths)', (): void => {
+    expect(
+      u8aSorted([new Uint8Array([1, 2, 3, 4]), new Uint8Array([4, 5, 6]), new Uint8Array([1, 2, 3, 5])])
+    ).toEqual([new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2, 3, 5]), new Uint8Array([4, 5, 6])]);
+  });
+});

packages/util/src/u8a/sorted.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import isUndefined from '../is/undefined';
+
+export default function u8aSorted (u8as: Uint8Array[]): Uint8Array[] {
+  return u8as.sort((a, b): number => {
+    let i = 0;
+
+    while (true) {
+      if (isUndefined(a[i]) && isUndefined(b[i])) {
+        return 0;
+      } else if (isUndefined(a[i])) {
+        return -1;
+      } else if (isUndefined(b[i])) {
+        return 1;
+      }
+
+      const cmp = a[i] - b[i];
+
+      if (cmp !== 0) {
+        return cmp;
+      }
+
+      i++;
+    }
+  });
+}

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

@@ -33,7 +33,7 @@ describe('u8aToBn', (): void => {
   it('converts empty', (): void => {
     expect(
       u8aToBn(
-        new Uint8Array([]),
+        new Uint8Array(),
         { isLe: true }
       ).toString(16)
     ).toBe('0');