From 34380caf1ff1cb8cd638284f37bce73f5b78a2a3 Mon Sep 17 00:00:00 2001
From: Alexander Krupenkin <mail@akru.me>
Date: Thu, 30 Apr 2020 07:33:10 +0900
Subject: [PATCH] Added ECDSA keypair support (#589)

* Added ECDSA signature verification

* Add ECDSA keypair, sign, key derivation, fromSeed and tests

* keyring: added ECDSA keypair

* Fix lint errors
---
 packages/keyring/src/index.spec.ts            | 65 +++++++++++++++++++
 packages/keyring/src/keyring.ts               | 34 +++++-----
 packages/keyring/src/pair/index.ts            | 54 +++++++++------
 packages/keyring/src/pair/toJson.ts           |  7 +-
 packages/keyring/src/pairs.ts                 |  2 +-
 packages/util-crypto/src/key/fromPath.ts      | 11 ++--
 packages/util-crypto/src/key/hdkdEcdsa.ts     | 19 ++++++
 packages/util-crypto/src/key/index.ts         |  1 +
 .../util-crypto/src/secp256k1/deriveHard.ts   | 13 ++++
 packages/util-crypto/src/secp256k1/index.ts   |  3 +
 .../src/secp256k1/keypair/fromSeed.spec.ts    | 31 +++++++++
 .../src/secp256k1/keypair/fromSeed.ts         | 24 +++++++
 .../src/secp256k1/keypair/testing.ts          | 35 ++++++++++
 packages/util-crypto/src/secp256k1/sign.ts    | 28 ++++++++
 .../src/secp256k1/signVerify.spec.ts          | 36 ++++++++++
 packages/util-crypto/src/secp256k1/verify.ts  | 29 +++++++++
 .../util-crypto/src/signature/verify.spec.ts  | 29 +++++----
 packages/util-crypto/src/signature/verify.ts  | 39 +++++++----
 packages/util-crypto/src/types.ts             |  2 +-
 19 files changed, 392 insertions(+), 70 deletions(-)
 create mode 100644 packages/util-crypto/src/key/hdkdEcdsa.ts
 create mode 100644 packages/util-crypto/src/secp256k1/deriveHard.ts
 create mode 100644 packages/util-crypto/src/secp256k1/keypair/fromSeed.spec.ts
 create mode 100644 packages/util-crypto/src/secp256k1/keypair/fromSeed.ts
 create mode 100644 packages/util-crypto/src/secp256k1/keypair/testing.ts
 create mode 100644 packages/util-crypto/src/secp256k1/sign.ts
 create mode 100644 packages/util-crypto/src/secp256k1/signVerify.spec.ts
 create mode 100644 packages/util-crypto/src/secp256k1/verify.ts

diff --git a/packages/keyring/src/index.spec.ts b/packages/keyring/src/index.spec.ts
index bfd5107a9..e4e55c36d 100644
--- a/packages/keyring/src/index.spec.ts
+++ b/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);
+    });
+  });
 });
