Merge branch 'master' into isValidOrderHash

package.json

@@ -39,6 +39,7 @@
     "awesome-typescript-loader": "^3.1.3",
     "bignumber.js": "^4.0.2",
     "chai": "^3.5.0",
+    "chai-bignumber": "^2.0.0",
     "mocha": "^3.4.1",
     "npm-run-all": "^4.0.2",
     "nyc": "^10.3.2",

src/ts/0x.js.ts

@@ -56,5 +56,30 @@ export class ZeroEx {
         assert.isString('orderHash', orderHash);
         const isValid = /^0x[0-9A-F]{66}$/i.test(orderHash);
         return isValid;
+    /*
+     * A unit amount is defined as the amount of a token above the specified decimal places (integer part).
+     * E.g: If a currency has 18 decimal places, 1e18 or one quintillion of the currency is equivalent
+     * to 1 unit.
+    */
+    public static toUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+        assert.isBigNumber('amount', amount);
+        assert.isNumber('decimals', decimals);
+
+        const aUnit = new BigNumber(10).pow(decimals);
+        const unit = amount.div(aUnit);
+        return unit;
+    }
+    /*
+     * A baseUnit is defined as the smallest denomination of a token. An amount expressed in baseUnits
+     * is the amount expressed in the smallest denomination.
+     * E.g: 1 unit of a token with 18 decimal places is expressed in baseUnits as 1000000000000000000
+    */
+    public static toBaseUnitAmount(amount: BigNumber.BigNumber, decimals: number): BigNumber.BigNumber {
+        assert.isBigNumber('amount', amount);
+        assert.isNumber('decimals', decimals);
+
+        const unit = new BigNumber(10).pow(decimals);
+        const baseUnitAmount = amount.times(unit);
+        return baseUnitAmount;
     }
 }

src/ts/globals.d.ts

@@ -1,14 +1,25 @@
-declare type ETHAddressBuff = Buffer;
+declare module 'chai-bignumber';
 
 declare interface Schema {
     id: string;
 }
 
+// HACK: In order to merge the bignumber declaration added by chai-bignumber to the chai Assertion
+// interface we must use `namespace` as the Chai definitelyTyped definition does. Since we otherwise
+// disallow `namespace`, we disable tslint for the following.
+/* tslint:disable */
+declare namespace Chai {
+    interface Assertion {
+        bignumber: Assertion;
+    }
+}
+/* tslint:enable */
+
 declare module 'ethereumjs-util' {
     const toBuffer: (dataHex: string) => Buffer;
     const hashPersonalMessage: (msg: Buffer) => Buffer;
     const bufferToHex: (buff: Buffer) => string;
     const ecrecover: (msgHashBuff: Buffer, v: number, r: Buffer, s: Buffer) => string;
-    const pubToAddress: (pubKey: string) => ETHAddressBuff;
+    const pubToAddress: (pubKey: string) => Buffer;
     const isValidAddress: (address: string) => boolean;
 }

test/0x.js.ts

@@ -1,7 +1,12 @@
 import {ZeroEx} from '../src/ts/0x.js';
-import {expect} from 'chai';
+import * as chai from 'chai';
 import 'mocha';
 import * as BigNumber from 'bignumber.js';
+import ChaiBigNumber = require('chai-bignumber');
+
+// Use BigNumber chai add-on
+chai.use(ChaiBigNumber());
+const expect = chai.expect;
 
 describe('ZeroEx library', () => {
     describe('#isValidSignature', () => {
@@ -94,6 +99,22 @@ describe('ZeroEx library', () => {
         it('returns true if order hash is correct', () => {
             const isValid = ZeroEx.isValidOrderHash('0x' + Array(65).join('0'));
             expect(isValid).to.be.true;
+    describe('#toUnitAmount', () => {
+        it('Should return the expected unit amount for the decimals passed in', () => {
+            const baseUnitAmount = new BigNumber(1000000000);
+            const decimals = 6;
+            const unitAmount = ZeroEx.toUnitAmount(baseUnitAmount, decimals);
+            const expectedUnitAmount = new BigNumber(1000);
+            expect(unitAmount).to.be.bignumber.equal(expectedUnitAmount);
+        });
+    });
+    describe('#toBaseUnitAmount', () => {
+        it('Should return the expected base unit amount for the decimals passed in', () => {
+            const unitAmount = new BigNumber(1000);
+            const decimals = 6;
+            const baseUnitAmount = ZeroEx.toBaseUnitAmount(unitAmount, decimals);
+            const expectedUnitAmount = new BigNumber(1000000000);
+            expect(baseUnitAmount).to.be.bignumber.equal(expectedUnitAmount);
         });
     });
 });