test(): add basic tests for util.ts

Author: Ian Tan

jest.config.js

@@ -3,8 +3,8 @@ const config = {
     '^.+\\.(t|j)s$': 'ts-jest',
   },
   testMatch: [
-    '<rootDir>/src/**/__tests__/**/*.ts?(x)',
-    '<rootDir>/src/**/?(*.)+(spec|test).ts?(x)',
+    // '<rootDir>/src/**/__tests__/**/*.ts',
+    '<rootDir>/src/**/?(*.)+(spec|test).ts',
   ],
   moduleDirectories: ['src', 'node_modules'],
   moduleFileExtensions: ['js', 'ts'],

package.json

@@ -11,8 +11,8 @@
   "dependencies": {
     "bn.js": "^4.11.8",
     "bsert": "^0.0.3",
-    "crypto-js": "^3.1.9-1",
     "elliptic": "^6.4.0",
+    "hash.js": "^1.1.5",
     "hmac-drbg": "^1.0.1",
     "node-fetch": "^2.2.0",
     "valid-url": "^1.0.9"

src/__tests__/keypairs.fixtures.ts

@@ -0,0 +1,62 @@
+export const pairs = [
+  {
+    private: 'b776d8f068d11b3c3f5b94db0fb30efea05b73ddb9af1bbd5da8182d94245f0b',
+    public:
+      '04cfa555bb63231d167f643f1a23ba66e6ca1458d416ddb9941e95b5fd28df0ac513075403c996efbbc15d187868857e31cf7be4d109b4f8cb3fd40499839f150a',
+    digest: '533eb365e9c33754c7d7cf437d15fbdfb708c65f330253ea65b9ba2ba553fffe',
+  },
+  {
+    private: '24180e6b0c3021aedb8f5a86f75276ee6fc7ff46e67e98e716728326102e91c9',
+    public:
+      '04163fa604c65aebeb7048c5548875c11418d6d106a20a0289d67b59807abdd299d4cf0efcf07e96e576732dae122b9a8ac142214a6bc133b77aa5b79ba46b3e20',
+    digest: 'cd10769d6ea5b71d13b90a4c810ce050814fcd9dc1a257087aa00cb9e4f50fe3',
+  },
+  {
+    private: 'af71626e38926401a6d2fd8fdf91c97f785b8fb2b867e7f8a884351e59ee9aa6',
+    public:
+      '0485c34ff11ea1e06f44d35afe3cc1748b6b122bb06df021a4767db4ef5fbcf1cdbed73c821d89724b59a0fc5e2f2e3e1a9c121d698fff36d750ee463117438a14',
+    digest: 'f900af5c4b116e050687ce9116d9f99608a64b2005215670014ca04482e0dc76',
+  },
+  {
+    private: 'b94289721618d1a8100bea8502fee149bae7313fcbaebf5ad6a867d557e82971',
+    public:
+      '04c7d47ad99dd1db85c9d0b6abe89ffc137f230c991a33890c05436a14974543a29d58bc4655269db6bcd6ea27adca287f956355c64d676cefcfea14051b5239c9',
+    digest: 'f3b24aed190c68ca93fd03ca268e234003da7a08bc400cae93d470ca2d6a4c91',
+  },
+  {
+    private: 'c577711506abf9dbdabd09c5ae66492e77d6450e8d739ce6493728e781150236',
+    public:
+      '0484929ab70d2b39703319a94144802ea9b9a7c8c1a673b10f01738db5b5c40ea8f534bc21ef1b167ffcac7d1a087ed5be2a5d1fa720bc016fbfbd9fb869aee4c6',
+    digest: 'e4908def64f5255f313a8d137b478be9af5b34052ec73f1bca1dcf18f046351f',
+  },
+  {
+    private: 'e9521f5f9f2ac16f4e22681d43f2c1e15163ffe56e5912d57540dd59d71f2877',
+    public:
+      '04db0535d0e4337e5ada6d87b07569308f3f3de19aad15ba1f95108e96f855e17195e5b86773f7570645832048cb5e13e1721784ecce6bf69a0342f873e3afef58',
+    digest: 'd2a8c89cf55bb366d3631aedd39cc1bad2a9938b6b42847a0b1ec9ac79c5c31c',
+  },
+  {
+    private: 'def6ac38d746349abd8a28903c6b98b06156f6f3925d1c32dec9964541fbbfa1',
+    public:
+      '04dc5ca31dff767cb18f92d208fd74e36e800508d3b88bee61680bb7cefa0515943f2801d25bbce9c6a65721427f2443532980a0f7b7aae71b1fe0501179b8f641',
+    digest: 'cb72209dc219fea538f6d134c571555d6201e90a5cc60dc1e85db227b934311e',
+  },
+  {
+    private: '93fe1b32f4f1358d6809982bce53b9e95c083eb889d14b0c2d0f96012074dc6b',
+    public:
+      '04987f1f6a2fe56cd0c2461f2920e3e0d9bd9de96a8febf9246e187e057c6141c494b697455dccefa29361b976698594082ed962da42bce09ef0ce59bd05510dd4',
+    digest: '672f8403890d6640ba82e1b67bd976037efa0f373aaa9d8fb281c98c3910b889',
+  },
+  {
+    private: 'efaa6048789fa0282302a5620a2fb0e2c60095a54c42b8312646bbbe1d2ec801',
+    public:
+      '04645a3995ff3309a36d1ec0991fd87ece2ee36e8887f0d5b304accb9152fe7a603aba24fefa904741e0fd67db24432a38153ecdc496ceec38eab1b7c2d8405de9',
+    digest: 'ed65e2933beba968f04857532ea8fb93a0f086fc35fa41e8f6cb458867bea380',
+  },
+  {
+    private: 'ca7de577b3e6968da27088d22e918c039a96af3d4821b7e103560fb6ca1185c4',
+    public:
+      '04f3e03a4ac451a78254fa3d056448db6cbc29d2ef429228c8435141a126c0c07f2446c68270016322e93a6a14f2e7c557bfdcc74e122a013498b7f1ebe008cc30',
+    digest: 'dee77df5370c94e61bb300588b6e4653dd2b76bf48862064f2f2ec1202f7f489',
+  },
+];

src/__tests__/util.spec.ts

@@ -0,0 +1,75 @@
+import elliptic from 'elliptic';
+import hashjs from 'hash.js';
+import {pairs} from './keypairs.fixtures';
+import * as util from '../util';
+import * as schnorr from '../schnorr';
+
+const secp256k1 = elliptic.ec('secp256k1');
+
+describe('utils', () => {
+  it('should be able to generate a valid 32-byte private key', () => {
+    const pk = util.generatePrivateKey();
+
+    expect(pk.slice(2)).toHaveLength(64);
+    expect(util.verifyPrivateKey(pk)).toBeTruthy();
+  });
+
+  it('should recover a public key from a private key', () => {
+    pairs.forEach(({private: priv, public: expected}) => {
+      const actual = util.getPubKeyFromPrivateKey(priv);
+      expect(actual).toEqual(expected);
+    });
+  });
+
+  it('should convert a public key to an address', () => {
+    pairs.forEach(({public: pub, digest}) => {
+      const expected = digest.slice(0, 40);
+      const actual = util.getAddressFromPublicKey(pub);
+      expect(actual).toEqual(expected);
+    });
+  });
+
+  it('should be able to recover an address from a private key', () => {
+    const pk = util.generatePrivateKey();
+    const publicKey = secp256k1
+      .keyFromPrivate(pk, 'hex')
+      .getPublic(false, 'hex');
+    const hash = hashjs.sha256().update(publicKey).digest('hex');
+    const expected = hash.slice(0, 40);
+    const actual = util.getAddressFromPrivateKey(pk);
+
+    expect(actual).toHaveLength(40);
+    expect(actual).toEqual(hash.slice(0, 40));
+    expect(actual).toEqual(expected);
+  });
+
+  it('should sign messages correctly', () => {
+    const privateKey = pairs[1].private;
+    const publicKey = secp256k1
+      .keyFromPrivate(privateKey, 'hex')
+      .getPublic(false, 'hex');
+
+    const tx = {
+      version: 8,
+      nonce: 8,
+      to: pairs[0].digest.slice(0, 40),
+      from: pairs[1].digest.slice(0, 40),
+      pubKey: publicKey,
+      amount: 888,
+      gasPrice: 8,
+      gasLimit: 88,
+      code: '',
+      data: '',
+    };
+
+    const encodedTx = util.encodeTransaction(tx);
+    const sig = schnorr.sign(
+      encodedTx,
+      new Buffer(privateKey, 'hex'),
+      new Buffer(publicKey, 'hex'),
+    );
+    const res = schnorr.verify(encodedTx, sig, new Buffer(publicKey, 'hex'));
+
+    expect(res).toBeTruthy();
+  });
+});

src/index.ts

@@ -0,0 +1,7 @@
+import Zilliqa from './zilliqa';
+export { default as Zilliqa } from './zilliqa';
+
+if (typeof window !== 'undefined' && typeof window.Zilliqa === 'undefined') {
+  window.Zilliqa = Zilliqa;
+}
+

src/schnorr.ts

@@ -21,11 +21,17 @@
 import assert from 'bsert';
 import elliptic from 'elliptic';
 import BN from 'bn.js';
+import hashjs from 'hash.js';
 import DRBG from 'hmac-drbg';
-import sha256 from 'crypto-js/sha256';
 import Signature from 'elliptic/lib/elliptic/ec/signature';
 
 const curve = elliptic.ec('secp256k1').curve;
+// Public key is a point (x, y) on the curve.
+// Each coordinate requires 32 bytes.
+// In its compressed form it suffices to store the x co-ordinate
+// and the sign for y.
+// Hence a total of 33 bytes.
+const PUBKEY_COMPRESSED_SIZE_BYTES = 33;
 
 /**
  * Hash (r | M).
@@ -36,30 +42,34 @@ const curve = elliptic.ec('secp256k1').curve;
  */
 
 export const hash = (q: BN, pubkey: Buffer, msg: Buffer) => {
-  const totalLength = 66 + msg.byteLength; // 33 q + 33 pubkey + variable msgLen
+  const sha256 = hashjs.sha256();
+  const totalLength = PUBKEY_COMPRESSED_SIZE_BYTES * 2 + msg.byteLength; // 33 q + 33 pubkey + variable msgLen
   const Q = q.toArrayLike(Buffer, 'be', 33);
   const B = Buffer.allocUnsafe(totalLength);
 
   Q.copy(B, 0);
   pubkey.copy(B, 33);
   msg.copy(B, 66);
 
-  return new BN(sha256.digest(B));
+  return new BN(sha256.update(B).digest('hex'));
 };
 
 /**
- * Sign message.
+ * sign
+ *
  * @param {Buffer} msg
  * @param {Buffer} key
- * @param {Buffer} pubNonce
+ * @param {Buffer} pubkey
+ * @param {Buffer} pubNonce?
+ *
  * @returns {Signature}
  */
 export const sign = (
   msg: Buffer,
   key: Buffer,
   pubkey: Buffer,
   pubNonce?: Buffer,
-) => {
+): Signature => {
   const prv = new BN(key);
   const drbg = getDRBG(msg, key, pubNonce);
   const len = curve.n.byteLength();
@@ -77,38 +87,43 @@ export const sign = (
 };
 
 /**
- * Sign message.
+ * trySign
  *
  * @param {Buffer} msg
- * @param {BN} priv
- * @param {BN} k
- * @param {Buffer} pn
+ * @param {BN} prv - private key
+ * @param {BN} k - DRBG-generated random number
+ * @param {Buffer} pn - optional
+ * @param {Buffer)} pubKey - public key
  *
- * @returns {Signature|null}
+ * @returns {Signature | null =>}
  */
-const trySign = (msg: Buffer, prv: BN, k: BN, pn: Buffer, pubKey: Buffer) => {
+const trySign = (msg: Buffer, prv: BN, k: BN, pn: Buffer, pubKey: Buffer): Signature | null => {
   if (prv.isZero()) throw new Error('Bad private key.');
 
   if (prv.gte(curve.n)) throw new Error('Bad private key.');
 
+  // 1a. check that k is not 0
   if (k.isZero()) return null;
-
+  // 1b. check that k is < the order of the group
   if (k.gte(curve.n)) return null;
 
+  // 2. Compute commitment Q = kG, where g is the base point
   const Q = curve.g.mul(k);
+  // convert the commitment to octets first
   const compressedQ = new BN(Q.encodeCompressed());
 
-  const Q = curve.g.mul(k);
-  const compressedQ = new BN(Q.encodeCompressed());
-
+  // 3. Compute the challenge r = H(Q || pubKey || msg)
   const r = hash(compressedQ, pubKey, msg);
   const h = r.clone();
 
   if (h.isZero()) return null;
 
-  if (h.gte(curve.n)) return null;
+  if (h.eq(curve.n)) return null;
 
+  // 4. Compute s = k - r * prv
+  // 4a. Compute r * prv
   let s = h.imul(prv);
+  // 4b. Compute s = k - r * prv mod n
   s = k.isub(s);
   s = s.umod(curve.n);
 
@@ -119,13 +134,20 @@ const trySign = (msg: Buffer, prv: BN, k: BN, pn: Buffer, pubKey: Buffer) => {
 
 /**
  * Verify signature.
+ *
  * @param {Buffer} msg
  * @param {Buffer} signature
  * @param {Buffer} key
- * @returns {Buffer}
+ *
+ * @returns {boolean}
+ *
+ * 1. Check if r,s is in [1, ..., order-1]
+ * 2. Compute Q = sG + r*kpub
+ * 3. If Q = O (the neutral point), return 0;
+ * 4. r' = H(Q, kpub, m)
+ * 5. return r' == r
  */
-
-export const verify = (msg: Buffer, signature: Buffer, key: Buffer) => {
+export const verify = (msg: Buffer, signature: Signature, key: Buffer) => {
   const sig = new Signature(signature);
 
   if (sig.s.gte(curve.n)) throw new Error('Invalid S value.');
@@ -159,8 +181,8 @@ export const alg = Buffer.from('Schnorr+SHA256  ', 'ascii');
  * Instantiate an HMAC-DRBG.
  *
  * @param {Buffer} msg
- * @param {Buffer} priv
- * @param {Buffer} data
+ * @param {Buffer} priv - used as entropy input
+ * @param {Buffer} data - used as nonce
  *
  * @returns {DRBG}
  */
@@ -177,14 +199,22 @@ export const getDRBG = (msg: Buffer, priv: Buffer, data?: Buffer) => {
 
   alg.copy(pers, 32);
 
-  return new DRBG(sha256, priv, msg, pers);
+  // return new DRBG(sha256, priv, msg, pers);
+  return new DRBG({
+    hash: hashjs.sha256,
+    entropy: priv,
+    nonce: msg,
+    pers,
+  });
 };
 
 /**
  * Generate pub+priv nonce pair.
+ *
  * @param {Buffer} msg
  * @param {Buffer} priv
  * @param {Buffer} data
+ *
  * @returns {Buffer}
  */