diff --git a/packages/keyring/src/keyring.ts b/packages/keyring/src/keyring.ts
index 378c83b50..311da8c29 100644
--- a/packages/keyring/src/keyring.ts
+++ b/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);
   }
 
   /**
diff --git a/packages/keyring/src/pair/index.ts b/packages/keyring/src/pair/index.ts
index 955e857e5..c0acef88d 100644
--- a/packages/keyring/src/pair/index.ts
+++ b/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)
   };
diff --git a/packages/keyring/src/pair/toJson.ts b/packages/keyring/src/pair/toJson.ts
index 37ea38cf1..0e76416bc 100644
--- a/packages/keyring/src/pair/toJson.ts
+++ b/packages/keyring/src/pair/toJson.ts
@@ -6,15 +6,14 @@ 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;
+  address: string;
 };
 
-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],
diff --git a/packages/keyring/src/pairs.ts b/packages/keyring/src/pairs.ts
index 916e3d78d..69d0786d6 100644
--- a/packages/keyring/src/pairs.ts
+++ b/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;
   }
diff --git a/packages/util-crypto/src/key/fromPath.ts b/packages/util-crypto/src/key/fromPath.ts
index db57ddd25..2cb3e4811 100644
--- a/packages/util-crypto/src/key/fromPath.ts
+++ b/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);
 }
diff --git a/packages/util-crypto/src/key/hdkdEcdsa.ts b/packages/util-crypto/src/key/hdkdEcdsa.ts
new file mode 100644
index 000000000..26bf09425
--- /dev/null
+++ b/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)
+  );
+}
diff --git a/packages/util-crypto/src/key/index.ts b/packages/util-crypto/src/key/index.ts
index 290deee60..d5d4b4496 100644
--- a/packages/util-crypto/src/key/index.ts
+++ b/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';
diff --git a/packages/util-crypto/src/secp256k1/deriveHard.ts b/packages/util-crypto/src/secp256k1/deriveHard.ts
new file mode 100644
index 000000000..59c500a45
--- /dev/null
+++ b/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);
+}
diff --git a/packages/util-crypto/src/secp256k1/index.ts b/packages/util-crypto/src/secp256k1/index.ts
index 3202fcb2f..35d8ca9c6 100644
--- a/packages/util-crypto/src/secp256k1/index.ts
+++ b/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';
diff --git a/packages/util-crypto/src/secp256k1/keypair/fromSeed.spec.ts b/packages/util-crypto/src/secp256k1/keypair/fromSeed.spec.ts
new file mode 100644
index 000000000..68301b283
--- /dev/null
+++ b/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);
+    });
+  });
+});
diff --git a/packages/util-crypto/src/secp256k1/keypair/fromSeed.ts b/packages/util-crypto/src/secp256k1/keypair/fromSeed.ts
new file mode 100644
index 000000000..d63adc295
--- /dev/null
+++ b/packages/util-crypto/src/secp256k1/keypair/fromSeed.ts
@@ -0,0 +1,24 @@
+// 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: ' + seed);
+  const key = ec.keyFromPrivate(seed);
+
+  return {
+    publicKey: new Uint8Array(key.getPublic().encodeCompressed('array')),
+    secretKey: hexToU8a('0x' + key.getPrivate('hex'))
+  };
+}
diff --git a/packages/util-crypto/src/secp256k1/keypair/testing.ts b/packages/util-crypto/src/secp256k1/keypair/testing.ts
new file mode 100644
index 000000000..b07803e3b
--- /dev/null
+++ b/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;
diff --git a/packages/util-crypto/src/secp256k1/sign.ts b/packages/util-crypto/src/secp256k1/sign.ts
new file mode 100644
index 000000000..fe3fb53c1
--- /dev/null
+++ b/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);
+}
diff --git a/packages/util-crypto/src/secp256k1/signVerify.spec.ts b/packages/util-crypto/src/secp256k1/signVerify.spec.ts
new file mode 100644
index 000000000..b1f211510
--- /dev/null
+++ b/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);
+  });
+});
diff --git a/packages/util-crypto/src/secp256k1/verify.ts b/packages/util-crypto/src/secp256k1/verify.ts
new file mode 100644
index 000000000..615cf4b6a
--- /dev/null
+++ b/packages/util-crypto/src/secp256k1/verify.ts
@@ -0,0 +1,29 @@
+// 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(
+    ec.recoverPubKey(blake2AsU8a(message, 256), sig, recovery)
+      .encodeCompressed(null)
+  );
+
+  return Buffer.compare(blake2AsU8a(publicKey, 256), u8aToU8a(address)) === 0;
+}
diff --git a/packages/util-crypto/src/signature/verify.spec.ts b/packages/util-crypto/src/signature/verify.spec.ts
index 28e3dbc65..ea0ba47ce 100644
--- a/packages/util-crypto/src/signature/verify.spec.ts
+++ b/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',
diff --git a/packages/util-crypto/src/signature/verify.ts b/packages/util-crypto/src/signature/verify.ts
index 59736c0df..b2053ea44 100644
--- a/packages/util-crypto/src/signature/verify.ts
+++ b/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);
+  }
 }
diff --git a/packages/util-crypto/src/types.ts b/packages/util-crypto/src/types.ts
index 396e1cba3..002022aa0 100644
--- a/packages/util-crypto/src/types.ts
+++ b/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;