Add config file specifically in prettier command and fix files

24 files changed, 4370 insertions, 4370 deletions

diff --git a/packages/0x.js/test/0x.js_test.ts b/packages/0x.js/test/0x.js_test.ts
index 5ece5192f..927fe20be 100644
--- a/packages/0x.js/test/0x.js_test.ts
+++ b/packages/0x.js/test/0x.js_test.ts
@@ -19,278 +19,278 @@ const expect = chai.expect;
 const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
 
 describe('ZeroEx library', () => {
-	const web3 = web3Factory.create();
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	const zeroEx = new ZeroEx(web3.currentProvider, config);
-	describe('#setProvider', () => {
-		it('overrides provider in nested web3s and invalidates contractInstances', async () => {
-			// Instantiate the contract instances with the current provider
-			await (zeroEx.exchange as any)._getExchangeContractAsync();
-			await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-			expect((zeroEx.exchange as any)._exchangeContractIfExists).to.not.be.undefined();
-			expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.not.be.undefined();
+    const web3 = web3Factory.create();
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    describe('#setProvider', () => {
+        it('overrides provider in nested web3s and invalidates contractInstances', async () => {
+            // Instantiate the contract instances with the current provider
+            await (zeroEx.exchange as any)._getExchangeContractAsync();
+            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
+            expect((zeroEx.exchange as any)._exchangeContractIfExists).to.not.be.undefined();
+            expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.not.be.undefined();
 
-			const newProvider = web3Factory.getRpcProvider();
-			// Add property to newProvider so that we can differentiate it from old provider
-			(newProvider as any).zeroExTestId = 1;
-			zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+            const newProvider = web3Factory.getRpcProvider();
+            // Add property to newProvider so that we can differentiate it from old provider
+            (newProvider as any).zeroExTestId = 1;
+            zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
 
-			// Check that contractInstances with old provider are removed after provider update
-			expect((zeroEx.exchange as any)._exchangeContractIfExists).to.be.undefined();
-			expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.be.undefined();
+            // Check that contractInstances with old provider are removed after provider update
+            expect((zeroEx.exchange as any)._exchangeContractIfExists).to.be.undefined();
+            expect((zeroEx.tokenRegistry as any)._tokenRegistryContractIfExists).to.be.undefined();
 
-			// Check that all nested web3 wrapper instances return the updated provider
-			const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getCurrentProvider();
-			expect(nestedWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-			const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
-			expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-			const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getCurrentProvider();
-			expect(tokenRegistryWeb3WrapperProvider.zeroExTestId).to.be.a('number');
-		});
-	});
-	describe('#isValidSignature', () => {
-		// The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes
-		// the length of the data is exactly 32 bytes. Thus for these tests, we use data of this size.
-		const dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-		const signature = {
-			v: 27,
-			r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-			s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-		};
-		const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-		it("should return false if the data doesn't pertain to the signature & address", async () => {
-			expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
-			return expect(
-				(zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync('0x0', signature, address),
-			).to.become(false);
-		});
-		it("should return false if the address doesn't pertain to the signature & data", async () => {
-			const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
-			expect(ZeroEx.isValidSignature(dataHex, signature, validUnrelatedAddress)).to.be.false();
-			return expect(
-				(zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(
-					dataHex,
-					signature,
-					validUnrelatedAddress,
-				),
-			).to.become(false);
-		});
-		it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
-			const wrongSignature = _.assign({}, signature, { v: 28 });
-			expect(ZeroEx.isValidSignature(dataHex, wrongSignature, address)).to.be.false();
-			return expect(
-				(zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, wrongSignature, address),
-			).to.become(false);
-		});
-		it('should return true if the signature does pertain to the dataHex & address', async () => {
-			const isValidSignatureLocal = ZeroEx.isValidSignature(dataHex, signature, address);
-			expect(isValidSignatureLocal).to.be.true();
-			return expect(
-				(zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature, address),
-			).to.become(true);
-		});
-	});
-	describe('#generateSalt', () => {
-		it('generates different salts', () => {
-			const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt());
-			expect(equal).to.be.false();
-		});
-		it('generates salt in range [0..2^256)', () => {
-			const salt = ZeroEx.generatePseudoRandomSalt();
-			expect(salt.greaterThanOrEqualTo(0)).to.be.true();
-			const twoPow256 = new BigNumber(2).pow(256);
-			expect(salt.lessThan(twoPow256)).to.be.true();
-		});
-	});
-	describe('#isValidOrderHash', () => {
-		it('returns false if the value is not a hex string', () => {
-			const isValid = ZeroEx.isValidOrderHash('not a hex');
-			expect(isValid).to.be.false();
-		});
-		it('returns false if the length is wrong', () => {
-			const isValid = ZeroEx.isValidOrderHash('0xdeadbeef');
-			expect(isValid).to.be.false();
-		});
-		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 throw if invalid baseUnit amount supplied as argument', () => {
-			const invalidBaseUnitAmount = new BigNumber(1000000000.4);
-			const decimals = 6;
-			expect(() => ZeroEx.toUnitAmount(invalidBaseUnitAmount, decimals)).to.throw(
-				'amount should be in baseUnits (no decimals), found value: 1000000000.4',
-			);
-		});
-		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);
-		});
-		it('should throw if unitAmount has more decimals then specified as the max decimal precision', () => {
-			const unitAmount = new BigNumber(0.823091);
-			const decimals = 5;
-			expect(() => ZeroEx.toBaseUnitAmount(unitAmount, decimals)).to.throw(
-				'Invalid unit amount: 0.823091 - Too many decimal places',
-			);
-		});
-	});
-	describe('#getOrderHashHex', () => {
-		const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
-		const fakeExchangeContractAddress = '0xb69e673309512a9d726f87304c6984054f87a93b';
-		const order: Order = {
-			maker: constants.NULL_ADDRESS,
-			taker: constants.NULL_ADDRESS,
-			feeRecipient: constants.NULL_ADDRESS,
-			makerTokenAddress: constants.NULL_ADDRESS,
-			takerTokenAddress: constants.NULL_ADDRESS,
-			exchangeContractAddress: fakeExchangeContractAddress,
-			salt: new BigNumber(0),
-			makerFee: new BigNumber(0),
-			takerFee: new BigNumber(0),
-			makerTokenAmount: new BigNumber(0),
-			takerTokenAmount: new BigNumber(0),
-			expirationUnixTimestampSec: new BigNumber(0),
-		};
-		it('calculates the order hash', async () => {
-			const orderHash = ZeroEx.getOrderHashHex(order);
-			expect(orderHash).to.be.equal(expectedOrderHash);
-		});
-		it('throws a readable error message if taker format is invalid', async () => {
-			const orderWithInvalidtakerFormat = {
-				...order,
-				taker: (null as any) as string,
-			};
-			const expectedErrorMessage =
-				'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
-			expect(() => ZeroEx.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
-		});
-	});
-	describe('#signOrderHashAsync', () => {
-		let stubs: Sinon.SinonStub[] = [];
-		let makerAddress: string;
-		before(async () => {
-			const availableAddreses = await zeroEx.getAvailableAddressesAsync();
-			makerAddress = availableAddreses[0];
-		});
-		afterEach(() => {
-			// clean up any stubs after the test has completed
-			_.each(stubs, s => s.restore());
-			stubs = [];
-		});
-		it('Should return the correct ECSignature', async () => {
-			const orderHash = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
-			const expectedECSignature = {
-				v: 27,
-				r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
-				s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
-			};
-			const ecSignature = await zeroEx.signOrderHashAsync(
-				orderHash,
-				makerAddress,
-				SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-			);
-			expect(ecSignature).to.deep.equal(expectedECSignature);
-		});
-		it('should return the correct ECSignature for signatureHex concatenated as R + S + V', async () => {
-			const orderHash = '0x34decbedc118904df65f379a175bb39ca18209d6ce41d5ed549d54e6e0a95004';
-			const signature =
-				'0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb021b';
-			const expectedECSignature = {
-				v: 27,
-				r: '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3',
-				s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
-			};
-			stubs = [
-				Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
-				Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-			];
+            // Check that all nested web3 wrapper instances return the updated provider
+            const nestedWeb3WrapperProvider = (zeroEx as any)._web3Wrapper.getCurrentProvider();
+            expect(nestedWeb3WrapperProvider.zeroExTestId).to.be.a('number');
+            const exchangeWeb3WrapperProvider = (zeroEx.exchange as any)._web3Wrapper.getCurrentProvider();
+            expect(exchangeWeb3WrapperProvider.zeroExTestId).to.be.a('number');
+            const tokenRegistryWeb3WrapperProvider = (zeroEx.tokenRegistry as any)._web3Wrapper.getCurrentProvider();
+            expect(tokenRegistryWeb3WrapperProvider.zeroExTestId).to.be.a('number');
+        });
+    });
+    describe('#isValidSignature', () => {
+        // The Exchange smart contract `isValidSignature` method only validates orderHashes and assumes
+        // the length of the data is exactly 32 bytes. Thus for these tests, we use data of this size.
+        const dataHex = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
+        const signature = {
+            v: 27,
+            r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
+            s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
+        };
+        const address = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
+        it("should return false if the data doesn't pertain to the signature & address", async () => {
+            expect(ZeroEx.isValidSignature('0x0', signature, address)).to.be.false();
+            return expect(
+                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync('0x0', signature, address),
+            ).to.become(false);
+        });
+        it("should return false if the address doesn't pertain to the signature & data", async () => {
+            const validUnrelatedAddress = '0x8b0292b11a196601ed2ce54b665cafeca0347d42';
+            expect(ZeroEx.isValidSignature(dataHex, signature, validUnrelatedAddress)).to.be.false();
+            return expect(
+                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(
+                    dataHex,
+                    signature,
+                    validUnrelatedAddress,
+                ),
+            ).to.become(false);
+        });
+        it("should return false if the signature doesn't pertain to the dataHex & address", async () => {
+            const wrongSignature = _.assign({}, signature, { v: 28 });
+            expect(ZeroEx.isValidSignature(dataHex, wrongSignature, address)).to.be.false();
+            return expect(
+                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, wrongSignature, address),
+            ).to.become(false);
+        });
+        it('should return true if the signature does pertain to the dataHex & address', async () => {
+            const isValidSignatureLocal = ZeroEx.isValidSignature(dataHex, signature, address);
+            expect(isValidSignatureLocal).to.be.true();
+            return expect(
+                (zeroEx.exchange as any)._isValidSignatureUsingContractCallAsync(dataHex, signature, address),
+            ).to.become(true);
+        });
+    });
+    describe('#generateSalt', () => {
+        it('generates different salts', () => {
+            const equal = ZeroEx.generatePseudoRandomSalt().eq(ZeroEx.generatePseudoRandomSalt());
+            expect(equal).to.be.false();
+        });
+        it('generates salt in range [0..2^256)', () => {
+            const salt = ZeroEx.generatePseudoRandomSalt();
+            expect(salt.greaterThanOrEqualTo(0)).to.be.true();
+            const twoPow256 = new BigNumber(2).pow(256);
+            expect(salt.lessThan(twoPow256)).to.be.true();
+        });
+    });
+    describe('#isValidOrderHash', () => {
+        it('returns false if the value is not a hex string', () => {
+            const isValid = ZeroEx.isValidOrderHash('not a hex');
+            expect(isValid).to.be.false();
+        });
+        it('returns false if the length is wrong', () => {
+            const isValid = ZeroEx.isValidOrderHash('0xdeadbeef');
+            expect(isValid).to.be.false();
+        });
+        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 throw if invalid baseUnit amount supplied as argument', () => {
+            const invalidBaseUnitAmount = new BigNumber(1000000000.4);
+            const decimals = 6;
+            expect(() => ZeroEx.toUnitAmount(invalidBaseUnitAmount, decimals)).to.throw(
+                'amount should be in baseUnits (no decimals), found value: 1000000000.4',
+            );
+        });
+        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);
+        });
+        it('should throw if unitAmount has more decimals then specified as the max decimal precision', () => {
+            const unitAmount = new BigNumber(0.823091);
+            const decimals = 5;
+            expect(() => ZeroEx.toBaseUnitAmount(unitAmount, decimals)).to.throw(
+                'Invalid unit amount: 0.823091 - Too many decimal places',
+            );
+        });
+    });
+    describe('#getOrderHashHex', () => {
+        const expectedOrderHash = '0x39da987067a3c9e5f1617694f1301326ba8c8b0498ebef5df4863bed394e3c83';
+        const fakeExchangeContractAddress = '0xb69e673309512a9d726f87304c6984054f87a93b';
+        const order: Order = {
+            maker: constants.NULL_ADDRESS,
+            taker: constants.NULL_ADDRESS,
+            feeRecipient: constants.NULL_ADDRESS,
+            makerTokenAddress: constants.NULL_ADDRESS,
+            takerTokenAddress: constants.NULL_ADDRESS,
+            exchangeContractAddress: fakeExchangeContractAddress,
+            salt: new BigNumber(0),
+            makerFee: new BigNumber(0),
+            takerFee: new BigNumber(0),
+            makerTokenAmount: new BigNumber(0),
+            takerTokenAmount: new BigNumber(0),
+            expirationUnixTimestampSec: new BigNumber(0),
+        };
+        it('calculates the order hash', async () => {
+            const orderHash = ZeroEx.getOrderHashHex(order);
+            expect(orderHash).to.be.equal(expectedOrderHash);
+        });
+        it('throws a readable error message if taker format is invalid', async () => {
+            const orderWithInvalidtakerFormat = {
+                ...order,
+                taker: (null as any) as string,
+            };
+            const expectedErrorMessage =
+                'Order taker must be of type string. If you want anyone to be able to fill an order - pass ZeroEx.NULL_ADDRESS';
+            expect(() => ZeroEx.getOrderHashHex(orderWithInvalidtakerFormat)).to.throw(expectedErrorMessage);
+        });
+    });
+    describe('#signOrderHashAsync', () => {
+        let stubs: Sinon.SinonStub[] = [];
+        let makerAddress: string;
+        before(async () => {
+            const availableAddreses = await zeroEx.getAvailableAddressesAsync();
+            makerAddress = availableAddreses[0];
+        });
+        afterEach(() => {
+            // clean up any stubs after the test has completed
+            _.each(stubs, s => s.restore());
+            stubs = [];
+        });
+        it('Should return the correct ECSignature', async () => {
+            const orderHash = '0x6927e990021d23b1eb7b8789f6a6feaf98fe104bb0cf8259421b79f9a34222b0';
+            const expectedECSignature = {
+                v: 27,
+                r: '0x61a3ed31b43c8780e905a260a35faefcc527be7516aa11c0256729b5b351bc33',
+                s: '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
+            };
+            const ecSignature = await zeroEx.signOrderHashAsync(
+                orderHash,
+                makerAddress,
+                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
+            );
+            expect(ecSignature).to.deep.equal(expectedECSignature);
+        });
+        it('should return the correct ECSignature for signatureHex concatenated as R + S + V', async () => {
+            const orderHash = '0x34decbedc118904df65f379a175bb39ca18209d6ce41d5ed549d54e6e0a95004';
+            const signature =
+                '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb021b';
+            const expectedECSignature = {
+                v: 27,
+                r: '0x22109d11d79cb8bf96ed88625e1cd9558800c4073332a9a02857499883ee5ce3',
+                s: '0x050aa3cc1f2c435e67e114cdce54b9527b4f50548342401bc5d2b77adbdacb02',
+            };
+            stubs = [
+                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
+                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
+            ];
 
-			const ecSignature = await zeroEx.signOrderHashAsync(
-				orderHash,
-				makerAddress,
-				SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-			);
-			expect(ecSignature).to.deep.equal(expectedECSignature);
-		});
-		it('should return the correct ECSignature for signatureHex concatenated as V + R + S', async () => {
-			const orderHash = '0xc793e33ffded933b76f2f48d9aa3339fc090399d5e7f5dec8d3660f5480793f7';
-			const signature =
-				'0x1bc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee02dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960';
-			const expectedECSignature = {
-				v: 27,
-				r: '0xc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee0',
-				s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
-			};
-			stubs = [
-				Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
-				Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
-			];
+            const ecSignature = await zeroEx.signOrderHashAsync(
+                orderHash,
+                makerAddress,
+                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
+            );
+            expect(ecSignature).to.deep.equal(expectedECSignature);
+        });
+        it('should return the correct ECSignature for signatureHex concatenated as V + R + S', async () => {
+            const orderHash = '0xc793e33ffded933b76f2f48d9aa3339fc090399d5e7f5dec8d3660f5480793f7';
+            const signature =
+                '0x1bc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee02dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960';
+            const expectedECSignature = {
+                v: 27,
+                r: '0xc80bedc6756722672753413efdd749b5adbd4fd552595f59c13427407ee9aee0',
+                s: '0x2dea66f25a608bbae457e020fb6decb763deb8b7192abab624997242da248960',
+            };
+            stubs = [
+                Sinon.stub((zeroEx as any)._web3Wrapper, 'signTransactionAsync').returns(Promise.resolve(signature)),
+                Sinon.stub(ZeroEx, 'isValidSignature').returns(true),
+            ];
 
-			const ecSignature = await zeroEx.signOrderHashAsync(
-				orderHash,
-				makerAddress,
-				SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
-			);
-			expect(ecSignature).to.deep.equal(expectedECSignature);
-		});
-	});
-	describe('#awaitTransactionMinedAsync', () => {
-		beforeEach(async () => {
-			await blockchainLifecycle.startAsync();
-		});
-		afterEach(async () => {
-			await blockchainLifecycle.revertAsync();
-		});
-		it('returns transaction receipt with decoded logs', async () => {
-			const availableAddresses = await zeroEx.getAvailableAddressesAsync();
-			const coinbase = availableAddresses[0];
-			const tokens = await zeroEx.tokenRegistry.getTokensAsync();
-			const tokenUtils = new TokenUtils(tokens);
-			const zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-			const proxyAddress = zeroEx.proxy.getContractAddress();
-			const txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
-			const txReceiptWithDecodedLogs = await zeroEx.awaitTransactionMinedAsync(txHash);
-			const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ApprovalContractEventArgs>;
-			expect(log.event).to.be.equal(TokenEvents.Approval);
-			expect(log.args._owner).to.be.equal(coinbase);
-			expect(log.args._spender).to.be.equal(proxyAddress);
-			expect(log.args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-	});
-	describe('#config', () => {
-		it('allows to specify exchange contract address', async () => {
-			const zeroExConfig = {
-				exchangeContractAddress: ZeroEx.NULL_ADDRESS,
-				networkId: constants.TESTRPC_NETWORK_ID,
-			};
-			const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-			expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
-		});
-		it('allows to specify token registry token contract address', async () => {
-			const zeroExConfig = {
-				tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
-				networkId: constants.TESTRPC_NETWORK_ID,
-			};
-			const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
-			expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
-				ZeroEx.NULL_ADDRESS,
-			);
-		});
-	});
+            const ecSignature = await zeroEx.signOrderHashAsync(
+                orderHash,
+                makerAddress,
+                SHOULD_ADD_PERSONAL_MESSAGE_PREFIX,
+            );
+            expect(ecSignature).to.deep.equal(expectedECSignature);
+        });
+    });
+    describe('#awaitTransactionMinedAsync', () => {
+        beforeEach(async () => {
+            await blockchainLifecycle.startAsync();
+        });
+        afterEach(async () => {
+            await blockchainLifecycle.revertAsync();
+        });
+        it('returns transaction receipt with decoded logs', async () => {
+            const availableAddresses = await zeroEx.getAvailableAddressesAsync();
+            const coinbase = availableAddresses[0];
+            const tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            const tokenUtils = new TokenUtils(tokens);
+            const zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+            const proxyAddress = zeroEx.proxy.getContractAddress();
+            const txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(zrxTokenAddress, coinbase);
+            const txReceiptWithDecodedLogs = await zeroEx.awaitTransactionMinedAsync(txHash);
+            const log = txReceiptWithDecodedLogs.logs[0] as LogWithDecodedArgs<ApprovalContractEventArgs>;
+            expect(log.event).to.be.equal(TokenEvents.Approval);
+            expect(log.args._owner).to.be.equal(coinbase);
+            expect(log.args._spender).to.be.equal(proxyAddress);
+            expect(log.args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+    });
+    describe('#config', () => {
+        it('allows to specify exchange contract address', async () => {
+            const zeroExConfig = {
+                exchangeContractAddress: ZeroEx.NULL_ADDRESS,
+                networkId: constants.TESTRPC_NETWORK_ID,
+            };
+            const zeroExWithWrongExchangeAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
+            expect(zeroExWithWrongExchangeAddress.exchange.getContractAddress()).to.be.equal(ZeroEx.NULL_ADDRESS);
+        });
+        it('allows to specify token registry token contract address', async () => {
+            const zeroExConfig = {
+                tokenRegistryContractAddress: ZeroEx.NULL_ADDRESS,
+                networkId: constants.TESTRPC_NETWORK_ID,
+            };
+            const zeroExWithWrongTokenRegistryAddress = new ZeroEx(web3.currentProvider, zeroExConfig);
+            expect(zeroExWithWrongTokenRegistryAddress.tokenRegistry.getContractAddress()).to.be.equal(
+                ZeroEx.NULL_ADDRESS,
+            );
+        });
+    });
 });
diff --git a/packages/0x.js/test/artifacts_test.ts b/packages/0x.js/test/artifacts_test.ts
index 3a791f436..e8ab9aa97 100644
--- a/packages/0x.js/test/artifacts_test.ts
+++ b/packages/0x.js/test/artifacts_test.ts
@@ -12,44 +12,44 @@ chaiSetup.configure();
 const TIMEOUT = 10000;
 
 describe('Artifacts', () => {
-	describe('contracts are deployed on kovan', () => {
-		const kovanRpcUrl = constants.KOVAN_RPC_URL;
-		const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
-		const packageJSON = JSON.parse(packageJSONContent);
-		const mnemonic = packageJSON.config.mnemonic;
-		const web3Provider = new HDWalletProvider(mnemonic, kovanRpcUrl);
-		const config = {
-			networkId: constants.KOVAN_NETWORK_ID,
-		};
-		const zeroEx = new ZeroEx(web3Provider, config);
-		it('token registry contract is deployed', async () => {
-			await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-		}).timeout(TIMEOUT);
-		it('proxy contract is deployed', async () => {
-			await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
-		}).timeout(TIMEOUT);
-		it('exchange contract is deployed', async () => {
-			await (zeroEx.exchange as any)._getExchangeContractAsync();
-		}).timeout(TIMEOUT);
-	});
-	describe('contracts are deployed on ropsten', () => {
-		const ropstenRpcUrl = constants.ROPSTEN_RPC_URL;
-		const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
-		const packageJSON = JSON.parse(packageJSONContent);
-		const mnemonic = packageJSON.config.mnemonic;
-		const web3Provider = new HDWalletProvider(mnemonic, ropstenRpcUrl);
-		const config = {
-			networkId: constants.ROPSTEN_NETWORK_ID,
-		};
-		const zeroEx = new ZeroEx(web3Provider, config);
-		it('token registry contract is deployed', async () => {
-			await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
-		}).timeout(TIMEOUT);
-		it('proxy contract is deployed', async () => {
-			await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
-		}).timeout(TIMEOUT);
-		it('exchange contract is deployed', async () => {
-			await (zeroEx.exchange as any)._getExchangeContractAsync();
-		}).timeout(TIMEOUT);
-	});
+    describe('contracts are deployed on kovan', () => {
+        const kovanRpcUrl = constants.KOVAN_RPC_URL;
+        const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
+        const packageJSON = JSON.parse(packageJSONContent);
+        const mnemonic = packageJSON.config.mnemonic;
+        const web3Provider = new HDWalletProvider(mnemonic, kovanRpcUrl);
+        const config = {
+            networkId: constants.KOVAN_NETWORK_ID,
+        };
+        const zeroEx = new ZeroEx(web3Provider, config);
+        it('token registry contract is deployed', async () => {
+            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
+        }).timeout(TIMEOUT);
+        it('proxy contract is deployed', async () => {
+            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
+        }).timeout(TIMEOUT);
+        it('exchange contract is deployed', async () => {
+            await (zeroEx.exchange as any)._getExchangeContractAsync();
+        }).timeout(TIMEOUT);
+    });
+    describe('contracts are deployed on ropsten', () => {
+        const ropstenRpcUrl = constants.ROPSTEN_RPC_URL;
+        const packageJSONContent = fs.readFileSync('package.json', 'utf-8');
+        const packageJSON = JSON.parse(packageJSONContent);
+        const mnemonic = packageJSON.config.mnemonic;
+        const web3Provider = new HDWalletProvider(mnemonic, ropstenRpcUrl);
+        const config = {
+            networkId: constants.ROPSTEN_NETWORK_ID,
+        };
+        const zeroEx = new ZeroEx(web3Provider, config);
+        it('token registry contract is deployed', async () => {
+            await (zeroEx.tokenRegistry as any)._getTokenRegistryContractAsync();
+        }).timeout(TIMEOUT);
+        it('proxy contract is deployed', async () => {
+            await (zeroEx.proxy as any)._getTokenTransferProxyContractAsync();
+        }).timeout(TIMEOUT);
+        it('exchange contract is deployed', async () => {
+            await (zeroEx.exchange as any)._getExchangeContractAsync();
+        }).timeout(TIMEOUT);
+    });
 });
diff --git a/packages/0x.js/test/assert_test.ts b/packages/0x.js/test/assert_test.ts
index 2c72a5e88..1f2820070 100644
--- a/packages/0x.js/test/assert_test.ts
+++ b/packages/0x.js/test/assert_test.ts
@@ -10,34 +10,34 @@ import { web3Factory } from './utils/web3_factory';
 const expect = chai.expect;
 
 describe('Assertion library', () => {
-	const web3 = web3Factory.create();
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	const zeroEx = new ZeroEx(web3.currentProvider, config);
-	describe('#isSenderAddressHexAsync', () => {
-		it('throws when address is invalid', async () => {
-			const address = '0xdeadbeef';
-			const varName = 'address';
-			return expect(
-				assert.isSenderAddressAsync(varName, address, (zeroEx as any)._web3Wrapper),
-			).to.be.rejectedWith(`Expected ${varName} to be of type ETHAddressHex, encountered: ${address}`);
-		});
-		it('throws when address is unavailable', async () => {
-			const validUnrelatedAddress = '0x8b0292b11a196601eddce54b665cafeca0347d42';
-			const varName = 'address';
-			return expect(
-				assert.isSenderAddressAsync(varName, validUnrelatedAddress, (zeroEx as any)._web3Wrapper),
-			).to.be.rejectedWith(
-				`Specified ${varName} ${validUnrelatedAddress} isn't available through the supplied web3 provider`,
-			);
-		});
-		it("doesn't throw if address is available", async () => {
-			const availableAddress = (await zeroEx.getAvailableAddressesAsync())[0];
-			const varName = 'address';
-			return expect(
-				assert.isSenderAddressAsync(varName, availableAddress, (zeroEx as any)._web3Wrapper),
-			).to.become(undefined);
-		});
-	});
+    const web3 = web3Factory.create();
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    describe('#isSenderAddressHexAsync', () => {
+        it('throws when address is invalid', async () => {
+            const address = '0xdeadbeef';
+            const varName = 'address';
+            return expect(
+                assert.isSenderAddressAsync(varName, address, (zeroEx as any)._web3Wrapper),
+            ).to.be.rejectedWith(`Expected ${varName} to be of type ETHAddressHex, encountered: ${address}`);
+        });
+        it('throws when address is unavailable', async () => {
+            const validUnrelatedAddress = '0x8b0292b11a196601eddce54b665cafeca0347d42';
+            const varName = 'address';
+            return expect(
+                assert.isSenderAddressAsync(varName, validUnrelatedAddress, (zeroEx as any)._web3Wrapper),
+            ).to.be.rejectedWith(
+                `Specified ${varName} ${validUnrelatedAddress} isn't available through the supplied web3 provider`,
+            );
+        });
+        it("doesn't throw if address is available", async () => {
+            const availableAddress = (await zeroEx.getAvailableAddressesAsync())[0];
+            const varName = 'address';
+            return expect(
+                assert.isSenderAddressAsync(varName, availableAddress, (zeroEx as any)._web3Wrapper),
+            ).to.become(undefined);
+        });
+    });
 });
diff --git a/packages/0x.js/test/ether_token_wrapper_test.ts b/packages/0x.js/test/ether_token_wrapper_test.ts
index 67e62dc12..b810fc9f1 100644
--- a/packages/0x.js/test/ether_token_wrapper_test.ts
+++ b/packages/0x.js/test/ether_token_wrapper_test.ts
@@ -5,17 +5,17 @@ import 'mocha';
 import * as Web3 from 'web3';
 
 import {
-	ApprovalContractEventArgs,
-	BlockParamLiteral,
-	BlockRange,
-	DecodedLogEvent,
-	DepositContractEventArgs,
-	EtherTokenEvents,
-	Token,
-	TransferContractEventArgs,
-	WithdrawalContractEventArgs,
-	ZeroEx,
-	ZeroExError,
+    ApprovalContractEventArgs,
+    BlockParamLiteral,
+    BlockRange,
+    DecodedLogEvent,
+    DepositContractEventArgs,
+    EtherTokenEvents,
+    Token,
+    TransferContractEventArgs,
+    WithdrawalContractEventArgs,
+    ZeroEx,
+    ZeroExError,
 } from '../src';
 import { artifacts } from '../src/artifacts';
 import { DoneCallback } from '../src/types';
@@ -37,339 +37,339 @@ const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 const MAX_REASONABLE_GAS_COST_IN_WEI = 62517;
 
 describe('EtherTokenWrapper', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let tokens: Token[];
-	let userAddresses: string[];
-	let addressWithETH: string;
-	let wethContractAddress: string;
-	let depositWeiAmount: BigNumber;
-	let decimalPlaces: number;
-	let addressWithoutFunds: string;
-	const gasPrice = new BigNumber(1);
-	const zeroExConfig = {
-		gasPrice,
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	const transferAmount = new BigNumber(42);
-	const allowanceAmount = new BigNumber(42);
-	const depositAmount = new BigNumber(42);
-	const withdrawalAmount = new BigNumber(42);
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, zeroExConfig);
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		addressWithETH = userAddresses[0];
-		wethContractAddress = (zeroEx.etherToken as any)._getContractAddress(artifacts.EtherTokenArtifact);
-		depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(new BigNumber(5));
-		decimalPlaces = 7;
-		addressWithoutFunds = userAddresses[1];
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#depositAsync', () => {
-		it('should successfully deposit ETH and issue Wrapped ETH tokens', async () => {
-			const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-			const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
-			expect(preETHBalance).to.be.bignumber.gt(0);
-			expect(preWETHBalance).to.be.bignumber.equal(0);
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let tokens: Token[];
+    let userAddresses: string[];
+    let addressWithETH: string;
+    let wethContractAddress: string;
+    let depositWeiAmount: BigNumber;
+    let decimalPlaces: number;
+    let addressWithoutFunds: string;
+    const gasPrice = new BigNumber(1);
+    const zeroExConfig = {
+        gasPrice,
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    const transferAmount = new BigNumber(42);
+    const allowanceAmount = new BigNumber(42);
+    const depositAmount = new BigNumber(42);
+    const withdrawalAmount = new BigNumber(42);
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, zeroExConfig);
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        addressWithETH = userAddresses[0];
+        wethContractAddress = (zeroEx.etherToken as any)._getContractAddress(artifacts.EtherTokenArtifact);
+        depositWeiAmount = (zeroEx as any)._web3Wrapper.toWei(new BigNumber(5));
+        decimalPlaces = 7;
+        addressWithoutFunds = userAddresses[1];
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#depositAsync', () => {
+        it('should successfully deposit ETH and issue Wrapped ETH tokens', async () => {
+            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            expect(preETHBalance).to.be.bignumber.gt(0);
+            expect(preWETHBalance).to.be.bignumber.equal(0);
 
-			const txHash = await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
+            const txHash = await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
 
-			const postETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-			const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const postETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
 
-			expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(depositWeiAmount);
-			const remainingETHInWei = preETHBalance.minus(depositWeiAmount);
-			const gasCost = remainingETHInWei.minus(postETHBalanceInWei);
-			expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
-		});
-		it('should throw if user has insufficient ETH balance for deposit', async () => {
-			const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(depositWeiAmount);
+            const remainingETHInWei = preETHBalance.minus(depositWeiAmount);
+            const gasCost = remainingETHInWei.minus(postETHBalanceInWei);
+            expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
+        });
+        it('should throw if user has insufficient ETH balance for deposit', async () => {
+            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
-			const extraETHBalance = (zeroEx as any)._web3Wrapper.toWei(5, 'ether');
-			const overETHBalanceinWei = preETHBalance.add(extraETHBalance);
+            const extraETHBalance = (zeroEx as any)._web3Wrapper.toWei(5, 'ether');
+            const overETHBalanceinWei = preETHBalance.add(extraETHBalance);
 
-			return expect(
-				zeroEx.etherToken.depositAsync(wethContractAddress, overETHBalanceinWei, addressWithETH),
-			).to.be.rejectedWith(ZeroExError.InsufficientEthBalanceForDeposit);
-		});
-	});
-	describe('#withdrawAsync', () => {
-		it('should successfully withdraw ETH in return for Wrapped ETH tokens', async () => {
-			const ETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            return expect(
+                zeroEx.etherToken.depositAsync(wethContractAddress, overETHBalanceinWei, addressWithETH),
+            ).to.be.rejectedWith(ZeroExError.InsufficientEthBalanceForDeposit);
+        });
+    });
+    describe('#withdrawAsync', () => {
+        it('should successfully withdraw ETH in return for Wrapped ETH tokens', async () => {
+            const ETHBalanceInWei = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
 
-			await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            await zeroEx.etherToken.depositAsync(wethContractAddress, depositWeiAmount, addressWithETH);
 
-			const expectedPreETHBalance = ETHBalanceInWei.minus(depositWeiAmount);
-			const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-			const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
-			let gasCost = expectedPreETHBalance.minus(preETHBalance);
-			expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
-			expect(preWETHBalance).to.be.bignumber.equal(depositWeiAmount);
+            const expectedPreETHBalance = ETHBalanceInWei.minus(depositWeiAmount);
+            const preETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            let gasCost = expectedPreETHBalance.minus(preETHBalance);
+            expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
+            expect(preWETHBalance).to.be.bignumber.equal(depositWeiAmount);
 
-			const txHash = await zeroEx.etherToken.withdrawAsync(wethContractAddress, depositWeiAmount, addressWithETH);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
+            const txHash = await zeroEx.etherToken.withdrawAsync(wethContractAddress, depositWeiAmount, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
 
-			const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
-			const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            const postETHBalance = await (zeroEx as any)._web3Wrapper.getBalanceInWeiAsync(addressWithETH);
+            const postWETHBalanceInBaseUnits = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
 
-			expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(0);
-			const expectedETHBalance = preETHBalance.add(depositWeiAmount).round(decimalPlaces);
-			gasCost = expectedETHBalance.minus(postETHBalance);
-			expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
-		});
-		it('should throw if user has insufficient WETH balance for withdrawl', async () => {
-			const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
-			expect(preWETHBalance).to.be.bignumber.equal(0);
+            expect(postWETHBalanceInBaseUnits).to.be.bignumber.equal(0);
+            const expectedETHBalance = preETHBalance.add(depositWeiAmount).round(decimalPlaces);
+            gasCost = expectedETHBalance.minus(postETHBalance);
+            expect(gasCost).to.be.bignumber.lte(MAX_REASONABLE_GAS_COST_IN_WEI);
+        });
+        it('should throw if user has insufficient WETH balance for withdrawl', async () => {
+            const preWETHBalance = await zeroEx.token.getBalanceAsync(wethContractAddress, addressWithETH);
+            expect(preWETHBalance).to.be.bignumber.equal(0);
 
-			const overWETHBalance = preWETHBalance.add(999999999);
+            const overWETHBalance = preWETHBalance.add(999999999);
 
-			return expect(
-				zeroEx.etherToken.withdrawAsync(wethContractAddress, overWETHBalance, addressWithETH),
-			).to.be.rejectedWith(ZeroExError.InsufficientWEthBalanceForWithdrawal);
-		});
-	});
-	describe('#subscribe', () => {
-		const indexFilterValues = {};
-		let etherTokenAddress: string;
-		before(() => {
-			const tokenUtils = new TokenUtils(tokens);
-			const etherToken = tokenUtils.getWethTokenOrThrow();
-			etherTokenAddress = etherToken.address;
-		});
-		afterEach(() => {
-			zeroEx.etherToken.unsubscribeAll();
-		});
-		// Hack: Mocha does not allow a test to be both async and have a `done` callback
-		// Since we need to await the receipt of the event in the `subscribe` callback,
-		// we do need both. A hack is to make the top-level async fn w/ a done callback and then
-		// wrap the rest of the test in an async block
-		// Source: https://github.com/mochajs/mocha/issues/2407
-		it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
-						expect(logEvent).to.not.be.undefined();
-						expect(logEvent.isRemoved).to.be.false();
-						expect(logEvent.log.logIndex).to.be.equal(0);
-						expect(logEvent.log.transactionIndex).to.be.equal(0);
-						expect(logEvent.log.blockNumber).to.be.a('number');
-						const args = logEvent.log.args;
-						expect(args._from).to.be.equal(addressWithETH);
-						expect(args._to).to.be.equal(addressWithoutFunds);
-						expect(args._value).to.be.bignumber.equal(transferAmount);
-					},
-				);
-				await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-				zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callback);
-				await zeroEx.token.transferAsync(
-					etherTokenAddress,
-					addressWithETH,
-					addressWithoutFunds,
-					transferAmount,
-				);
-			})().catch(done);
-		});
-		it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						expect(logEvent).to.not.be.undefined();
-						expect(logEvent.isRemoved).to.be.false();
-						const args = logEvent.log.args;
-						expect(args._owner).to.be.equal(addressWithETH);
-						expect(args._spender).to.be.equal(addressWithoutFunds);
-						expect(args._value).to.be.bignumber.equal(allowanceAmount);
-					},
-				);
-				zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Approval, indexFilterValues, callback);
-				await zeroEx.token.setAllowanceAsync(
-					etherTokenAddress,
-					addressWithETH,
-					addressWithoutFunds,
-					allowanceAmount,
-				);
-			})().catch(done);
-		});
-		it('Should receive the Deposit event when ether is being deposited', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<DepositContractEventArgs>) => {
-						expect(logEvent).to.not.be.undefined();
-						expect(logEvent.isRemoved).to.be.false();
-						const args = logEvent.log.args;
-						expect(args._owner).to.be.equal(addressWithETH);
-						expect(args._value).to.be.bignumber.equal(depositAmount);
-					},
-				);
-				zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Deposit, indexFilterValues, callback);
-				await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-			})().catch(done);
-		});
-		it('Should receive the Withdrawal event when ether is being withdrawn', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<WithdrawalContractEventArgs>) => {
-						expect(logEvent).to.not.be.undefined();
-						expect(logEvent.isRemoved).to.be.false();
-						const args = logEvent.log.args;
-						expect(args._owner).to.be.equal(addressWithETH);
-						expect(args._value).to.be.bignumber.equal(depositAmount);
-					},
-				);
-				await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-				zeroEx.etherToken.subscribe(
-					etherTokenAddress,
-					EtherTokenEvents.Withdrawal,
-					indexFilterValues,
-					callback,
-				);
-				await zeroEx.etherToken.withdrawAsync(etherTokenAddress, withdrawalAmount, addressWithETH);
-			})().catch(done);
-		});
-		it('should cancel outstanding subscriptions when ZeroEx.setProvider is called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				zeroEx.etherToken.subscribe(
-					etherTokenAddress,
-					EtherTokenEvents.Transfer,
-					indexFilterValues,
-					callbackNeverToBeCalled,
-				);
-				const callbackToBeCalled = reportNodeCallbackErrors(done)();
-				const newProvider = web3Factory.getRpcProvider();
-				zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
-				await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-				zeroEx.etherToken.subscribe(
-					etherTokenAddress,
-					EtherTokenEvents.Transfer,
-					indexFilterValues,
-					callbackToBeCalled,
-				);
-				await zeroEx.token.transferAsync(
-					etherTokenAddress,
-					addressWithETH,
-					addressWithoutFunds,
-					transferAmount,
-				);
-			})().catch(done);
-		});
-		it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
-				const subscriptionToken = zeroEx.etherToken.subscribe(
-					etherTokenAddress,
-					EtherTokenEvents.Transfer,
-					indexFilterValues,
-					callbackNeverToBeCalled,
-				);
-				zeroEx.etherToken.unsubscribe(subscriptionToken);
-				await zeroEx.token.transferAsync(
-					etherTokenAddress,
-					addressWithETH,
-					addressWithoutFunds,
-					transferAmount,
-				);
-				done();
-			})().catch(done);
-		});
-	});
-	describe('#getLogsAsync', () => {
-		let etherTokenAddress: string;
-		let tokenTransferProxyAddress: string;
-		const blockRange: BlockRange = {
-			fromBlock: 0,
-			toBlock: BlockParamLiteral.Latest,
-		};
-		let txHash: string;
-		before(() => {
-			addressWithETH = userAddresses[0];
-			const tokenUtils = new TokenUtils(tokens);
-			const etherToken = tokenUtils.getWethTokenOrThrow();
-			etherTokenAddress = etherToken.address;
-			tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
-		});
-		it('should get logs with decoded args emitted by Approval', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const eventName = EtherTokenEvents.Approval;
-			const indexFilterValues = {};
-			const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
-				etherTokenAddress,
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(logs[0].event).to.be.equal(eventName);
-			expect(args._owner).to.be.equal(addressWithETH);
-			expect(args._spender).to.be.equal(tokenTransferProxyAddress);
-			expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-		it('should get logs with decoded args emitted by Deposit', async () => {
-			await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
-			const eventName = EtherTokenEvents.Deposit;
-			const indexFilterValues = {};
-			const logs = await zeroEx.etherToken.getLogsAsync<DepositContractEventArgs>(
-				etherTokenAddress,
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(logs[0].event).to.be.equal(eventName);
-			expect(args._owner).to.be.equal(addressWithETH);
-			expect(args._value).to.be.bignumber.equal(depositAmount);
-		});
-		it('should only get the logs with the correct event name', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const differentEventName = EtherTokenEvents.Transfer;
-			const indexFilterValues = {};
-			const logs = await zeroEx.etherToken.getLogsAsync(
-				etherTokenAddress,
-				differentEventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(0);
-		});
-		it('should only get the logs with the correct indexed fields', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithoutFunds);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const eventName = EtherTokenEvents.Approval;
-			const indexFilterValues = {
-				_owner: addressWithETH,
-			};
-			const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
-				etherTokenAddress,
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(args._owner).to.be.equal(addressWithETH);
-		});
-	});
+            return expect(
+                zeroEx.etherToken.withdrawAsync(wethContractAddress, overWETHBalance, addressWithETH),
+            ).to.be.rejectedWith(ZeroExError.InsufficientWEthBalanceForWithdrawal);
+        });
+    });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        let etherTokenAddress: string;
+        before(() => {
+            const tokenUtils = new TokenUtils(tokens);
+            const etherToken = tokenUtils.getWethTokenOrThrow();
+            etherTokenAddress = etherToken.address;
+        });
+        afterEach(() => {
+            zeroEx.etherToken.unsubscribeAll();
+        });
+        // Hack: Mocha does not allow a test to be both async and have a `done` callback
+        // Since we need to await the receipt of the event in the `subscribe` callback,
+        // we do need both. A hack is to make the top-level async fn w/ a done callback and then
+        // wrap the rest of the test in an async block
+        // Source: https://github.com/mochajs/mocha/issues/2407
+        it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
+                        expect(logEvent).to.not.be.undefined();
+                        expect(logEvent.isRemoved).to.be.false();
+                        expect(logEvent.log.logIndex).to.be.equal(0);
+                        expect(logEvent.log.transactionIndex).to.be.equal(0);
+                        expect(logEvent.log.blockNumber).to.be.a('number');
+                        const args = logEvent.log.args;
+                        expect(args._from).to.be.equal(addressWithETH);
+                        expect(args._to).to.be.equal(addressWithoutFunds);
+                        expect(args._value).to.be.bignumber.equal(transferAmount);
+                    },
+                );
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Transfer, indexFilterValues, callback);
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress,
+                    addressWithETH,
+                    addressWithoutFunds,
+                    transferAmount,
+                );
+            })().catch(done);
+        });
+        it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        expect(logEvent).to.not.be.undefined();
+                        expect(logEvent.isRemoved).to.be.false();
+                        const args = logEvent.log.args;
+                        expect(args._owner).to.be.equal(addressWithETH);
+                        expect(args._spender).to.be.equal(addressWithoutFunds);
+                        expect(args._value).to.be.bignumber.equal(allowanceAmount);
+                    },
+                );
+                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(
+                    etherTokenAddress,
+                    addressWithETH,
+                    addressWithoutFunds,
+                    allowanceAmount,
+                );
+            })().catch(done);
+        });
+        it('Should receive the Deposit event when ether is being deposited', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<DepositContractEventArgs>) => {
+                        expect(logEvent).to.not.be.undefined();
+                        expect(logEvent.isRemoved).to.be.false();
+                        const args = logEvent.log.args;
+                        expect(args._owner).to.be.equal(addressWithETH);
+                        expect(args._value).to.be.bignumber.equal(depositAmount);
+                    },
+                );
+                zeroEx.etherToken.subscribe(etherTokenAddress, EtherTokenEvents.Deposit, indexFilterValues, callback);
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+            })().catch(done);
+        });
+        it('Should receive the Withdrawal event when ether is being withdrawn', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<WithdrawalContractEventArgs>) => {
+                        expect(logEvent).to.not.be.undefined();
+                        expect(logEvent.isRemoved).to.be.false();
+                        const args = logEvent.log.args;
+                        expect(args._owner).to.be.equal(addressWithETH);
+                        expect(args._value).to.be.bignumber.equal(depositAmount);
+                    },
+                );
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Withdrawal,
+                    indexFilterValues,
+                    callback,
+                );
+                await zeroEx.etherToken.withdrawAsync(etherTokenAddress, withdrawalAmount, addressWithETH);
+            })().catch(done);
+        });
+        it('should cancel outstanding subscriptions when ZeroEx.setProvider is called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Transfer,
+                    indexFilterValues,
+                    callbackNeverToBeCalled,
+                );
+                const callbackToBeCalled = reportNodeCallbackErrors(done)();
+                const newProvider = web3Factory.getRpcProvider();
+                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                zeroEx.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Transfer,
+                    indexFilterValues,
+                    callbackToBeCalled,
+                );
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress,
+                    addressWithETH,
+                    addressWithoutFunds,
+                    transferAmount,
+                );
+            })().catch(done);
+        });
+        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                await zeroEx.etherToken.depositAsync(etherTokenAddress, transferAmount, addressWithETH);
+                const subscriptionToken = zeroEx.etherToken.subscribe(
+                    etherTokenAddress,
+                    EtherTokenEvents.Transfer,
+                    indexFilterValues,
+                    callbackNeverToBeCalled,
+                );
+                zeroEx.etherToken.unsubscribe(subscriptionToken);
+                await zeroEx.token.transferAsync(
+                    etherTokenAddress,
+                    addressWithETH,
+                    addressWithoutFunds,
+                    transferAmount,
+                );
+                done();
+            })().catch(done);
+        });
+    });
+    describe('#getLogsAsync', () => {
+        let etherTokenAddress: string;
+        let tokenTransferProxyAddress: string;
+        const blockRange: BlockRange = {
+            fromBlock: 0,
+            toBlock: BlockParamLiteral.Latest,
+        };
+        let txHash: string;
+        before(() => {
+            addressWithETH = userAddresses[0];
+            const tokenUtils = new TokenUtils(tokens);
+            const etherToken = tokenUtils.getWethTokenOrThrow();
+            etherTokenAddress = etherToken.address;
+            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
+        });
+        it('should get logs with decoded args emitted by Approval', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = EtherTokenEvents.Approval;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+                etherTokenAddress,
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(logs[0].event).to.be.equal(eventName);
+            expect(args._owner).to.be.equal(addressWithETH);
+            expect(args._spender).to.be.equal(tokenTransferProxyAddress);
+            expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+        it('should get logs with decoded args emitted by Deposit', async () => {
+            await zeroEx.etherToken.depositAsync(etherTokenAddress, depositAmount, addressWithETH);
+            const eventName = EtherTokenEvents.Deposit;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync<DepositContractEventArgs>(
+                etherTokenAddress,
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(logs[0].event).to.be.equal(eventName);
+            expect(args._owner).to.be.equal(addressWithETH);
+            expect(args._value).to.be.bignumber.equal(depositAmount);
+        });
+        it('should only get the logs with the correct event name', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const differentEventName = EtherTokenEvents.Transfer;
+            const indexFilterValues = {};
+            const logs = await zeroEx.etherToken.getLogsAsync(
+                etherTokenAddress,
+                differentEventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(0);
+        });
+        it('should only get the logs with the correct indexed fields', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithETH);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(etherTokenAddress, addressWithoutFunds);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = EtherTokenEvents.Approval;
+            const indexFilterValues = {
+                _owner: addressWithETH,
+            };
+            const logs = await zeroEx.etherToken.getLogsAsync<ApprovalContractEventArgs>(
+                etherTokenAddress,
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(args._owner).to.be.equal(addressWithETH);
+        });
+    });
 });
diff --git a/packages/0x.js/test/event_watcher_test.ts b/packages/0x.js/test/event_watcher_test.ts
index f0c97eced..f92fb2b02 100644
--- a/packages/0x.js/test/event_watcher_test.ts
+++ b/packages/0x.js/test/event_watcher_test.ts
@@ -17,110 +17,110 @@ chaiSetup.configure();
 const expect = chai.expect;
 
 describe('EventWatcher', () => {
-	let web3: Web3;
-	let stubs: Sinon.SinonStub[] = [];
-	let eventWatcher: EventWatcher;
-	let web3Wrapper: Web3Wrapper;
-	const logA: Web3.LogEntry = {
-		address: '0x71d271f8b14adef568f8f28f1587ce7271ac4ca5',
-		blockHash: null,
-		blockNumber: null,
-		data: '',
-		logIndex: null,
-		topics: [],
-		transactionHash: '0x004881d38cd4a8f72f1a0d68c8b9b8124504706041ff37019c1d1ed6bfda8e17',
-		transactionIndex: 0,
-	};
-	const logB: Web3.LogEntry = {
-		address: '0x8d12a197cb00d4747a1fe03395095ce2a5cc6819',
-		blockHash: null,
-		blockNumber: null,
-		data: '',
-		logIndex: null,
-		topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
-		transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
-		transactionIndex: 0,
-	};
-	const logC: Web3.LogEntry = {
-		address: '0x1d271f8b174adef58f1587ce68f8f27271ac4ca5',
-		blockHash: null,
-		blockNumber: null,
-		data: '',
-		logIndex: null,
-		topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
-		transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
-		transactionIndex: 0,
-	};
-	before(async () => {
-		web3 = web3Factory.create();
-		const pollingIntervalMs = 10;
-		web3Wrapper = new Web3Wrapper(web3.currentProvider);
-		eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalMs);
-	});
-	afterEach(() => {
-		// clean up any stubs after the test has completed
-		_.each(stubs, s => s.restore());
-		stubs = [];
-		eventWatcher.unsubscribe();
-	});
-	it('correctly emits initial log events', (done: DoneCallback) => {
-		const logs: Web3.LogEntry[] = [logA, logB];
-		const expectedLogEvents = [
-			{
-				removed: false,
-				...logA,
-			},
-			{
-				removed: false,
-				...logB,
-			},
-		];
-		const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
-		getLogsStub.onCall(0).returns(logs);
-		stubs.push(getLogsStub);
-		const expectedToBeCalledOnce = false;
-		const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
-			const expectedLogEvent = expectedLogEvents.shift();
-			expect(event).to.be.deep.equal(expectedLogEvent);
-			if (_.isEmpty(expectedLogEvents)) {
-				done();
-			}
-		});
-		eventWatcher.subscribe(callback);
-	});
-	it('correctly computes the difference and emits only changes', (done: DoneCallback) => {
-		const initialLogs: Web3.LogEntry[] = [logA, logB];
-		const changedLogs: Web3.LogEntry[] = [logA, logC];
-		const expectedLogEvents = [
-			{
-				removed: false,
-				...logA,
-			},
-			{
-				removed: false,
-				...logB,
-			},
-			{
-				removed: true,
-				...logB,
-			},
-			{
-				removed: false,
-				...logC,
-			},
-		];
-		const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
-		getLogsStub.onCall(0).returns(initialLogs);
-		getLogsStub.onCall(1).returns(changedLogs);
-		stubs.push(getLogsStub);
-		const expectedToBeCalledOnce = false;
-		const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
-			const expectedLogEvent = expectedLogEvents.shift();
-			expect(event).to.be.deep.equal(expectedLogEvent);
-			if (_.isEmpty(expectedLogEvents)) {
-				done();
-			}
-		});
-		eventWatcher.subscribe(callback);
-	});
+    let web3: Web3;
+    let stubs: Sinon.SinonStub[] = [];
+    let eventWatcher: EventWatcher;
+    let web3Wrapper: Web3Wrapper;
+    const logA: Web3.LogEntry = {
+        address: '0x71d271f8b14adef568f8f28f1587ce7271ac4ca5',
+        blockHash: null,
+        blockNumber: null,
+        data: '',
+        logIndex: null,
+        topics: [],
+        transactionHash: '0x004881d38cd4a8f72f1a0d68c8b9b8124504706041ff37019c1d1ed6bfda8e17',
+        transactionIndex: 0,
+    };
+    const logB: Web3.LogEntry = {
+        address: '0x8d12a197cb00d4747a1fe03395095ce2a5cc6819',
+        blockHash: null,
+        blockNumber: null,
+        data: '',
+        logIndex: null,
+        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
+        transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
+        transactionIndex: 0,
+    };
+    const logC: Web3.LogEntry = {
+        address: '0x1d271f8b174adef58f1587ce68f8f27271ac4ca5',
+        blockHash: null,
+        blockNumber: null,
+        data: '',
+        logIndex: null,
+        topics: ['0xf341246adaac6f497bc2a656f546ab9e182111d630394f0c57c710a59a2cb567'],
+        transactionHash: '0x01ef3c048b18d9b09ea195b4ed94cf8dd5f3d857a1905ff886b152cfb1166f25',
+        transactionIndex: 0,
+    };
+    before(async () => {
+        web3 = web3Factory.create();
+        const pollingIntervalMs = 10;
+        web3Wrapper = new Web3Wrapper(web3.currentProvider);
+        eventWatcher = new EventWatcher(web3Wrapper, pollingIntervalMs);
+    });
+    afterEach(() => {
+        // clean up any stubs after the test has completed
+        _.each(stubs, s => s.restore());
+        stubs = [];
+        eventWatcher.unsubscribe();
+    });
+    it('correctly emits initial log events', (done: DoneCallback) => {
+        const logs: Web3.LogEntry[] = [logA, logB];
+        const expectedLogEvents = [
+            {
+                removed: false,
+                ...logA,
+            },
+            {
+                removed: false,
+                ...logB,
+            },
+        ];
+        const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
+        getLogsStub.onCall(0).returns(logs);
+        stubs.push(getLogsStub);
+        const expectedToBeCalledOnce = false;
+        const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
+            const expectedLogEvent = expectedLogEvents.shift();
+            expect(event).to.be.deep.equal(expectedLogEvent);
+            if (_.isEmpty(expectedLogEvents)) {
+                done();
+            }
+        });
+        eventWatcher.subscribe(callback);
+    });
+    it('correctly computes the difference and emits only changes', (done: DoneCallback) => {
+        const initialLogs: Web3.LogEntry[] = [logA, logB];
+        const changedLogs: Web3.LogEntry[] = [logA, logC];
+        const expectedLogEvents = [
+            {
+                removed: false,
+                ...logA,
+            },
+            {
+                removed: false,
+                ...logB,
+            },
+            {
+                removed: true,
+                ...logB,
+            },
+            {
+                removed: false,
+                ...logC,
+            },
+        ];
+        const getLogsStub = Sinon.stub(web3Wrapper, 'getLogsAsync');
+        getLogsStub.onCall(0).returns(initialLogs);
+        getLogsStub.onCall(1).returns(changedLogs);
+        stubs.push(getLogsStub);
+        const expectedToBeCalledOnce = false;
+        const callback = reportNodeCallbackErrors(done, expectedToBeCalledOnce)((event: LogEvent) => {
+            const expectedLogEvent = expectedLogEvents.shift();
+            expect(event).to.be.deep.equal(expectedLogEvent);
+            if (_.isEmpty(expectedLogEvents)) {
+                done();
+            }
+        });
+        eventWatcher.subscribe(callback);
+    });
 });
diff --git a/packages/0x.js/test/exchange_transfer_simulator_test.ts b/packages/0x.js/test/exchange_transfer_simulator_test.ts
index 9f4d76933..20b4a05ca 100644
--- a/packages/0x.js/test/exchange_transfer_simulator_test.ts
+++ b/packages/0x.js/test/exchange_transfer_simulator_test.ts
@@ -15,103 +15,103 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 
 describe('ExchangeTransferSimulator', () => {
-	const web3 = web3Factory.create();
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	const zeroEx = new ZeroEx(web3.currentProvider, config);
-	const transferAmount = new BigNumber(5);
-	let userAddresses: string[];
-	let tokens: Token[];
-	let coinbase: string;
-	let sender: string;
-	let recipient: string;
-	let exampleTokenAddress: string;
-	let exchangeTransferSimulator: ExchangeTransferSimulator;
-	let txHash: string;
-	before(async () => {
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		[coinbase, sender, recipient] = userAddresses;
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		exampleTokenAddress = tokens[0].address;
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#transferFromAsync', () => {
-		beforeEach(() => {
-			exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
-		});
-		it("throws if the user doesn't have enough allowance", async () => {
-			return expect(
-				exchangeTransferSimulator.transferFromAsync(
-					exampleTokenAddress,
-					sender,
-					recipient,
-					transferAmount,
-					TradeSide.Taker,
-					TransferType.Trade,
-				),
-			).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
-		});
-		it("throws if the user doesn't have enough balance", async () => {
-			txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			return expect(
-				exchangeTransferSimulator.transferFromAsync(
-					exampleTokenAddress,
-					sender,
-					recipient,
-					transferAmount,
-					TradeSide.Maker,
-					TransferType.Trade,
-				),
-			).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
-		});
-		it('updates balances and proxyAllowance after transfer', async () => {
-			txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			await exchangeTransferSimulator.transferFromAsync(
-				exampleTokenAddress,
-				sender,
-				recipient,
-				transferAmount,
-				TradeSide.Taker,
-				TransferType.Trade,
-			);
-			const store = (exchangeTransferSimulator as any)._store;
-			const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
-			const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
-			const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
-			expect(senderBalance).to.be.bignumber.equal(0);
-			expect(recipientBalance).to.be.bignumber.equal(transferAmount);
-			expect(senderProxyAllowance).to.be.bignumber.equal(0);
-		});
-		it("doesn't update proxyAllowance after transfer if unlimited", async () => {
-			txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(exampleTokenAddress, sender);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			await exchangeTransferSimulator.transferFromAsync(
-				exampleTokenAddress,
-				sender,
-				recipient,
-				transferAmount,
-				TradeSide.Taker,
-				TransferType.Trade,
-			);
-			const store = (exchangeTransferSimulator as any)._store;
-			const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
-			const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
-			const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
-			expect(senderBalance).to.be.bignumber.equal(0);
-			expect(recipientBalance).to.be.bignumber.equal(transferAmount);
-			expect(senderProxyAllowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-	});
+    const web3 = web3Factory.create();
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    const zeroEx = new ZeroEx(web3.currentProvider, config);
+    const transferAmount = new BigNumber(5);
+    let userAddresses: string[];
+    let tokens: Token[];
+    let coinbase: string;
+    let sender: string;
+    let recipient: string;
+    let exampleTokenAddress: string;
+    let exchangeTransferSimulator: ExchangeTransferSimulator;
+    let txHash: string;
+    before(async () => {
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        [coinbase, sender, recipient] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        exampleTokenAddress = tokens[0].address;
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#transferFromAsync', () => {
+        beforeEach(() => {
+            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
+        });
+        it("throws if the user doesn't have enough allowance", async () => {
+            return expect(
+                exchangeTransferSimulator.transferFromAsync(
+                    exampleTokenAddress,
+                    sender,
+                    recipient,
+                    transferAmount,
+                    TradeSide.Taker,
+                    TransferType.Trade,
+                ),
+            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientTakerAllowance);
+        });
+        it("throws if the user doesn't have enough balance", async () => {
+            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            return expect(
+                exchangeTransferSimulator.transferFromAsync(
+                    exampleTokenAddress,
+                    sender,
+                    recipient,
+                    transferAmount,
+                    TradeSide.Maker,
+                    TransferType.Trade,
+                ),
+            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
+        });
+        it('updates balances and proxyAllowance after transfer', async () => {
+            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await zeroEx.token.setProxyAllowanceAsync(exampleTokenAddress, sender, transferAmount);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await exchangeTransferSimulator.transferFromAsync(
+                exampleTokenAddress,
+                sender,
+                recipient,
+                transferAmount,
+                TradeSide.Taker,
+                TransferType.Trade,
+            );
+            const store = (exchangeTransferSimulator as any)._store;
+            const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
+            const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
+            const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
+            expect(senderBalance).to.be.bignumber.equal(0);
+            expect(recipientBalance).to.be.bignumber.equal(transferAmount);
+            expect(senderProxyAllowance).to.be.bignumber.equal(0);
+        });
+        it("doesn't update proxyAllowance after transfer if unlimited", async () => {
+            txHash = await zeroEx.token.transferAsync(exampleTokenAddress, coinbase, sender, transferAmount);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(exampleTokenAddress, sender);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            await exchangeTransferSimulator.transferFromAsync(
+                exampleTokenAddress,
+                sender,
+                recipient,
+                transferAmount,
+                TradeSide.Taker,
+                TransferType.Trade,
+            );
+            const store = (exchangeTransferSimulator as any)._store;
+            const senderBalance = await store.getBalanceAsync(exampleTokenAddress, sender);
+            const recipientBalance = await store.getBalanceAsync(exampleTokenAddress, recipient);
+            const senderProxyAllowance = await store.getProxyAllowanceAsync(exampleTokenAddress, sender);
+            expect(senderBalance).to.be.bignumber.equal(0);
+            expect(recipientBalance).to.be.bignumber.equal(transferAmount);
+            expect(senderProxyAllowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+    });
 });
diff --git a/packages/0x.js/test/exchange_wrapper_test.ts b/packages/0x.js/test/exchange_wrapper_test.ts
index f67e61a55..7e0ffd818 100644
--- a/packages/0x.js/test/exchange_wrapper_test.ts
+++ b/packages/0x.js/test/exchange_wrapper_test.ts
@@ -6,17 +6,17 @@ import 'mocha';
 import * as Web3 from 'web3';
 
 import {
-	BlockRange,
-	DecodedLogEvent,
-	ExchangeContractErrs,
-	ExchangeEvents,
-	LogCancelContractEventArgs,
-	LogFillContractEventArgs,
-	OrderCancellationRequest,
-	OrderFillRequest,
-	SignedOrder,
-	Token,
-	ZeroEx,
+    BlockRange,
+    DecodedLogEvent,
+    ExchangeContractErrs,
+    ExchangeEvents,
+    LogCancelContractEventArgs,
+    LogFillContractEventArgs,
+    OrderCancellationRequest,
+    OrderFillRequest,
+    SignedOrder,
+    Token,
+    ZeroEx,
 } from '../src';
 import { BlockParamLiteral, DoneCallback } from '../src/types';
 
@@ -34,1114 +34,1114 @@ const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 const NON_EXISTENT_ORDER_HASH = '0x79370342234e7acd6bbeac335bd3bb1d368383294b64b8160a00f4060e4d3777';
 
 describe('ExchangeWrapper', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let tokenUtils: TokenUtils;
-	let tokens: Token[];
-	let userAddresses: string[];
-	let zrxTokenAddress: string;
-	let fillScenarios: FillScenarios;
-	let exchangeContractAddress: string;
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		exchangeContractAddress = zeroEx.exchange.getContractAddress();
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		tokenUtils = new TokenUtils(tokens);
-		zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-		fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-		await fillScenarios.initTokenBalancesAsync();
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('fillOrKill order(s)', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let coinbase: string;
-		let makerAddress: string;
-		let takerAddress: string;
-		let feeRecipient: string;
-		const takerTokenFillAmount = new BigNumber(5);
-		before(async () => {
-			[coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-			tokens = await zeroEx.tokenRegistry.getTokensAsync();
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		describe('#batchFillOrKillAsync', () => {
-			it('successfully batch fillOrKill', async () => {
-				const fillableAmount = new BigNumber(5);
-				const partialFillTakerAmount = new BigNumber(2);
-				const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				const orderFillRequests = [
-					{
-						signedOrder,
-						takerTokenFillAmount: partialFillTakerAmount,
-					},
-					{
-						signedOrder: anotherSignedOrder,
-						takerTokenFillAmount: partialFillTakerAmount,
-					},
-				];
-				await zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress);
-			});
-			describe('order transaction options', () => {
-				let signedOrder: SignedOrder;
-				let orderFillRequests: OrderFillRequest[];
-				const fillableAmount = new BigNumber(5);
-				beforeEach(async () => {
-					signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-					orderFillRequests = [
-						{
-							signedOrder,
-							takerTokenFillAmount: new BigNumber(0),
-						},
-					];
-				});
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
-							shouldValidate: true,
-						}),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
-							shouldValidate: false,
-						}),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-			});
-		});
-		describe('#fillOrKillOrderAsync', () => {
-			let signedOrder: SignedOrder;
-			const fillableAmount = new BigNumber(5);
-			beforeEach(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-			});
-			describe('successful fills', () => {
-				it('should fill a valid order', async () => {
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						0,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						0,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount,
-					);
-					await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, takerTokenFillAmount, takerAddress);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(takerTokenFillAmount),
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						takerTokenFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						takerTokenFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(takerTokenFillAmount),
-					);
-				});
-				it('should partially fill a valid order', async () => {
-					const partialFillAmount = new BigNumber(3);
-					await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, partialFillAmount, takerAddress);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(partialFillAmount),
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						partialFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						partialFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(partialFillAmount),
-					);
-				});
-			});
-			describe('order transaction options', () => {
-				const emptyFillableAmount = new BigNumber(0);
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
-							shouldValidate: true,
-						}),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
-							shouldValidate: false,
-						}),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-			});
-		});
-	});
-	describe('fill order(s)', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let coinbase: string;
-		let makerAddress: string;
-		let takerAddress: string;
-		let feeRecipient: string;
-		const fillableAmount = new BigNumber(5);
-		const takerTokenFillAmount = new BigNumber(5);
-		const shouldThrowOnInsufficientBalanceOrAllowance = true;
-		before(async () => {
-			[coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-			tokens = await zeroEx.tokenRegistry.getTokensAsync();
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		describe('#fillOrderAsync', () => {
-			describe('successful fills', () => {
-				it('should fill a valid order', async () => {
-					const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						0,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						0,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount,
-					);
-					const txHash = await zeroEx.exchange.fillOrderAsync(
-						signedOrder,
-						takerTokenFillAmount,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(takerTokenFillAmount),
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						takerTokenFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						takerTokenFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(takerTokenFillAmount),
-					);
-				});
-				it('should partially fill the valid order', async () => {
-					const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-					const partialFillAmount = new BigNumber(3);
-					const txHash = await zeroEx.exchange.fillOrderAsync(
-						signedOrder,
-						partialFillAmount,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(partialFillAmount),
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
-						partialFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						partialFillAmount,
-					);
-					expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
-						fillableAmount.minus(partialFillAmount),
-					);
-				});
-				it('should fill the valid orders with fees', async () => {
-					const makerFee = new BigNumber(1);
-					const takerFee = new BigNumber(2);
-					const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerFee,
-						takerFee,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-						feeRecipient,
-					);
-					const txHash = await zeroEx.exchange.fillOrderAsync(
-						signedOrder,
-						takerTokenFillAmount,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient)).to.be.bignumber.equal(
-						makerFee.plus(takerFee),
-					);
-				});
-			});
-			describe('order transaction options', () => {
-				let signedOrder: SignedOrder;
-				const emptyFillTakerAmount = new BigNumber(0);
-				beforeEach(async () => {
-					signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-				});
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.fillOrderAsync(
-							signedOrder,
-							emptyFillTakerAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrderAsync(
-							signedOrder,
-							emptyFillTakerAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: true,
-							},
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrderAsync(
-							signedOrder,
-							emptyFillTakerAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: false,
-							},
-						),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-			});
-			describe('negative fill amount', async () => {
-				let signedOrder: SignedOrder;
-				const negativeFillTakerAmount = new BigNumber(-100);
-				beforeEach(async () => {
-					signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						makerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-				});
-				it('should not allow the exchange wrapper to fill if amount is negative', async () => {
-					return expect(
-						zeroEx.exchange.fillOrderAsync(
-							signedOrder,
-							negativeFillTakerAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejected();
-				});
-			});
-		});
-		describe('#batchFillOrdersAsync', () => {
-			let signedOrder: SignedOrder;
-			let signedOrderHashHex: string;
-			let anotherSignedOrder: SignedOrder;
-			let anotherOrderHashHex: string;
-			let orderFillBatch: OrderFillRequest[];
-			beforeEach(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
-				anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
-			});
-			describe('successful batch fills', () => {
-				beforeEach(() => {
-					orderFillBatch = [
-						{
-							signedOrder,
-							takerTokenFillAmount,
-						},
-						{
-							signedOrder: anotherSignedOrder,
-							takerTokenFillAmount,
-						},
-					];
-				});
-				it('should throw if a batch is empty', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrdersAsync(
-							[],
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-				});
-				it('should successfully fill multiple orders', async () => {
-					const txHash = await zeroEx.exchange.batchFillOrdersAsync(
-						orderFillBatch,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-					const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
-					expect(filledAmount).to.be.bignumber.equal(takerTokenFillAmount);
-					expect(anotherFilledAmount).to.be.bignumber.equal(takerTokenFillAmount);
-				});
-			});
-			describe('order transaction options', () => {
-				beforeEach(async () => {
-					const emptyFillTakerAmount = new BigNumber(0);
-					orderFillBatch = [
-						{
-							signedOrder,
-							takerTokenFillAmount: emptyFillTakerAmount,
-						},
-						{
-							signedOrder: anotherSignedOrder,
-							takerTokenFillAmount: emptyFillTakerAmount,
-						},
-					];
-				});
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrdersAsync(
-							orderFillBatch,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrdersAsync(
-							orderFillBatch,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: true,
-							},
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrdersAsync(
-							orderFillBatch,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: false,
-							},
-						),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-			});
-			describe('negative batch fill amount', async () => {
-				beforeEach(async () => {
-					const negativeFillTakerAmount = new BigNumber(-100);
-					orderFillBatch = [
-						{
-							signedOrder,
-							takerTokenFillAmount,
-						},
-						{
-							signedOrder: anotherSignedOrder,
-							takerTokenFillAmount: negativeFillTakerAmount,
-						},
-					];
-				});
-				it('should not allow the exchange wrapper to batch fill if any amount is negative', async () => {
-					return expect(
-						zeroEx.exchange.batchFillOrdersAsync(
-							orderFillBatch,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejected();
-				});
-			});
-		});
-		describe('#fillOrdersUpTo', () => {
-			let signedOrder: SignedOrder;
-			let signedOrderHashHex: string;
-			let anotherSignedOrder: SignedOrder;
-			let anotherOrderHashHex: string;
-			let signedOrders: SignedOrder[];
-			const fillUpToAmount = fillableAmount.plus(fillableAmount).minus(1);
-			beforeEach(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
-				anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
-				signedOrders = [signedOrder, anotherSignedOrder];
-			});
-			describe('successful batch fills', () => {
-				it('should throw if a batch is empty', async () => {
-					return expect(
-						zeroEx.exchange.fillOrdersUpToAsync(
-							[],
-							fillUpToAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
-				});
-				it('should successfully fill up to specified amount when all orders are fully funded', async () => {
-					const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
-						signedOrders,
-						fillUpToAmount,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-					const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
-					expect(filledAmount).to.be.bignumber.equal(fillableAmount);
-					const remainingFillAmount = fillableAmount.minus(1);
-					expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
-				});
-				it('should successfully fill up to specified amount even if filling all orders would fail', async () => {
-					const missingBalance = new BigNumber(1); // User will still have enough balance to fill up to 9,
-					// but won't have 10 to fully fill all orders in a batch.
-					await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
-					const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
-						signedOrders,
-						fillUpToAmount,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						takerAddress,
-					);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
-					const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
-					expect(filledAmount).to.be.bignumber.equal(fillableAmount);
-					const remainingFillAmount = fillableAmount.minus(1);
-					expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
-				});
-			});
-			describe('failed batch fills', () => {
-				it("should fail validation if user doesn't have enough balance without fill up to", async () => {
-					const missingBalance = new BigNumber(2); // User will only have enough balance to fill up to 8
-					await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
-					return expect(
-						zeroEx.exchange.fillOrdersUpToAsync(
-							signedOrders,
-							fillUpToAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
-				});
-			});
-			describe('order transaction options', () => {
-				const emptyFillUpToAmount = new BigNumber(0);
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.fillOrdersUpToAsync(
-							signedOrders,
-							emptyFillUpToAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrdersUpToAsync(
-							signedOrders,
-							emptyFillUpToAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: true,
-							},
-						),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.fillOrdersUpToAsync(
-							signedOrders,
-							emptyFillUpToAmount,
-							shouldThrowOnInsufficientBalanceOrAllowance,
-							takerAddress,
-							{
-								shouldValidate: false,
-							},
-						),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-				});
-			});
-		});
-	});
-	describe('cancel order(s)', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let coinbase: string;
-		let makerAddress: string;
-		let takerAddress: string;
-		const fillableAmount = new BigNumber(5);
-		let signedOrder: SignedOrder;
-		let orderHashHex: string;
-		const cancelAmount = new BigNumber(3);
-		beforeEach(async () => {
-			[coinbase, makerAddress, takerAddress] = userAddresses;
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-			signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			orderHashHex = ZeroEx.getOrderHashHex(signedOrder);
-		});
-		describe('#cancelOrderAsync', () => {
-			describe('successful cancels', () => {
-				it('should cancel an order', async () => {
-					const txHash = await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
-					await zeroEx.awaitTransactionMinedAsync(txHash);
-					const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
-					expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
-				});
-			});
-			describe('order transaction options', () => {
-				const emptyCancelTakerTokenAmount = new BigNumber(0);
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(
-						zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
-							shouldValidate: true,
-						}),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
-							shouldValidate: false,
-						}),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-				});
-			});
-		});
-		describe('#batchCancelOrdersAsync', () => {
-			let anotherSignedOrder: SignedOrder;
-			let anotherOrderHashHex: string;
-			let cancelBatch: OrderCancellationRequest[];
-			beforeEach(async () => {
-				anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerTokenAddress,
-					takerTokenAddress,
-					makerAddress,
-					takerAddress,
-					fillableAmount,
-				);
-				anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
-				cancelBatch = [
-					{
-						order: signedOrder,
-						takerTokenCancelAmount: cancelAmount,
-					},
-					{
-						order: anotherSignedOrder,
-						takerTokenCancelAmount: cancelAmount,
-					},
-				];
-			});
-			describe('failed batch cancels', () => {
-				it('should throw when orders have different makers', async () => {
-					const signedOrderWithDifferentMaker = await fillScenarios.createFillableSignedOrderAsync(
-						makerTokenAddress,
-						takerTokenAddress,
-						takerAddress,
-						takerAddress,
-						fillableAmount,
-					);
-					return expect(
-						zeroEx.exchange.batchCancelOrdersAsync([
-							cancelBatch[0],
-							{
-								order: signedOrderWithDifferentMaker,
-								takerTokenCancelAmount: cancelAmount,
-							},
-						]),
-					).to.be.rejectedWith(ExchangeContractErrs.MultipleMakersInSingleCancelBatchDisallowed);
-				});
-			});
-			describe('successful batch cancels', () => {
-				it('should cancel a batch of orders', async () => {
-					await zeroEx.exchange.batchCancelOrdersAsync(cancelBatch);
-					const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
-					const anotherCancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(
-						anotherOrderHashHex,
-					);
-					expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
-					expect(anotherCancelledAmount).to.be.bignumber.equal(cancelAmount);
-				});
-			});
-			describe('order transaction options', () => {
-				beforeEach(async () => {
-					const emptyTakerTokenCancelAmount = new BigNumber(0);
-					cancelBatch = [
-						{
-							order: signedOrder,
-							takerTokenCancelAmount: emptyTakerTokenCancelAmount,
-						},
-						{
-							order: anotherSignedOrder,
-							takerTokenCancelAmount: emptyTakerTokenCancelAmount,
-						},
-					];
-				});
-				it('should validate when orderTransactionOptions are not present', async () => {
-					return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch)).to.be.rejectedWith(
-						ExchangeContractErrs.OrderCancelAmountZero,
-					);
-				});
-				it('should validate when orderTransactionOptions specify to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
-							shouldValidate: true,
-						}),
-					).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-				});
-				it('should not validate when orderTransactionOptions specify not to validate', async () => {
-					return expect(
-						zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
-							shouldValidate: false,
-						}),
-					).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-				});
-			});
-		});
-	});
-	describe('tests that require partially filled order', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let takerAddress: string;
-		let fillableAmount: BigNumber;
-		let partialFillAmount: BigNumber;
-		let signedOrder: SignedOrder;
-		let orderHash: string;
-		before(() => {
-			takerAddress = userAddresses[1];
-			tokenUtils = new TokenUtils(tokens);
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		beforeEach(async () => {
-			fillableAmount = new BigNumber(5);
-			partialFillAmount = new BigNumber(2);
-			signedOrder = await fillScenarios.createPartiallyFilledSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				takerAddress,
-				fillableAmount,
-				partialFillAmount,
-			);
-			orderHash = ZeroEx.getOrderHashHex(signedOrder);
-		});
-		describe('#getUnavailableTakerAmountAsync', () => {
-			it('should throw if passed an invalid orderHash', async () => {
-				const invalidOrderHashHex = '0x123';
-				return expect(zeroEx.exchange.getUnavailableTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
-			});
-			it('should return zero if passed a valid but non-existent orderHash', async () => {
-				const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
-				expect(unavailableValueT).to.be.bignumber.equal(0);
-			});
-			it('should return the unavailableValueT for a valid and partially filled orderHash', async () => {
-				const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(orderHash);
-				expect(unavailableValueT).to.be.bignumber.equal(partialFillAmount);
-			});
-		});
-		describe('#getFilledTakerAmountAsync', () => {
-			it('should throw if passed an invalid orderHash', async () => {
-				const invalidOrderHashHex = '0x123';
-				return expect(zeroEx.exchange.getFilledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
-			});
-			it('should return zero if passed a valid but non-existent orderHash', async () => {
-				const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
-				expect(filledValueT).to.be.bignumber.equal(0);
-			});
-			it('should return the filledValueT for a valid and partially filled orderHash', async () => {
-				const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(orderHash);
-				expect(filledValueT).to.be.bignumber.equal(partialFillAmount);
-			});
-		});
-		describe('#getCancelledTakerAmountAsync', () => {
-			it('should throw if passed an invalid orderHash', async () => {
-				const invalidOrderHashHex = '0x123';
-				return expect(zeroEx.exchange.getCancelledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
-			});
-			it('should return zero if passed a valid but non-existent orderHash', async () => {
-				const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
-				expect(cancelledValueT).to.be.bignumber.equal(0);
-			});
-			it('should return the cancelledValueT for a valid and partially filled orderHash', async () => {
-				const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
-				expect(cancelledValueT).to.be.bignumber.equal(0);
-			});
-			it('should return the cancelledValueT for a valid and cancelled orderHash', async () => {
-				const cancelAmount = fillableAmount.minus(partialFillAmount);
-				await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
-				const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
-				expect(cancelledValueT).to.be.bignumber.equal(cancelAmount);
-			});
-		});
-	});
-	describe('#subscribe', () => {
-		const indexFilterValues = {};
-		const shouldThrowOnInsufficientBalanceOrAllowance = true;
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let coinbase: string;
-		let takerAddress: string;
-		let makerAddress: string;
-		let fillableAmount: BigNumber;
-		let signedOrder: SignedOrder;
-		const takerTokenFillAmountInBaseUnits = new BigNumber(1);
-		const cancelTakerAmountInBaseUnits = new BigNumber(1);
-		before(() => {
-			[coinbase, makerAddress, takerAddress] = userAddresses;
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		beforeEach(async () => {
-			fillableAmount = new BigNumber(5);
-			signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-		});
-		afterEach(async () => {
-			zeroEx.exchange.unsubscribeAll();
-		});
-		// Hack: Mocha does not allow a test to be both async and have a `done` callback
-		// Since we need to await the receipt of the event in the `subscribe` callback,
-		// we do need both. A hack is to make the top-level a sync fn w/ a done callback and then
-		// wrap the rest of the test in an async block
-		// Source: https://github.com/mochajs/mocha/issues/2407
-		it('Should receive the LogFill event when an order is filled', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
-						expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
-					},
-				);
-				zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
-				await zeroEx.exchange.fillOrderAsync(
-					signedOrder,
-					takerTokenFillAmountInBaseUnits,
-					shouldThrowOnInsufficientBalanceOrAllowance,
-					takerAddress,
-				);
-			})().catch(done);
-		});
-		it('Should receive the LogCancel event when an order is cancelled', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<LogCancelContractEventArgs>) => {
-						expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogCancel);
-					},
-				);
-				zeroEx.exchange.subscribe(ExchangeEvents.LogCancel, indexFilterValues, callback);
-				await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelTakerAmountInBaseUnits);
-			})().catch(done);
-		});
-		it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callbackNeverToBeCalled);
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let tokenUtils: TokenUtils;
+    let tokens: Token[];
+    let userAddresses: string[];
+    let zrxTokenAddress: string;
+    let fillScenarios: FillScenarios;
+    let exchangeContractAddress: string;
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        await fillScenarios.initTokenBalancesAsync();
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('fillOrKill order(s)', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let coinbase: string;
+        let makerAddress: string;
+        let takerAddress: string;
+        let feeRecipient: string;
+        const takerTokenFillAmount = new BigNumber(5);
+        before(async () => {
+            [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
+            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        describe('#batchFillOrKillAsync', () => {
+            it('successfully batch fillOrKill', async () => {
+                const fillableAmount = new BigNumber(5);
+                const partialFillTakerAmount = new BigNumber(2);
+                const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                const orderFillRequests = [
+                    {
+                        signedOrder,
+                        takerTokenFillAmount: partialFillTakerAmount,
+                    },
+                    {
+                        signedOrder: anotherSignedOrder,
+                        takerTokenFillAmount: partialFillTakerAmount,
+                    },
+                ];
+                await zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress);
+            });
+            describe('order transaction options', () => {
+                let signedOrder: SignedOrder;
+                let orderFillRequests: OrderFillRequest[];
+                const fillableAmount = new BigNumber(5);
+                beforeEach(async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                    orderFillRequests = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount: new BigNumber(0),
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
+                            shouldValidate: true,
+                        }),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrKillAsync(orderFillRequests, takerAddress, {
+                            shouldValidate: false,
+                        }),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
+        });
+        describe('#fillOrKillOrderAsync', () => {
+            let signedOrder: SignedOrder;
+            const fillableAmount = new BigNumber(5);
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+            });
+            describe('successful fills', () => {
+                it('should fill a valid order', async () => {
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        0,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        0,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount,
+                    );
+                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, takerTokenFillAmount, takerAddress);
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(takerTokenFillAmount),
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        takerTokenFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        takerTokenFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(takerTokenFillAmount),
+                    );
+                });
+                it('should partially fill a valid order', async () => {
+                    const partialFillAmount = new BigNumber(3);
+                    await zeroEx.exchange.fillOrKillOrderAsync(signedOrder, partialFillAmount, takerAddress);
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(partialFillAmount),
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        partialFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        partialFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(partialFillAmount),
+                    );
+                });
+            });
+            describe('order transaction options', () => {
+                const emptyFillableAmount = new BigNumber(0);
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
+                            shouldValidate: true,
+                        }),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrKillOrderAsync(signedOrder, emptyFillableAmount, takerAddress, {
+                            shouldValidate: false,
+                        }),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
+        });
+    });
+    describe('fill order(s)', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let coinbase: string;
+        let makerAddress: string;
+        let takerAddress: string;
+        let feeRecipient: string;
+        const fillableAmount = new BigNumber(5);
+        const takerTokenFillAmount = new BigNumber(5);
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
+        before(async () => {
+            [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
+            tokens = await zeroEx.tokenRegistry.getTokensAsync();
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        describe('#fillOrderAsync', () => {
+            describe('successful fills', () => {
+                it('should fill a valid order', async () => {
+                    const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        0,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        0,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount,
+                    );
+                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                        signedOrder,
+                        takerTokenFillAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(takerTokenFillAmount),
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        takerTokenFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        takerTokenFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(takerTokenFillAmount),
+                    );
+                });
+                it('should partially fill the valid order', async () => {
+                    const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                    const partialFillAmount = new BigNumber(3);
+                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                        signedOrder,
+                        partialFillAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(partialFillAmount),
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, makerAddress)).to.be.bignumber.equal(
+                        partialFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(makerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        partialFillAmount,
+                    );
+                    expect(await zeroEx.token.getBalanceAsync(takerTokenAddress, takerAddress)).to.be.bignumber.equal(
+                        fillableAmount.minus(partialFillAmount),
+                    );
+                });
+                it('should fill the valid orders with fees', async () => {
+                    const makerFee = new BigNumber(1);
+                    const takerFee = new BigNumber(2);
+                    const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerFee,
+                        takerFee,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                        feeRecipient,
+                    );
+                    const txHash = await zeroEx.exchange.fillOrderAsync(
+                        signedOrder,
+                        takerTokenFillAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    expect(await zeroEx.token.getBalanceAsync(zrxTokenAddress, feeRecipient)).to.be.bignumber.equal(
+                        makerFee.plus(takerFee),
+                    );
+                });
+            });
+            describe('order transaction options', () => {
+                let signedOrder: SignedOrder;
+                const emptyFillTakerAmount = new BigNumber(0);
+                beforeEach(async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrderAsync(
+                            signedOrder,
+                            emptyFillTakerAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrderAsync(
+                            signedOrder,
+                            emptyFillTakerAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: true,
+                            },
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrderAsync(
+                            signedOrder,
+                            emptyFillTakerAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: false,
+                            },
+                        ),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
+            describe('negative fill amount', async () => {
+                let signedOrder: SignedOrder;
+                const negativeFillTakerAmount = new BigNumber(-100);
+                beforeEach(async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                });
+                it('should not allow the exchange wrapper to fill if amount is negative', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrderAsync(
+                            signedOrder,
+                            negativeFillTakerAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejected();
+                });
+            });
+        });
+        describe('#batchFillOrdersAsync', () => {
+            let signedOrder: SignedOrder;
+            let signedOrderHashHex: string;
+            let anotherSignedOrder: SignedOrder;
+            let anotherOrderHashHex: string;
+            let orderFillBatch: OrderFillRequest[];
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+                anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+            });
+            describe('successful batch fills', () => {
+                beforeEach(() => {
+                    orderFillBatch = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount,
+                        },
+                        {
+                            signedOrder: anotherSignedOrder,
+                            takerTokenFillAmount,
+                        },
+                    ];
+                });
+                it('should throw if a batch is empty', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrdersAsync(
+                            [],
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+                });
+                it('should successfully fill multiple orders', async () => {
+                    const txHash = await zeroEx.exchange.batchFillOrdersAsync(
+                        orderFillBatch,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    expect(filledAmount).to.be.bignumber.equal(takerTokenFillAmount);
+                    expect(anotherFilledAmount).to.be.bignumber.equal(takerTokenFillAmount);
+                });
+            });
+            describe('order transaction options', () => {
+                beforeEach(async () => {
+                    const emptyFillTakerAmount = new BigNumber(0);
+                    orderFillBatch = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount: emptyFillTakerAmount,
+                        },
+                        {
+                            signedOrder: anotherSignedOrder,
+                            takerTokenFillAmount: emptyFillTakerAmount,
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrdersAsync(
+                            orderFillBatch,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrdersAsync(
+                            orderFillBatch,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: true,
+                            },
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrdersAsync(
+                            orderFillBatch,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: false,
+                            },
+                        ),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
+            describe('negative batch fill amount', async () => {
+                beforeEach(async () => {
+                    const negativeFillTakerAmount = new BigNumber(-100);
+                    orderFillBatch = [
+                        {
+                            signedOrder,
+                            takerTokenFillAmount,
+                        },
+                        {
+                            signedOrder: anotherSignedOrder,
+                            takerTokenFillAmount: negativeFillTakerAmount,
+                        },
+                    ];
+                });
+                it('should not allow the exchange wrapper to batch fill if any amount is negative', async () => {
+                    return expect(
+                        zeroEx.exchange.batchFillOrdersAsync(
+                            orderFillBatch,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejected();
+                });
+            });
+        });
+        describe('#fillOrdersUpTo', () => {
+            let signedOrder: SignedOrder;
+            let signedOrderHashHex: string;
+            let anotherSignedOrder: SignedOrder;
+            let anotherOrderHashHex: string;
+            let signedOrders: SignedOrder[];
+            const fillUpToAmount = fillableAmount.plus(fillableAmount).minus(1);
+            beforeEach(async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                signedOrderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+                anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+                signedOrders = [signedOrder, anotherSignedOrder];
+            });
+            describe('successful batch fills', () => {
+                it('should throw if a batch is empty', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrdersUpToAsync(
+                            [],
+                            fillUpToAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.BatchOrdersMustHaveAtLeastOneItem);
+                });
+                it('should successfully fill up to specified amount when all orders are fully funded', async () => {
+                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders,
+                        fillUpToAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    expect(filledAmount).to.be.bignumber.equal(fillableAmount);
+                    const remainingFillAmount = fillableAmount.minus(1);
+                    expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
+                });
+                it('should successfully fill up to specified amount even if filling all orders would fail', async () => {
+                    const missingBalance = new BigNumber(1); // User will still have enough balance to fill up to 9,
+                    // but won't have 10 to fully fill all orders in a batch.
+                    await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
+                    const txHash = await zeroEx.exchange.fillOrdersUpToAsync(
+                        signedOrders,
+                        fillUpToAmount,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        takerAddress,
+                    );
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    const filledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(signedOrderHashHex);
+                    const anotherFilledAmount = await zeroEx.exchange.getFilledTakerAmountAsync(anotherOrderHashHex);
+                    expect(filledAmount).to.be.bignumber.equal(fillableAmount);
+                    const remainingFillAmount = fillableAmount.minus(1);
+                    expect(anotherFilledAmount).to.be.bignumber.equal(remainingFillAmount);
+                });
+            });
+            describe('failed batch fills', () => {
+                it("should fail validation if user doesn't have enough balance without fill up to", async () => {
+                    const missingBalance = new BigNumber(2); // User will only have enough balance to fill up to 8
+                    await zeroEx.token.transferAsync(makerTokenAddress, makerAddress, coinbase, missingBalance);
+                    return expect(
+                        zeroEx.exchange.fillOrdersUpToAsync(
+                            signedOrders,
+                            fillUpToAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.InsufficientMakerBalance);
+                });
+            });
+            describe('order transaction options', () => {
+                const emptyFillUpToAmount = new BigNumber(0);
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrdersUpToAsync(
+                            signedOrders,
+                            emptyFillUpToAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrdersUpToAsync(
+                            signedOrders,
+                            emptyFillUpToAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: true,
+                            },
+                        ),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.fillOrdersUpToAsync(
+                            signedOrders,
+                            emptyFillUpToAmount,
+                            shouldThrowOnInsufficientBalanceOrAllowance,
+                            takerAddress,
+                            {
+                                shouldValidate: false,
+                            },
+                        ),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+                });
+            });
+        });
+    });
+    describe('cancel order(s)', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let coinbase: string;
+        let makerAddress: string;
+        let takerAddress: string;
+        const fillableAmount = new BigNumber(5);
+        let signedOrder: SignedOrder;
+        let orderHashHex: string;
+        const cancelAmount = new BigNumber(3);
+        beforeEach(async () => {
+            [coinbase, makerAddress, takerAddress] = userAddresses;
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            orderHashHex = ZeroEx.getOrderHashHex(signedOrder);
+        });
+        describe('#cancelOrderAsync', () => {
+            describe('successful cancels', () => {
+                it('should cancel an order', async () => {
+                    const txHash = await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
+                    await zeroEx.awaitTransactionMinedAsync(txHash);
+                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
+                    expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
+                });
+            });
+            describe('order transaction options', () => {
+                const emptyCancelTakerTokenAmount = new BigNumber(0);
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(
+                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
+                            shouldValidate: true,
+                        }),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.cancelOrderAsync(signedOrder, emptyCancelTakerTokenAmount, {
+                            shouldValidate: false,
+                        }),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+            });
+        });
+        describe('#batchCancelOrdersAsync', () => {
+            let anotherSignedOrder: SignedOrder;
+            let anotherOrderHashHex: string;
+            let cancelBatch: OrderCancellationRequest[];
+            beforeEach(async () => {
+                anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerTokenAddress,
+                    takerTokenAddress,
+                    makerAddress,
+                    takerAddress,
+                    fillableAmount,
+                );
+                anotherOrderHashHex = ZeroEx.getOrderHashHex(anotherSignedOrder);
+                cancelBatch = [
+                    {
+                        order: signedOrder,
+                        takerTokenCancelAmount: cancelAmount,
+                    },
+                    {
+                        order: anotherSignedOrder,
+                        takerTokenCancelAmount: cancelAmount,
+                    },
+                ];
+            });
+            describe('failed batch cancels', () => {
+                it('should throw when orders have different makers', async () => {
+                    const signedOrderWithDifferentMaker = await fillScenarios.createFillableSignedOrderAsync(
+                        makerTokenAddress,
+                        takerTokenAddress,
+                        takerAddress,
+                        takerAddress,
+                        fillableAmount,
+                    );
+                    return expect(
+                        zeroEx.exchange.batchCancelOrdersAsync([
+                            cancelBatch[0],
+                            {
+                                order: signedOrderWithDifferentMaker,
+                                takerTokenCancelAmount: cancelAmount,
+                            },
+                        ]),
+                    ).to.be.rejectedWith(ExchangeContractErrs.MultipleMakersInSingleCancelBatchDisallowed);
+                });
+            });
+            describe('successful batch cancels', () => {
+                it('should cancel a batch of orders', async () => {
+                    await zeroEx.exchange.batchCancelOrdersAsync(cancelBatch);
+                    const cancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHashHex);
+                    const anotherCancelledAmount = await zeroEx.exchange.getCancelledTakerAmountAsync(
+                        anotherOrderHashHex,
+                    );
+                    expect(cancelledAmount).to.be.bignumber.equal(cancelAmount);
+                    expect(anotherCancelledAmount).to.be.bignumber.equal(cancelAmount);
+                });
+            });
+            describe('order transaction options', () => {
+                beforeEach(async () => {
+                    const emptyTakerTokenCancelAmount = new BigNumber(0);
+                    cancelBatch = [
+                        {
+                            order: signedOrder,
+                            takerTokenCancelAmount: emptyTakerTokenCancelAmount,
+                        },
+                        {
+                            order: anotherSignedOrder,
+                            takerTokenCancelAmount: emptyTakerTokenCancelAmount,
+                        },
+                    ];
+                });
+                it('should validate when orderTransactionOptions are not present', async () => {
+                    return expect(zeroEx.exchange.batchCancelOrdersAsync(cancelBatch)).to.be.rejectedWith(
+                        ExchangeContractErrs.OrderCancelAmountZero,
+                    );
+                });
+                it('should validate when orderTransactionOptions specify to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
+                            shouldValidate: true,
+                        }),
+                    ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+                it('should not validate when orderTransactionOptions specify not to validate', async () => {
+                    return expect(
+                        zeroEx.exchange.batchCancelOrdersAsync(cancelBatch, {
+                            shouldValidate: false,
+                        }),
+                    ).to.not.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+                });
+            });
+        });
+    });
+    describe('tests that require partially filled order', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let takerAddress: string;
+        let fillableAmount: BigNumber;
+        let partialFillAmount: BigNumber;
+        let signedOrder: SignedOrder;
+        let orderHash: string;
+        before(() => {
+            takerAddress = userAddresses[1];
+            tokenUtils = new TokenUtils(tokens);
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        beforeEach(async () => {
+            fillableAmount = new BigNumber(5);
+            partialFillAmount = new BigNumber(2);
+            signedOrder = await fillScenarios.createPartiallyFilledSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                takerAddress,
+                fillableAmount,
+                partialFillAmount,
+            );
+            orderHash = ZeroEx.getOrderHashHex(signedOrder);
+        });
+        describe('#getUnavailableTakerAmountAsync', () => {
+            it('should throw if passed an invalid orderHash', async () => {
+                const invalidOrderHashHex = '0x123';
+                return expect(zeroEx.exchange.getUnavailableTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+            });
+            it('should return zero if passed a valid but non-existent orderHash', async () => {
+                const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                expect(unavailableValueT).to.be.bignumber.equal(0);
+            });
+            it('should return the unavailableValueT for a valid and partially filled orderHash', async () => {
+                const unavailableValueT = await zeroEx.exchange.getUnavailableTakerAmountAsync(orderHash);
+                expect(unavailableValueT).to.be.bignumber.equal(partialFillAmount);
+            });
+        });
+        describe('#getFilledTakerAmountAsync', () => {
+            it('should throw if passed an invalid orderHash', async () => {
+                const invalidOrderHashHex = '0x123';
+                return expect(zeroEx.exchange.getFilledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+            });
+            it('should return zero if passed a valid but non-existent orderHash', async () => {
+                const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                expect(filledValueT).to.be.bignumber.equal(0);
+            });
+            it('should return the filledValueT for a valid and partially filled orderHash', async () => {
+                const filledValueT = await zeroEx.exchange.getFilledTakerAmountAsync(orderHash);
+                expect(filledValueT).to.be.bignumber.equal(partialFillAmount);
+            });
+        });
+        describe('#getCancelledTakerAmountAsync', () => {
+            it('should throw if passed an invalid orderHash', async () => {
+                const invalidOrderHashHex = '0x123';
+                return expect(zeroEx.exchange.getCancelledTakerAmountAsync(invalidOrderHashHex)).to.be.rejected();
+            });
+            it('should return zero if passed a valid but non-existent orderHash', async () => {
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(NON_EXISTENT_ORDER_HASH);
+                expect(cancelledValueT).to.be.bignumber.equal(0);
+            });
+            it('should return the cancelledValueT for a valid and partially filled orderHash', async () => {
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
+                expect(cancelledValueT).to.be.bignumber.equal(0);
+            });
+            it('should return the cancelledValueT for a valid and cancelled orderHash', async () => {
+                const cancelAmount = fillableAmount.minus(partialFillAmount);
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmount);
+                const cancelledValueT = await zeroEx.exchange.getCancelledTakerAmountAsync(orderHash);
+                expect(cancelledValueT).to.be.bignumber.equal(cancelAmount);
+            });
+        });
+    });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let coinbase: string;
+        let takerAddress: string;
+        let makerAddress: string;
+        let fillableAmount: BigNumber;
+        let signedOrder: SignedOrder;
+        const takerTokenFillAmountInBaseUnits = new BigNumber(1);
+        const cancelTakerAmountInBaseUnits = new BigNumber(1);
+        before(() => {
+            [coinbase, makerAddress, takerAddress] = userAddresses;
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        beforeEach(async () => {
+            fillableAmount = new BigNumber(5);
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+        });
+        afterEach(async () => {
+            zeroEx.exchange.unsubscribeAll();
+        });
+        // Hack: Mocha does not allow a test to be both async and have a `done` callback
+        // Since we need to await the receipt of the event in the `subscribe` callback,
+        // we do need both. A hack is to make the top-level a sync fn w/ a done callback and then
+        // wrap the rest of the test in an async block
+        // Source: https://github.com/mochajs/mocha/issues/2407
+        it('Should receive the LogFill event when an order is filled', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
+                        expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
+                    },
+                );
+                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder,
+                    takerTokenFillAmountInBaseUnits,
+                    shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
+                );
+            })().catch(done);
+        });
+        it('Should receive the LogCancel event when an order is cancelled', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<LogCancelContractEventArgs>) => {
+                        expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogCancel);
+                    },
+                );
+                zeroEx.exchange.subscribe(ExchangeEvents.LogCancel, indexFilterValues, callback);
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelTakerAmountInBaseUnits);
+            })().catch(done);
+        });
+        it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callbackNeverToBeCalled);
 
-				const newProvider = web3Factory.getRpcProvider();
-				zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                const newProvider = web3Factory.getRpcProvider();
+                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
 
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
-						expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
-					},
-				);
-				zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
-				await zeroEx.exchange.fillOrderAsync(
-					signedOrder,
-					takerTokenFillAmountInBaseUnits,
-					shouldThrowOnInsufficientBalanceOrAllowance,
-					takerAddress,
-				);
-			})().catch(done);
-		});
-		it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				const subscriptionToken = zeroEx.exchange.subscribe(
-					ExchangeEvents.LogFill,
-					indexFilterValues,
-					callbackNeverToBeCalled,
-				);
-				zeroEx.exchange.unsubscribe(subscriptionToken);
-				await zeroEx.exchange.fillOrderAsync(
-					signedOrder,
-					takerTokenFillAmountInBaseUnits,
-					shouldThrowOnInsufficientBalanceOrAllowance,
-					takerAddress,
-				);
-				done();
-			})().catch(done);
-		});
-	});
-	describe('#getOrderHashHexUsingContractCallAsync', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let makerAddress: string;
-		let takerAddress: string;
-		const fillableAmount = new BigNumber(5);
-		before(async () => {
-			[, makerAddress, takerAddress] = userAddresses;
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		it("get's the same hash as the local function", async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			const orderHashFromContract = await (zeroEx.exchange as any)._getOrderHashHexUsingContractCallAsync(
-				signedOrder,
-			);
-			expect(orderHash).to.equal(orderHashFromContract);
-		});
-	});
-	describe('#getZRXTokenAddressAsync', () => {
-		it('gets the same token as is in token registry', () => {
-			const zrxAddress = zeroEx.exchange.getZRXTokenAddress();
-			const zrxToken = tokenUtils.getProtocolTokenOrThrow();
-			expect(zrxAddress).to.equal(zrxToken.address);
-		});
-	});
-	describe('#getLogsAsync', () => {
-		let makerTokenAddress: string;
-		let takerTokenAddress: string;
-		let makerAddress: string;
-		let takerAddress: string;
-		const fillableAmount = new BigNumber(5);
-		const shouldThrowOnInsufficientBalanceOrAllowance = true;
-		const blockRange: BlockRange = {
-			fromBlock: 0,
-			toBlock: BlockParamLiteral.Latest,
-		};
-		let txHash: string;
-		before(async () => {
-			[, makerAddress, takerAddress] = userAddresses;
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-		});
-		it('should get logs with decoded args emitted by LogFill', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			txHash = await zeroEx.exchange.fillOrderAsync(
-				signedOrder,
-				fillableAmount,
-				shouldThrowOnInsufficientBalanceOrAllowance,
-				takerAddress,
-			);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const eventName = ExchangeEvents.LogFill;
-			const indexFilterValues = {};
-			const logs = await zeroEx.exchange.getLogsAsync(eventName, blockRange, indexFilterValues);
-			expect(logs).to.have.length(1);
-			expect(logs[0].event).to.be.equal(eventName);
-		});
-		it('should only get the logs with the correct event name', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			txHash = await zeroEx.exchange.fillOrderAsync(
-				signedOrder,
-				fillableAmount,
-				shouldThrowOnInsufficientBalanceOrAllowance,
-				takerAddress,
-			);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const differentEventName = ExchangeEvents.LogCancel;
-			const indexFilterValues = {};
-			const logs = await zeroEx.exchange.getLogsAsync(differentEventName, blockRange, indexFilterValues);
-			expect(logs).to.have.length(0);
-		});
-		it('should only get the logs with the correct indexed fields', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			txHash = await zeroEx.exchange.fillOrderAsync(
-				signedOrder,
-				fillableAmount,
-				shouldThrowOnInsufficientBalanceOrAllowance,
-				takerAddress,
-			);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
+                        expect(logEvent.log.event).to.be.equal(ExchangeEvents.LogFill);
+                    },
+                );
+                zeroEx.exchange.subscribe(ExchangeEvents.LogFill, indexFilterValues, callback);
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder,
+                    takerTokenFillAmountInBaseUnits,
+                    shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
+                );
+            })().catch(done);
+        });
+        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<LogFillContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                const subscriptionToken = zeroEx.exchange.subscribe(
+                    ExchangeEvents.LogFill,
+                    indexFilterValues,
+                    callbackNeverToBeCalled,
+                );
+                zeroEx.exchange.unsubscribe(subscriptionToken);
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder,
+                    takerTokenFillAmountInBaseUnits,
+                    shouldThrowOnInsufficientBalanceOrAllowance,
+                    takerAddress,
+                );
+                done();
+            })().catch(done);
+        });
+    });
+    describe('#getOrderHashHexUsingContractCallAsync', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let makerAddress: string;
+        let takerAddress: string;
+        const fillableAmount = new BigNumber(5);
+        before(async () => {
+            [, makerAddress, takerAddress] = userAddresses;
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        it("get's the same hash as the local function", async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            const orderHashFromContract = await (zeroEx.exchange as any)._getOrderHashHexUsingContractCallAsync(
+                signedOrder,
+            );
+            expect(orderHash).to.equal(orderHashFromContract);
+        });
+    });
+    describe('#getZRXTokenAddressAsync', () => {
+        it('gets the same token as is in token registry', () => {
+            const zrxAddress = zeroEx.exchange.getZRXTokenAddress();
+            const zrxToken = tokenUtils.getProtocolTokenOrThrow();
+            expect(zrxAddress).to.equal(zrxToken.address);
+        });
+    });
+    describe('#getLogsAsync', () => {
+        let makerTokenAddress: string;
+        let takerTokenAddress: string;
+        let makerAddress: string;
+        let takerAddress: string;
+        const fillableAmount = new BigNumber(5);
+        const shouldThrowOnInsufficientBalanceOrAllowance = true;
+        const blockRange: BlockRange = {
+            fromBlock: 0,
+            toBlock: BlockParamLiteral.Latest,
+        };
+        let txHash: string;
+        before(async () => {
+            [, makerAddress, takerAddress] = userAddresses;
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+        });
+        it('should get logs with decoded args emitted by LogFill', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            txHash = await zeroEx.exchange.fillOrderAsync(
+                signedOrder,
+                fillableAmount,
+                shouldThrowOnInsufficientBalanceOrAllowance,
+                takerAddress,
+            );
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = ExchangeEvents.LogFill;
+            const indexFilterValues = {};
+            const logs = await zeroEx.exchange.getLogsAsync(eventName, blockRange, indexFilterValues);
+            expect(logs).to.have.length(1);
+            expect(logs[0].event).to.be.equal(eventName);
+        });
+        it('should only get the logs with the correct event name', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            txHash = await zeroEx.exchange.fillOrderAsync(
+                signedOrder,
+                fillableAmount,
+                shouldThrowOnInsufficientBalanceOrAllowance,
+                takerAddress,
+            );
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const differentEventName = ExchangeEvents.LogCancel;
+            const indexFilterValues = {};
+            const logs = await zeroEx.exchange.getLogsAsync(differentEventName, blockRange, indexFilterValues);
+            expect(logs).to.have.length(0);
+        });
+        it('should only get the logs with the correct indexed fields', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            txHash = await zeroEx.exchange.fillOrderAsync(
+                signedOrder,
+                fillableAmount,
+                shouldThrowOnInsufficientBalanceOrAllowance,
+                takerAddress,
+            );
+            await zeroEx.awaitTransactionMinedAsync(txHash);
 
-			const differentMakerAddress = userAddresses[2];
-			const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				differentMakerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			txHash = await zeroEx.exchange.fillOrderAsync(
-				anotherSignedOrder,
-				fillableAmount,
-				shouldThrowOnInsufficientBalanceOrAllowance,
-				takerAddress,
-			);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
+            const differentMakerAddress = userAddresses[2];
+            const anotherSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                differentMakerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            txHash = await zeroEx.exchange.fillOrderAsync(
+                anotherSignedOrder,
+                fillableAmount,
+                shouldThrowOnInsufficientBalanceOrAllowance,
+                takerAddress,
+            );
+            await zeroEx.awaitTransactionMinedAsync(txHash);
 
-			const eventName = ExchangeEvents.LogFill;
-			const indexFilterValues = {
-				maker: differentMakerAddress,
-			};
-			const logs = await zeroEx.exchange.getLogsAsync<LogFillContractEventArgs>(
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(args.maker).to.be.equal(differentMakerAddress);
-		});
-	});
+            const eventName = ExchangeEvents.LogFill;
+            const indexFilterValues = {
+                maker: differentMakerAddress,
+            };
+            const logs = await zeroEx.exchange.getLogsAsync<LogFillContractEventArgs>(
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(args.maker).to.be.equal(differentMakerAddress);
+        });
+    });
 }); // tslint:disable:max-file-line-count
diff --git a/packages/0x.js/test/expiration_watcher_test.ts b/packages/0x.js/test/expiration_watcher_test.ts
index a76d84da1..770615f88 100644
--- a/packages/0x.js/test/expiration_watcher_test.ts
+++ b/packages/0x.js/test/expiration_watcher_test.ts
@@ -24,137 +24,137 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(testConstants.RPC_URL);
 
 describe('ExpirationWatcher', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let tokenUtils: TokenUtils;
-	let tokens: Token[];
-	let userAddresses: string[];
-	let zrxTokenAddress: string;
-	let fillScenarios: FillScenarios;
-	let exchangeContractAddress: string;
-	let makerTokenAddress: string;
-	let takerTokenAddress: string;
-	let coinbase: string;
-	let makerAddress: string;
-	let takerAddress: string;
-	let feeRecipient: string;
-	const fillableAmount = new BigNumber(5);
-	let currentUnixTimestampSec: BigNumber;
-	let timer: Sinon.SinonFakeTimers;
-	let expirationWatcher: ExpirationWatcher;
-	before(async () => {
-		web3 = web3Factory.create();
-		const config = {
-			networkId: constants.TESTRPC_NETWORK_ID,
-		};
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		exchangeContractAddress = zeroEx.exchange.getContractAddress();
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		tokenUtils = new TokenUtils(tokens);
-		zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-		fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-		[coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-		makerTokenAddress = makerToken.address;
-		takerTokenAddress = takerToken.address;
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-		const sinonTimerConfig = { shouldAdvanceTime: true } as any;
-		// This constructor has incorrect types
-		timer = Sinon.useFakeTimers(sinonTimerConfig);
-		currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
-		expirationWatcher = new ExpirationWatcher();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-		timer.restore();
-		expirationWatcher.unsubscribe();
-	});
-	it('correctly emits events when order expires', (done: DoneCallback) => {
-		(async () => {
-			const orderLifetimeSec = 60;
-			const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				expirationUnixTimestampSec,
-			);
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-			const callbackAsync = reportNoErrorCallbackErrors(done)((hash: string) => {
-				expect(hash).to.be.equal(orderHash);
-				expect(utils.getCurrentUnixTimestampSec()).to.be.bignumber.gte(expirationUnixTimestampSec);
-			});
-			expirationWatcher.subscribe(callbackAsync);
-			timer.tick(orderLifetimeSec * 1000);
-		})().catch(done);
-	});
-	it("doesn't emit events before order expires", (done: DoneCallback) => {
-		(async () => {
-			const orderLifetimeSec = 60;
-			const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				expirationUnixTimestampSec,
-			);
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
-			const callbackAsync = reportNoErrorCallbackErrors(done)(async (hash: string) => {
-				done(new Error('Emitted expiration went before the order actually expired'));
-			});
-			expirationWatcher.subscribe(callbackAsync);
-			const notEnoughTime = orderLifetimeSec - 1;
-			timer.tick(notEnoughTime * 1000);
-			done();
-		})().catch(done);
-	});
-	it('emits events in correct order', (done: DoneCallback) => {
-		(async () => {
-			const order1Lifetime = 60;
-			const order2Lifetime = 120;
-			const order1ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order1Lifetime);
-			const order2ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order2Lifetime);
-			const signedOrder1 = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				order1ExpirationUnixTimestampSec,
-			);
-			const signedOrder2 = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				order2ExpirationUnixTimestampSec,
-			);
-			const orderHash1 = ZeroEx.getOrderHashHex(signedOrder1);
-			const orderHash2 = ZeroEx.getOrderHashHex(signedOrder2);
-			expirationWatcher.addOrder(orderHash2, signedOrder2.expirationUnixTimestampSec.times(1000));
-			expirationWatcher.addOrder(orderHash1, signedOrder1.expirationUnixTimestampSec.times(1000));
-			const expirationOrder = [orderHash1, orderHash2];
-			const expectToBeCalledOnce = false;
-			const callbackAsync = reportNoErrorCallbackErrors(done, expectToBeCalledOnce)((hash: string) => {
-				const orderHash = expirationOrder.shift();
-				expect(hash).to.be.equal(orderHash);
-				if (_.isEmpty(expirationOrder)) {
-					done();
-				}
-			});
-			expirationWatcher.subscribe(callbackAsync);
-			timer.tick(order2Lifetime * 1000);
-		})().catch(done);
-	});
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let tokenUtils: TokenUtils;
+    let tokens: Token[];
+    let userAddresses: string[];
+    let zrxTokenAddress: string;
+    let fillScenarios: FillScenarios;
+    let exchangeContractAddress: string;
+    let makerTokenAddress: string;
+    let takerTokenAddress: string;
+    let coinbase: string;
+    let makerAddress: string;
+    let takerAddress: string;
+    let feeRecipient: string;
+    const fillableAmount = new BigNumber(5);
+    let currentUnixTimestampSec: BigNumber;
+    let timer: Sinon.SinonFakeTimers;
+    let expirationWatcher: ExpirationWatcher;
+    before(async () => {
+        web3 = web3Factory.create();
+        const config = {
+            networkId: constants.TESTRPC_NETWORK_ID,
+        };
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        makerTokenAddress = makerToken.address;
+        takerTokenAddress = takerToken.address;
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+        const sinonTimerConfig = { shouldAdvanceTime: true } as any;
+        // This constructor has incorrect types
+        timer = Sinon.useFakeTimers(sinonTimerConfig);
+        currentUnixTimestampSec = utils.getCurrentUnixTimestampSec();
+        expirationWatcher = new ExpirationWatcher();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+        timer.restore();
+        expirationWatcher.unsubscribe();
+    });
+    it('correctly emits events when order expires', (done: DoneCallback) => {
+        (async () => {
+            const orderLifetimeSec = 60;
+            const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                expirationUnixTimestampSec,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
+            const callbackAsync = reportNoErrorCallbackErrors(done)((hash: string) => {
+                expect(hash).to.be.equal(orderHash);
+                expect(utils.getCurrentUnixTimestampSec()).to.be.bignumber.gte(expirationUnixTimestampSec);
+            });
+            expirationWatcher.subscribe(callbackAsync);
+            timer.tick(orderLifetimeSec * 1000);
+        })().catch(done);
+    });
+    it("doesn't emit events before order expires", (done: DoneCallback) => {
+        (async () => {
+            const orderLifetimeSec = 60;
+            const expirationUnixTimestampSec = currentUnixTimestampSec.plus(orderLifetimeSec);
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                expirationUnixTimestampSec,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            expirationWatcher.addOrder(orderHash, signedOrder.expirationUnixTimestampSec.times(1000));
+            const callbackAsync = reportNoErrorCallbackErrors(done)(async (hash: string) => {
+                done(new Error('Emitted expiration went before the order actually expired'));
+            });
+            expirationWatcher.subscribe(callbackAsync);
+            const notEnoughTime = orderLifetimeSec - 1;
+            timer.tick(notEnoughTime * 1000);
+            done();
+        })().catch(done);
+    });
+    it('emits events in correct order', (done: DoneCallback) => {
+        (async () => {
+            const order1Lifetime = 60;
+            const order2Lifetime = 120;
+            const order1ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order1Lifetime);
+            const order2ExpirationUnixTimestampSec = currentUnixTimestampSec.plus(order2Lifetime);
+            const signedOrder1 = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                order1ExpirationUnixTimestampSec,
+            );
+            const signedOrder2 = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                order2ExpirationUnixTimestampSec,
+            );
+            const orderHash1 = ZeroEx.getOrderHashHex(signedOrder1);
+            const orderHash2 = ZeroEx.getOrderHashHex(signedOrder2);
+            expirationWatcher.addOrder(orderHash2, signedOrder2.expirationUnixTimestampSec.times(1000));
+            expirationWatcher.addOrder(orderHash1, signedOrder1.expirationUnixTimestampSec.times(1000));
+            const expirationOrder = [orderHash1, orderHash2];
+            const expectToBeCalledOnce = false;
+            const callbackAsync = reportNoErrorCallbackErrors(done, expectToBeCalledOnce)((hash: string) => {
+                const orderHash = expirationOrder.shift();
+                expect(hash).to.be.equal(orderHash);
+                if (_.isEmpty(expirationOrder)) {
+                    done();
+                }
+            });
+            expirationWatcher.subscribe(callbackAsync);
+            timer.tick(order2Lifetime * 1000);
+        })().catch(done);
+    });
 });
diff --git a/packages/0x.js/test/order_state_watcher_test.ts b/packages/0x.js/test/order_state_watcher_test.ts
index 22ed80446..2e9202fe2 100644
--- a/packages/0x.js/test/order_state_watcher_test.ts
+++ b/packages/0x.js/test/order_state_watcher_test.ts
@@ -6,14 +6,14 @@ import 'mocha';
 import * as Web3 from 'web3';
 
 import {
-	ExchangeContractErrs,
-	OrderState,
-	OrderStateInvalid,
-	OrderStateValid,
-	SignedOrder,
-	Token,
-	ZeroEx,
-	ZeroExError,
+    ExchangeContractErrs,
+    OrderState,
+    OrderStateInvalid,
+    OrderStateValid,
+    SignedOrder,
+    Token,
+    ZeroEx,
+    ZeroExError,
 } from '../src';
 import { DoneCallback } from '../src/types';
 
@@ -31,528 +31,528 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 
 describe('OrderStateWatcher', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let tokens: Token[];
-	let tokenUtils: TokenUtils;
-	let fillScenarios: FillScenarios;
-	let userAddresses: string[];
-	let zrxTokenAddress: string;
-	let exchangeContractAddress: string;
-	let makerToken: Token;
-	let takerToken: Token;
-	let maker: string;
-	let taker: string;
-	let signedOrder: SignedOrder;
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	const decimals = constants.ZRX_DECIMALS;
-	const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		exchangeContractAddress = zeroEx.exchange.getContractAddress();
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		[, maker, taker] = userAddresses;
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		tokenUtils = new TokenUtils(tokens);
-		zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-		fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-		await fillScenarios.initTokenBalancesAsync();
-		[makerToken, takerToken] = tokenUtils.getDummyTokens();
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#removeOrder', async () => {
-		it('should successfully remove existing order', async () => {
-			signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerToken.address,
-				takerToken.address,
-				maker,
-				taker,
-				fillableAmount,
-			);
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			zeroEx.orderStateWatcher.addOrder(signedOrder);
-			expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.include({
-				[orderHash]: signedOrder,
-			});
-			let dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
-			expect(dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress]).to.have.keys(orderHash);
-			zeroEx.orderStateWatcher.removeOrder(orderHash);
-			expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.not.include({
-				[orderHash]: signedOrder,
-			});
-			dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
-			expect(dependentOrderHashes[signedOrder.maker]).to.be.undefined();
-		});
-		it('should no-op when removing a non-existing order', async () => {
-			signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerToken.address,
-				takerToken.address,
-				maker,
-				taker,
-				fillableAmount,
-			);
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			const nonExistentOrderHash = `0x${orderHash
-				.substr(2)
-				.split('')
-				.reverse()
-				.join('')}`;
-			zeroEx.orderStateWatcher.removeOrder(nonExistentOrderHash);
-		});
-	});
-	describe('#subscribe', async () => {
-		afterEach(async () => {
-			zeroEx.orderStateWatcher.unsubscribe();
-		});
-		it('should fail when trying to subscribe twice', async () => {
-			zeroEx.orderStateWatcher.subscribe(_.noop);
-			expect(() => zeroEx.orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
-		});
-	});
-	describe('tests with cleanup', async () => {
-		afterEach(async () => {
-			zeroEx.orderStateWatcher.unsubscribe();
-			const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-			zeroEx.orderStateWatcher.removeOrder(orderHash);
-		});
-		it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.false();
-					const invalidOrderState = orderState as OrderStateInvalid;
-					expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-					expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerAllowance);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
-			})().catch(done);
-		});
-		it('should not emit an orderState event when irrelevant Transfer event received', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					throw new Error('OrderState callback fired for irrelevant order');
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				const notTheMaker = userAddresses[0];
-				const anyRecipient = taker;
-				const transferAmount = new BigNumber(2);
-				await zeroEx.token.transferAsync(makerToken.address, notTheMaker, anyRecipient, transferAmount);
-				setTimeout(() => {
-					done();
-				}, TIMEOUT_MS);
-			})().catch(done);
-		});
-		it('should emit orderStateInvalid when maker moves balance backing watched order', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.false();
-					const invalidOrderState = orderState as OrderStateInvalid;
-					expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-					expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerBalance);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				const anyRecipient = taker;
-				const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
-				await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
-			})().catch(done);
-		});
-		it('should emit orderStateInvalid when watched order fully filled', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let tokens: Token[];
+    let tokenUtils: TokenUtils;
+    let fillScenarios: FillScenarios;
+    let userAddresses: string[];
+    let zrxTokenAddress: string;
+    let exchangeContractAddress: string;
+    let makerToken: Token;
+    let takerToken: Token;
+    let maker: string;
+    let taker: string;
+    let signedOrder: SignedOrder;
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    const decimals = constants.ZRX_DECIMALS;
+    const fillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        [, maker, taker] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        await fillScenarios.initTokenBalancesAsync();
+        [makerToken, takerToken] = tokenUtils.getDummyTokens();
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#removeOrder', async () => {
+        it('should successfully remove existing order', async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address,
+                takerToken.address,
+                maker,
+                taker,
+                fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.addOrder(signedOrder);
+            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.include({
+                [orderHash]: signedOrder,
+            });
+            let dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
+            expect(dependentOrderHashes[signedOrder.maker][signedOrder.makerTokenAddress]).to.have.keys(orderHash);
+            zeroEx.orderStateWatcher.removeOrder(orderHash);
+            expect((zeroEx.orderStateWatcher as any)._orderByOrderHash).to.not.include({
+                [orderHash]: signedOrder,
+            });
+            dependentOrderHashes = (zeroEx.orderStateWatcher as any)._dependentOrderHashes;
+            expect(dependentOrderHashes[signedOrder.maker]).to.be.undefined();
+        });
+        it('should no-op when removing a non-existing order', async () => {
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerToken.address,
+                takerToken.address,
+                maker,
+                taker,
+                fillableAmount,
+            );
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            const nonExistentOrderHash = `0x${orderHash
+                .substr(2)
+                .split('')
+                .reverse()
+                .join('')}`;
+            zeroEx.orderStateWatcher.removeOrder(nonExistentOrderHash);
+        });
+    });
+    describe('#subscribe', async () => {
+        afterEach(async () => {
+            zeroEx.orderStateWatcher.unsubscribe();
+        });
+        it('should fail when trying to subscribe twice', async () => {
+            zeroEx.orderStateWatcher.subscribe(_.noop);
+            expect(() => zeroEx.orderStateWatcher.subscribe(_.noop)).to.throw(ZeroExError.SubscriptionAlreadyPresent);
+        });
+    });
+    describe('tests with cleanup', async () => {
+        afterEach(async () => {
+            zeroEx.orderStateWatcher.unsubscribe();
+            const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+            zeroEx.orderStateWatcher.removeOrder(orderHash);
+        });
+        it('should emit orderStateInvalid when maker allowance set to 0 for watched order', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerAllowance);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, new BigNumber(0));
+            })().catch(done);
+        });
+        it('should not emit an orderState event when irrelevant Transfer event received', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    throw new Error('OrderState callback fired for irrelevant order');
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                const notTheMaker = userAddresses[0];
+                const anyRecipient = taker;
+                const transferAmount = new BigNumber(2);
+                await zeroEx.token.transferAsync(makerToken.address, notTheMaker, anyRecipient, transferAmount);
+                setTimeout(() => {
+                    done();
+                }, TIMEOUT_MS);
+            })().catch(done);
+        });
+        it('should emit orderStateInvalid when maker moves balance backing watched order', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.InsufficientMakerBalance);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                const anyRecipient = taker;
+                const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                await zeroEx.token.transferAsync(makerToken.address, maker, anyRecipient, makerBalance);
+            })().catch(done);
+        });
+        it('should emit orderStateInvalid when watched order fully filled', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.false();
-					const invalidOrderState = orderState as OrderStateInvalid;
-					expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-					expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
 
-				const shouldThrowOnInsufficientBalanceOrAllowance = true;
-				await zeroEx.exchange.fillOrderAsync(
-					signedOrder,
-					fillableAmount,
-					shouldThrowOnInsufficientBalanceOrAllowance,
-					taker,
-				);
-			})().catch(done);
-		});
-		it('should emit orderStateValid when watched order partially filled', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
+                const shouldThrowOnInsufficientBalanceOrAllowance = true;
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder,
+                    fillableAmount,
+                    shouldThrowOnInsufficientBalanceOrAllowance,
+                    taker,
+                );
+            })().catch(done);
+        });
+        it('should emit orderStateValid when watched order partially filled', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
 
-				const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
-				const fillAmountInBaseUnits = new BigNumber(2);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                const fillAmountInBaseUnits = new BigNumber(2);
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.true();
-					const validOrderState = orderState as OrderStateValid;
-					expect(validOrderState.orderHash).to.be.equal(orderHash);
-					const orderRelevantState = validOrderState.orderRelevantState;
-					const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
-					const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
-					expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-						remainingFillable,
-					);
-					expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-						remainingFillable,
-					);
-					expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				const shouldThrowOnInsufficientBalanceOrAllowance = true;
-				await zeroEx.exchange.fillOrderAsync(
-					signedOrder,
-					fillAmountInBaseUnits,
-					shouldThrowOnInsufficientBalanceOrAllowance,
-					taker,
-				);
-			})().catch(done);
-		});
-		it('should trigger the callback when orders backing ZRX allowance changes', (done: DoneCallback) => {
-			(async () => {
-				const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
-				const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), 18);
-				signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-					makerToken.address,
-					takerToken.address,
-					makerFee,
-					takerFee,
-					maker,
-					taker,
-					fillableAmount,
-					taker,
-				);
-				const callback = reportNodeCallbackErrors(done)();
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
-				zeroEx.orderStateWatcher.subscribe(callback);
-				await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, new BigNumber(0));
-			})().catch(done);
-		});
-		describe('remainingFillable(M|T)akerTokenAmount', () => {
-			it('should calculate correct remaining fillable', (done: DoneCallback) => {
-				(async () => {
-					const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), decimals);
-					const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), decimals);
-					signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-						makerToken.address,
-						takerToken.address,
-						maker,
-						taker,
-						makerFillableAmount,
-						takerFillableAmount,
-					);
-					const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-					const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						expect(orderState.isValid).to.be.true();
-						const validOrderState = orderState as OrderStateValid;
-						expect(validOrderState.orderHash).to.be.equal(orderHash);
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							ZeroEx.toBaseUnitAmount(new BigNumber(16), decimals),
-						);
-						expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-							ZeroEx.toBaseUnitAmount(new BigNumber(8), decimals),
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					const shouldThrowOnInsufficientBalanceOrAllowance = true;
-					await zeroEx.exchange.fillOrderAsync(
-						signedOrder,
-						fillAmountInBaseUnits,
-						shouldThrowOnInsufficientBalanceOrAllowance,
-						taker,
-					);
-				})().catch(done);
-			});
-			it('should equal approved amount when approved amount is lowest', (done: DoneCallback) => {
-				(async () => {
-					signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerToken.address,
-						takerToken.address,
-						maker,
-						taker,
-						fillableAmount,
-					);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.true();
+                    const validOrderState = orderState as OrderStateValid;
+                    expect(validOrderState.orderHash).to.be.equal(orderHash);
+                    const orderRelevantState = validOrderState.orderRelevantState;
+                    const remainingMakerBalance = makerBalance.sub(fillAmountInBaseUnits);
+                    const remainingFillable = fillableAmount.minus(fillAmountInBaseUnits);
+                    expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                        remainingFillable,
+                    );
+                    expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                        remainingFillable,
+                    );
+                    expect(orderRelevantState.makerBalance).to.be.bignumber.equal(remainingMakerBalance);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                const shouldThrowOnInsufficientBalanceOrAllowance = true;
+                await zeroEx.exchange.fillOrderAsync(
+                    signedOrder,
+                    fillAmountInBaseUnits,
+                    shouldThrowOnInsufficientBalanceOrAllowance,
+                    taker,
+                );
+            })().catch(done);
+        });
+        it('should trigger the callback when orders backing ZRX allowance changes', (done: DoneCallback) => {
+            (async () => {
+                const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), 18);
+                const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), 18);
+                signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    makerFee,
+                    takerFee,
+                    maker,
+                    taker,
+                    fillableAmount,
+                    taker,
+                );
+                const callback = reportNodeCallbackErrors(done)();
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, new BigNumber(0));
+            })().catch(done);
+        });
+        describe('remainingFillable(M|T)akerTokenAmount', () => {
+            it('should calculate correct remaining fillable', (done: DoneCallback) => {
+                (async () => {
+                    const takerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(10), decimals);
+                    const makerFillableAmount = ZeroEx.toBaseUnitAmount(new BigNumber(20), decimals);
+                    signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        maker,
+                        taker,
+                        makerFillableAmount,
+                        takerFillableAmount,
+                    );
+                    const fillAmountInBaseUnits = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+                    const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        expect(orderState.isValid).to.be.true();
+                        const validOrderState = orderState as OrderStateValid;
+                        expect(validOrderState.orderHash).to.be.equal(orderHash);
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            ZeroEx.toBaseUnitAmount(new BigNumber(16), decimals),
+                        );
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            ZeroEx.toBaseUnitAmount(new BigNumber(8), decimals),
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    const shouldThrowOnInsufficientBalanceOrAllowance = true;
+                    await zeroEx.exchange.fillOrderAsync(
+                        signedOrder,
+                        fillAmountInBaseUnits,
+                        shouldThrowOnInsufficientBalanceOrAllowance,
+                        taker,
+                    );
+                })().catch(done);
+            });
+            it('should equal approved amount when approved amount is lowest', (done: DoneCallback) => {
+                (async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        maker,
+                        taker,
+                        fillableAmount,
+                    );
 
-					const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const changedMakerApprovalAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						const validOrderState = orderState as OrderStateValid;
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							changedMakerApprovalAmount,
-						);
-						expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-							changedMakerApprovalAmount,
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, changedMakerApprovalAmount);
-				})().catch(done);
-			});
-			it('should equal balance amount when balance amount is lowest', (done: DoneCallback) => {
-				(async () => {
-					signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-						makerToken.address,
-						takerToken.address,
-						maker,
-						taker,
-						fillableAmount,
-					);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            changedMakerApprovalAmount,
+                        );
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            changedMakerApprovalAmount,
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    await zeroEx.token.setProxyAllowanceAsync(makerToken.address, maker, changedMakerApprovalAmount);
+                })().catch(done);
+            });
+            it('should equal balance amount when balance amount is lowest', (done: DoneCallback) => {
+                (async () => {
+                    signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        maker,
+                        taker,
+                        fillableAmount,
+                    );
 
-					const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
+                    const makerBalance = await zeroEx.token.getBalanceAsync(makerToken.address, maker);
 
-					const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-					const transferAmount = makerBalance.sub(remainingAmount);
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const remainingAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
+                    const transferAmount = makerBalance.sub(remainingAmount);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						expect(orderState.isValid).to.be.true();
-						const validOrderState = orderState as OrderStateValid;
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							remainingAmount,
-						);
-						expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
-							remainingAmount,
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					await zeroEx.token.transferAsync(makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
-				})().catch(done);
-			});
-			it('should equal remaining amount when partially cancelled and order has fees', (done: DoneCallback) => {
-				(async () => {
-					const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-					const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-					const feeRecipient = taker;
-					signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-						makerToken.address,
-						takerToken.address,
-						makerFee,
-						takerFee,
-						maker,
-						taker,
-						fillableAmount,
-						feeRecipient,
-					);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        expect(orderState.isValid).to.be.true();
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            remainingAmount,
+                        );
+                        expect(orderRelevantState.remainingFillableTakerTokenAmount).to.be.bignumber.equal(
+                            remainingAmount,
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    await zeroEx.token.transferAsync(makerToken.address, maker, ZeroEx.NULL_ADDRESS, transferAmount);
+                })().catch(done);
+            });
+            it('should equal remaining amount when partially cancelled and order has fees', (done: DoneCallback) => {
+                (async () => {
+                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
+                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
+                    const feeRecipient = taker;
+                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        makerFee,
+                        takerFee,
+                        maker,
+                        taker,
+                        fillableAmount,
+                        feeRecipient,
+                    );
 
-					const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-					const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
+                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						expect(orderState.isValid).to.be.true();
-						const validOrderState = orderState as OrderStateValid;
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							remainingTokenAmount,
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					await zeroEx.exchange.cancelOrderAsync(signedOrder, transferTokenAmount);
-				})().catch(done);
-			});
-			it('should equal ratio amount when fee balance is lowered', (done: DoneCallback) => {
-				(async () => {
-					const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-					const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
-					const feeRecipient = taker;
-					signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-						makerToken.address,
-						takerToken.address,
-						makerFee,
-						takerFee,
-						maker,
-						taker,
-						fillableAmount,
-						feeRecipient,
-					);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        expect(orderState.isValid).to.be.true();
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            remainingTokenAmount,
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    await zeroEx.exchange.cancelOrderAsync(signedOrder, transferTokenAmount);
+                })().catch(done);
+            });
+            it('should equal ratio amount when fee balance is lowered', (done: DoneCallback) => {
+                (async () => {
+                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
+                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals);
+                    const feeRecipient = taker;
+                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        makerFee,
+                        takerFee,
+                        maker,
+                        taker,
+                        fillableAmount,
+                        feeRecipient,
+                    );
 
-					const remainingFeeAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
+                    const remainingFeeAmount = ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals);
 
-					const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
-					const transferTokenAmount = makerFee.sub(remainingTokenAmount);
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const remainingTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(4), decimals);
+                    const transferTokenAmount = makerFee.sub(remainingTokenAmount);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						const validOrderState = orderState as OrderStateValid;
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							remainingFeeAmount,
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, remainingFeeAmount);
-					await zeroEx.token.transferAsync(
-						makerToken.address,
-						maker,
-						ZeroEx.NULL_ADDRESS,
-						transferTokenAmount,
-					);
-				})().catch(done);
-			});
-			it('should calculate full amount when all available and non-divisible', (done: DoneCallback) => {
-				(async () => {
-					const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
-					const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-					const feeRecipient = taker;
-					signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-						makerToken.address,
-						takerToken.address,
-						makerFee,
-						takerFee,
-						maker,
-						taker,
-						fillableAmount,
-						feeRecipient,
-					);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            remainingFeeAmount,
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    await zeroEx.token.setProxyAllowanceAsync(zrxTokenAddress, maker, remainingFeeAmount);
+                    await zeroEx.token.transferAsync(
+                        makerToken.address,
+                        maker,
+                        ZeroEx.NULL_ADDRESS,
+                        transferTokenAmount,
+                    );
+                })().catch(done);
+            });
+            it('should calculate full amount when all available and non-divisible', (done: DoneCallback) => {
+                (async () => {
+                    const takerFee = ZeroEx.toBaseUnitAmount(new BigNumber(0), decimals);
+                    const makerFee = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+                    const feeRecipient = taker;
+                    signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                        makerToken.address,
+                        takerToken.address,
+                        makerFee,
+                        takerFee,
+                        maker,
+                        taker,
+                        fillableAmount,
+                        feeRecipient,
+                    );
 
-					zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-					const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-						const validOrderState = orderState as OrderStateValid;
-						const orderRelevantState = validOrderState.orderRelevantState;
-						expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
-							fillableAmount,
-						);
-					});
-					zeroEx.orderStateWatcher.subscribe(callback);
-					await zeroEx.token.setProxyAllowanceAsync(
-						makerToken.address,
-						maker,
-						ZeroEx.toBaseUnitAmount(new BigNumber(100), decimals),
-					);
-				})().catch(done);
-			});
-		});
-		it('should emit orderStateInvalid when watched order cancelled', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
+                    const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                        const validOrderState = orderState as OrderStateValid;
+                        const orderRelevantState = validOrderState.orderRelevantState;
+                        expect(orderRelevantState.remainingFillableMakerTokenAmount).to.be.bignumber.equal(
+                            fillableAmount,
+                        );
+                    });
+                    zeroEx.orderStateWatcher.subscribe(callback);
+                    await zeroEx.token.setProxyAllowanceAsync(
+                        makerToken.address,
+                        maker,
+                        ZeroEx.toBaseUnitAmount(new BigNumber(100), decimals),
+                    );
+                })().catch(done);
+            });
+        });
+        it('should emit orderStateInvalid when watched order cancelled', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.false();
-					const invalidOrderState = orderState as OrderStateInvalid;
-					expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-					expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderRemainingFillAmountZero);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
 
-				await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-			})().catch(done);
-		});
-		it('should emit orderStateInvalid when within rounding error range', (done: DoneCallback) => {
-			(async () => {
-				const remainingFillableAmountInBaseUnits = new BigNumber(100);
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            })().catch(done);
+        });
+        it('should emit orderStateInvalid when within rounding error range', (done: DoneCallback) => {
+            (async () => {
+                const remainingFillableAmountInBaseUnits = new BigNumber(100);
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.false();
-					const invalidOrderState = orderState as OrderStateInvalid;
-					expect(invalidOrderState.orderHash).to.be.equal(orderHash);
-					expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				await zeroEx.exchange.cancelOrderAsync(
-					signedOrder,
-					fillableAmount.minus(remainingFillableAmountInBaseUnits),
-				);
-			})().catch(done);
-		});
-		it('should emit orderStateValid when watched order partially cancelled', (done: DoneCallback) => {
-			(async () => {
-				signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-					makerToken.address,
-					takerToken.address,
-					maker,
-					taker,
-					fillableAmount,
-				);
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.false();
+                    const invalidOrderState = orderState as OrderStateInvalid;
+                    expect(invalidOrderState.orderHash).to.be.equal(orderHash);
+                    expect(invalidOrderState.error).to.be.equal(ExchangeContractErrs.OrderFillRoundingError);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.exchange.cancelOrderAsync(
+                    signedOrder,
+                    fillableAmount.minus(remainingFillableAmountInBaseUnits),
+                );
+            })().catch(done);
+        });
+        it('should emit orderStateValid when watched order partially cancelled', (done: DoneCallback) => {
+            (async () => {
+                signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                    makerToken.address,
+                    takerToken.address,
+                    maker,
+                    taker,
+                    fillableAmount,
+                );
 
-				const cancelAmountInBaseUnits = new BigNumber(2);
-				const orderHash = ZeroEx.getOrderHashHex(signedOrder);
-				zeroEx.orderStateWatcher.addOrder(signedOrder);
+                const cancelAmountInBaseUnits = new BigNumber(2);
+                const orderHash = ZeroEx.getOrderHashHex(signedOrder);
+                zeroEx.orderStateWatcher.addOrder(signedOrder);
 
-				const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
-					expect(orderState.isValid).to.be.true();
-					const validOrderState = orderState as OrderStateValid;
-					expect(validOrderState.orderHash).to.be.equal(orderHash);
-					const orderRelevantState = validOrderState.orderRelevantState;
-					expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
-				});
-				zeroEx.orderStateWatcher.subscribe(callback);
-				await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
-			})().catch(done);
-		});
-	});
+                const callback = reportNodeCallbackErrors(done)((orderState: OrderState) => {
+                    expect(orderState.isValid).to.be.true();
+                    const validOrderState = orderState as OrderStateValid;
+                    expect(validOrderState.orderHash).to.be.equal(orderHash);
+                    const orderRelevantState = validOrderState.orderRelevantState;
+                    expect(orderRelevantState.cancelledTakerTokenAmount).to.be.bignumber.equal(cancelAmountInBaseUnits);
+                });
+                zeroEx.orderStateWatcher.subscribe(callback);
+                await zeroEx.exchange.cancelOrderAsync(signedOrder, cancelAmountInBaseUnits);
+            })().catch(done);
+        });
+    });
 }); // tslint:disable:max-file-line-count
diff --git a/packages/0x.js/test/order_validation_test.ts b/packages/0x.js/test/order_validation_test.ts
index 4e023a9cc..be3e0590c 100644
--- a/packages/0x.js/test/order_validation_test.ts
+++ b/packages/0x.js/test/order_validation_test.ts
@@ -20,455 +20,455 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 
 describe('OrderValidation', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let userAddresses: string[];
-	let tokens: Token[];
-	let tokenUtils: TokenUtils;
-	let exchangeContractAddress: string;
-	let zrxTokenAddress: string;
-	let fillScenarios: FillScenarios;
-	let makerTokenAddress: string;
-	let takerTokenAddress: string;
-	let coinbase: string;
-	let makerAddress: string;
-	let takerAddress: string;
-	let feeRecipient: string;
-	const fillableAmount = new BigNumber(5);
-	const fillTakerAmount = new BigNumber(5);
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		exchangeContractAddress = zeroEx.exchange.getContractAddress();
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		[coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		tokenUtils = new TokenUtils(tokens);
-		zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
-		fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
-		const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-		makerTokenAddress = makerToken.address;
-		takerTokenAddress = takerToken.address;
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('validateOrderFillableOrThrowAsync', () => {
-		it('should succeed if the order is fillable', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
-		});
-		it('should succeed if the order is asymmetric and fillable', async () => {
-			const makerFillableAmount = fillableAmount;
-			const takerFillableAmount = fillableAmount.minus(4);
-			const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				makerFillableAmount,
-				takerFillableAmount,
-			);
-			await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
-		});
-		it('should throw when the order is fully filled or cancelled', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-			return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
-				ExchangeContractErrs.OrderRemainingFillAmountZero,
-			);
-		});
-		it('should throw when order is expired', async () => {
-			const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				expirationInPast,
-			);
-			return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
-				ExchangeContractErrs.OrderFillExpired,
-			);
-		});
-	});
-	describe('validateFillOrderAndThrowIfInvalidAsync', () => {
-		it('should throw when the fill amount is zero', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			const zeroFillAmount = new BigNumber(0);
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, zeroFillAmount, takerAddress),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
-		});
-		it('should throw when the signature is invalid', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			// 27 <--> 28
-			signedOrder.ecSignature.v = 28 - signedOrder.ecSignature.v + 27;
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
-			).to.be.rejectedWith(ZeroExError.InvalidSignature);
-		});
-		it('should throw when the order is fully filled or cancelled', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
-		});
-		it('should throw when sender is not a taker', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			const nonTakerAddress = userAddresses[6];
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, nonTakerAddress),
-			).to.be.rejectedWith(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
-		});
-		it('should throw when order is expired', async () => {
-			const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				expirationInPast,
-			);
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, takerAddress),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
-		});
-		it('should throw when there a rounding error would have occurred', async () => {
-			const makerAmount = new BigNumber(3);
-			const takerAmount = new BigNumber(5);
-			const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				makerAmount,
-				takerAmount,
-			);
-			const fillTakerAmountThatCausesRoundingError = new BigNumber(3);
-			return expect(
-				zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
-					signedOrder,
-					fillTakerAmountThatCausesRoundingError,
-					takerAddress,
-				),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderFillRoundingError);
-		});
-	});
-	describe('#validateFillOrKillOrderAndThrowIfInvalidAsync', () => {
-		it('should throw if remaining fillAmount is less then the desired fillAmount', async () => {
-			const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-			const tooLargeFillAmount = new BigNumber(7);
-			const fillAmountDifference = tooLargeFillAmount.minus(fillableAmount);
-			await zeroEx.token.transferAsync(takerTokenAddress, coinbase, takerAddress, fillAmountDifference);
-			await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress, tooLargeFillAmount);
-			await zeroEx.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
-			await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let userAddresses: string[];
+    let tokens: Token[];
+    let tokenUtils: TokenUtils;
+    let exchangeContractAddress: string;
+    let zrxTokenAddress: string;
+    let fillScenarios: FillScenarios;
+    let makerTokenAddress: string;
+    let takerTokenAddress: string;
+    let coinbase: string;
+    let makerAddress: string;
+    let takerAddress: string;
+    let feeRecipient: string;
+    const fillableAmount = new BigNumber(5);
+    const fillTakerAmount = new BigNumber(5);
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        exchangeContractAddress = zeroEx.exchange.getContractAddress();
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        [coinbase, makerAddress, takerAddress, feeRecipient] = userAddresses;
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        zrxTokenAddress = tokenUtils.getProtocolTokenOrThrow().address;
+        fillScenarios = new FillScenarios(zeroEx, userAddresses, tokens, zrxTokenAddress, exchangeContractAddress);
+        const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+        makerTokenAddress = makerToken.address;
+        takerTokenAddress = takerToken.address;
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('validateOrderFillableOrThrowAsync', () => {
+        it('should succeed if the order is fillable', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+        });
+        it('should succeed if the order is asymmetric and fillable', async () => {
+            const makerFillableAmount = fillableAmount;
+            const takerFillableAmount = fillableAmount.minus(4);
+            const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                makerFillableAmount,
+                takerFillableAmount,
+            );
+            await zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder);
+        });
+        it('should throw when the order is fully filled or cancelled', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
+                ExchangeContractErrs.OrderRemainingFillAmountZero,
+            );
+        });
+        it('should throw when order is expired', async () => {
+            const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                expirationInPast,
+            );
+            return expect(zeroEx.exchange.validateOrderFillableOrThrowAsync(signedOrder)).to.be.rejectedWith(
+                ExchangeContractErrs.OrderFillExpired,
+            );
+        });
+    });
+    describe('validateFillOrderAndThrowIfInvalidAsync', () => {
+        it('should throw when the fill amount is zero', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            const zeroFillAmount = new BigNumber(0);
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, zeroFillAmount, takerAddress),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillAmountZero);
+        });
+        it('should throw when the signature is invalid', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            // 27 <--> 28
+            signedOrder.ecSignature.v = 28 - signedOrder.ecSignature.v + 27;
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
+            ).to.be.rejectedWith(ZeroExError.InvalidSignature);
+        });
+        it('should throw when the order is fully filled or cancelled', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillableAmount, takerAddress),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderRemainingFillAmountZero);
+        });
+        it('should throw when sender is not a taker', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            const nonTakerAddress = userAddresses[6];
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, nonTakerAddress),
+            ).to.be.rejectedWith(ExchangeContractErrs.TransactionSenderIsNotFillOrderTaker);
+        });
+        it('should throw when order is expired', async () => {
+            const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                expirationInPast,
+            );
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(signedOrder, fillTakerAmount, takerAddress),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillExpired);
+        });
+        it('should throw when there a rounding error would have occurred', async () => {
+            const makerAmount = new BigNumber(3);
+            const takerAmount = new BigNumber(5);
+            const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                makerAmount,
+                takerAmount,
+            );
+            const fillTakerAmountThatCausesRoundingError = new BigNumber(3);
+            return expect(
+                zeroEx.exchange.validateFillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    fillTakerAmountThatCausesRoundingError,
+                    takerAddress,
+                ),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderFillRoundingError);
+        });
+    });
+    describe('#validateFillOrKillOrderAndThrowIfInvalidAsync', () => {
+        it('should throw if remaining fillAmount is less then the desired fillAmount', async () => {
+            const signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+            const tooLargeFillAmount = new BigNumber(7);
+            const fillAmountDifference = tooLargeFillAmount.minus(fillableAmount);
+            await zeroEx.token.transferAsync(takerTokenAddress, coinbase, takerAddress, fillAmountDifference);
+            await zeroEx.token.setProxyAllowanceAsync(takerTokenAddress, takerAddress, tooLargeFillAmount);
+            await zeroEx.token.transferAsync(makerTokenAddress, coinbase, makerAddress, fillAmountDifference);
+            await zeroEx.token.setProxyAllowanceAsync(makerTokenAddress, makerAddress, tooLargeFillAmount);
 
-			return expect(
-				zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
-					signedOrder,
-					tooLargeFillAmount,
-					takerAddress,
-				),
-			).to.be.rejectedWith(ExchangeContractErrs.InsufficientRemainingFillAmount);
-		});
-	});
-	describe('validateCancelOrderAndThrowIfInvalidAsync', () => {
-		let signedOrder: SignedOrder;
-		const cancelAmount = new BigNumber(3);
-		beforeEach(async () => {
-			[coinbase, makerAddress, takerAddress] = userAddresses;
-			const [makerToken, takerToken] = tokenUtils.getDummyTokens();
-			makerTokenAddress = makerToken.address;
-			takerTokenAddress = takerToken.address;
-			signedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-			);
-		});
-		it('should throw when cancel amount is zero', async () => {
-			const zeroCancelAmount = new BigNumber(0);
-			return expect(
-				zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
-		});
-		it('should throw when order is expired', async () => {
-			const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
-			const expiredSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				expirationInPast,
-			);
-			return expect(
-				zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(expiredSignedOrder, cancelAmount),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderCancelExpired);
-		});
-		it('should throw when order is already cancelled or filled', async () => {
-			await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
-			return expect(
-				zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount),
-			).to.be.rejectedWith(ExchangeContractErrs.OrderAlreadyCancelledOrFilled);
-		});
-	});
-	describe('#validateFillOrderBalancesAllowancesThrowIfInvalidAsync', () => {
-		let exchangeTransferSimulator: ExchangeTransferSimulator;
-		let transferFromAsync: Sinon.SinonSpy;
-		const bigNumberMatch = (expected: BigNumber) => {
-			return Sinon.match((value: BigNumber) => value.eq(expected));
-		};
-		beforeEach('create exchangeTransferSimulator', async () => {
-			exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
-			transferFromAsync = Sinon.spy();
-			exchangeTransferSimulator.transferFromAsync = transferFromAsync as any;
-		});
-		it('should call exchangeTransferSimulator.transferFrom in a correct order', async () => {
-			const makerFee = new BigNumber(2);
-			const takerFee = new BigNumber(2);
-			const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerFee,
-				takerFee,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				feeRecipient,
-			);
-			await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-				exchangeTransferSimulator,
-				signedOrder,
-				fillableAmount,
-				takerAddress,
-				zrxTokenAddress,
-			);
-			expect(transferFromAsync.callCount).to.be.equal(4);
-			expect(
-				transferFromAsync
-					.getCall(0)
-					.calledWith(
-						makerTokenAddress,
-						makerAddress,
-						takerAddress,
-						bigNumberMatch(fillableAmount),
-						TradeSide.Maker,
-						TransferType.Trade,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(1)
-					.calledWith(
-						takerTokenAddress,
-						takerAddress,
-						makerAddress,
-						bigNumberMatch(fillableAmount),
-						TradeSide.Taker,
-						TransferType.Trade,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(2)
-					.calledWith(
-						zrxTokenAddress,
-						makerAddress,
-						feeRecipient,
-						bigNumberMatch(makerFee),
-						TradeSide.Maker,
-						TransferType.Fee,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(3)
-					.calledWith(
-						zrxTokenAddress,
-						takerAddress,
-						feeRecipient,
-						bigNumberMatch(takerFee),
-						TradeSide.Taker,
-						TransferType.Fee,
-					),
-			).to.be.true();
-		});
-		it('should call exchangeTransferSimulator.transferFrom with correct values for an open order', async () => {
-			const makerFee = new BigNumber(2);
-			const takerFee = new BigNumber(2);
-			const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerFee,
-				takerFee,
-				makerAddress,
-				ZeroEx.NULL_ADDRESS,
-				fillableAmount,
-				feeRecipient,
-			);
-			await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-				exchangeTransferSimulator,
-				signedOrder,
-				fillableAmount,
-				takerAddress,
-				zrxTokenAddress,
-			);
-			expect(transferFromAsync.callCount).to.be.equal(4);
-			expect(
-				transferFromAsync
-					.getCall(0)
-					.calledWith(
-						makerTokenAddress,
-						makerAddress,
-						takerAddress,
-						bigNumberMatch(fillableAmount),
-						TradeSide.Maker,
-						TransferType.Trade,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(1)
-					.calledWith(
-						takerTokenAddress,
-						takerAddress,
-						makerAddress,
-						bigNumberMatch(fillableAmount),
-						TradeSide.Taker,
-						TransferType.Trade,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(2)
-					.calledWith(
-						zrxTokenAddress,
-						makerAddress,
-						feeRecipient,
-						bigNumberMatch(makerFee),
-						TradeSide.Maker,
-						TransferType.Fee,
-					),
-			).to.be.true();
-			expect(
-				transferFromAsync
-					.getCall(3)
-					.calledWith(
-						zrxTokenAddress,
-						takerAddress,
-						feeRecipient,
-						bigNumberMatch(takerFee),
-						TradeSide.Taker,
-						TransferType.Fee,
-					),
-			).to.be.true();
-		});
-		it('should correctly round the fillMakerTokenAmount', async () => {
-			const makerTokenAmount = new BigNumber(3);
-			const takerTokenAmount = new BigNumber(1);
-			const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerAddress,
-				takerAddress,
-				makerTokenAmount,
-				takerTokenAmount,
-			);
-			await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-				exchangeTransferSimulator,
-				signedOrder,
-				takerTokenAmount,
-				takerAddress,
-				zrxTokenAddress,
-			);
-			expect(transferFromAsync.callCount).to.be.equal(4);
-			const makerFillAmount = transferFromAsync.getCall(0).args[3];
-			expect(makerFillAmount).to.be.bignumber.equal(makerTokenAmount);
-		});
-		it('should correctly round the makerFeeAmount', async () => {
-			const makerFee = new BigNumber(2);
-			const takerFee = new BigNumber(4);
-			const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
-				makerTokenAddress,
-				takerTokenAddress,
-				makerFee,
-				takerFee,
-				makerAddress,
-				takerAddress,
-				fillableAmount,
-				ZeroEx.NULL_ADDRESS,
-			);
-			const fillTakerTokenAmount = fillableAmount.div(2).round(0);
-			await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
-				exchangeTransferSimulator,
-				signedOrder,
-				fillTakerTokenAmount,
-				takerAddress,
-				zrxTokenAddress,
-			);
-			const makerPartialFee = makerFee.div(2);
-			const takerPartialFee = takerFee.div(2);
-			expect(transferFromAsync.callCount).to.be.equal(4);
-			const partialMakerFee = transferFromAsync.getCall(2).args[3];
-			expect(partialMakerFee).to.be.bignumber.equal(makerPartialFee);
-			const partialTakerFee = transferFromAsync.getCall(3).args[3];
-			expect(partialTakerFee).to.be.bignumber.equal(takerPartialFee);
-		});
-	});
+            return expect(
+                zeroEx.exchange.validateFillOrKillOrderThrowIfInvalidAsync(
+                    signedOrder,
+                    tooLargeFillAmount,
+                    takerAddress,
+                ),
+            ).to.be.rejectedWith(ExchangeContractErrs.InsufficientRemainingFillAmount);
+        });
+    });
+    describe('validateCancelOrderAndThrowIfInvalidAsync', () => {
+        let signedOrder: SignedOrder;
+        const cancelAmount = new BigNumber(3);
+        beforeEach(async () => {
+            [coinbase, makerAddress, takerAddress] = userAddresses;
+            const [makerToken, takerToken] = tokenUtils.getDummyTokens();
+            makerTokenAddress = makerToken.address;
+            takerTokenAddress = takerToken.address;
+            signedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+            );
+        });
+        it('should throw when cancel amount is zero', async () => {
+            const zeroCancelAmount = new BigNumber(0);
+            return expect(
+                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, zeroCancelAmount),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelAmountZero);
+        });
+        it('should throw when order is expired', async () => {
+            const expirationInPast = new BigNumber(1496826058); // 7th Jun 2017
+            const expiredSignedOrder = await fillScenarios.createFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                expirationInPast,
+            );
+            return expect(
+                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(expiredSignedOrder, cancelAmount),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderCancelExpired);
+        });
+        it('should throw when order is already cancelled or filled', async () => {
+            await zeroEx.exchange.cancelOrderAsync(signedOrder, fillableAmount);
+            return expect(
+                zeroEx.exchange.validateCancelOrderThrowIfInvalidAsync(signedOrder, fillableAmount),
+            ).to.be.rejectedWith(ExchangeContractErrs.OrderAlreadyCancelledOrFilled);
+        });
+    });
+    describe('#validateFillOrderBalancesAllowancesThrowIfInvalidAsync', () => {
+        let exchangeTransferSimulator: ExchangeTransferSimulator;
+        let transferFromAsync: Sinon.SinonSpy;
+        const bigNumberMatch = (expected: BigNumber) => {
+            return Sinon.match((value: BigNumber) => value.eq(expected));
+        };
+        beforeEach('create exchangeTransferSimulator', async () => {
+            exchangeTransferSimulator = new ExchangeTransferSimulator(zeroEx.token, BlockParamLiteral.Latest);
+            transferFromAsync = Sinon.spy();
+            exchangeTransferSimulator.transferFromAsync = transferFromAsync as any;
+        });
+        it('should call exchangeTransferSimulator.transferFrom in a correct order', async () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerFee,
+                takerFee,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                feeRecipient,
+            );
+            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator,
+                signedOrder,
+                fillableAmount,
+                takerAddress,
+                zrxTokenAddress,
+            );
+            expect(transferFromAsync.callCount).to.be.equal(4);
+            expect(
+                transferFromAsync
+                    .getCall(0)
+                    .calledWith(
+                        makerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        bigNumberMatch(fillableAmount),
+                        TradeSide.Maker,
+                        TransferType.Trade,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(1)
+                    .calledWith(
+                        takerTokenAddress,
+                        takerAddress,
+                        makerAddress,
+                        bigNumberMatch(fillableAmount),
+                        TradeSide.Taker,
+                        TransferType.Trade,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(2)
+                    .calledWith(
+                        zrxTokenAddress,
+                        makerAddress,
+                        feeRecipient,
+                        bigNumberMatch(makerFee),
+                        TradeSide.Maker,
+                        TransferType.Fee,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(3)
+                    .calledWith(
+                        zrxTokenAddress,
+                        takerAddress,
+                        feeRecipient,
+                        bigNumberMatch(takerFee),
+                        TradeSide.Taker,
+                        TransferType.Fee,
+                    ),
+            ).to.be.true();
+        });
+        it('should call exchangeTransferSimulator.transferFrom with correct values for an open order', async () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(2);
+            const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerFee,
+                takerFee,
+                makerAddress,
+                ZeroEx.NULL_ADDRESS,
+                fillableAmount,
+                feeRecipient,
+            );
+            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator,
+                signedOrder,
+                fillableAmount,
+                takerAddress,
+                zrxTokenAddress,
+            );
+            expect(transferFromAsync.callCount).to.be.equal(4);
+            expect(
+                transferFromAsync
+                    .getCall(0)
+                    .calledWith(
+                        makerTokenAddress,
+                        makerAddress,
+                        takerAddress,
+                        bigNumberMatch(fillableAmount),
+                        TradeSide.Maker,
+                        TransferType.Trade,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(1)
+                    .calledWith(
+                        takerTokenAddress,
+                        takerAddress,
+                        makerAddress,
+                        bigNumberMatch(fillableAmount),
+                        TradeSide.Taker,
+                        TransferType.Trade,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(2)
+                    .calledWith(
+                        zrxTokenAddress,
+                        makerAddress,
+                        feeRecipient,
+                        bigNumberMatch(makerFee),
+                        TradeSide.Maker,
+                        TransferType.Fee,
+                    ),
+            ).to.be.true();
+            expect(
+                transferFromAsync
+                    .getCall(3)
+                    .calledWith(
+                        zrxTokenAddress,
+                        takerAddress,
+                        feeRecipient,
+                        bigNumberMatch(takerFee),
+                        TradeSide.Taker,
+                        TransferType.Fee,
+                    ),
+            ).to.be.true();
+        });
+        it('should correctly round the fillMakerTokenAmount', async () => {
+            const makerTokenAmount = new BigNumber(3);
+            const takerTokenAmount = new BigNumber(1);
+            const signedOrder = await fillScenarios.createAsymmetricFillableSignedOrderAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerAddress,
+                takerAddress,
+                makerTokenAmount,
+                takerTokenAmount,
+            );
+            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator,
+                signedOrder,
+                takerTokenAmount,
+                takerAddress,
+                zrxTokenAddress,
+            );
+            expect(transferFromAsync.callCount).to.be.equal(4);
+            const makerFillAmount = transferFromAsync.getCall(0).args[3];
+            expect(makerFillAmount).to.be.bignumber.equal(makerTokenAmount);
+        });
+        it('should correctly round the makerFeeAmount', async () => {
+            const makerFee = new BigNumber(2);
+            const takerFee = new BigNumber(4);
+            const signedOrder = await fillScenarios.createFillableSignedOrderWithFeesAsync(
+                makerTokenAddress,
+                takerTokenAddress,
+                makerFee,
+                takerFee,
+                makerAddress,
+                takerAddress,
+                fillableAmount,
+                ZeroEx.NULL_ADDRESS,
+            );
+            const fillTakerTokenAmount = fillableAmount.div(2).round(0);
+            await OrderValidationUtils.validateFillOrderBalancesAllowancesThrowIfInvalidAsync(
+                exchangeTransferSimulator,
+                signedOrder,
+                fillTakerTokenAmount,
+                takerAddress,
+                zrxTokenAddress,
+            );
+            const makerPartialFee = makerFee.div(2);
+            const takerPartialFee = takerFee.div(2);
+            expect(transferFromAsync.callCount).to.be.equal(4);
+            const partialMakerFee = transferFromAsync.getCall(2).args[3];
+            expect(partialMakerFee).to.be.bignumber.equal(makerPartialFee);
+            const partialTakerFee = transferFromAsync.getCall(3).args[3];
+            expect(partialTakerFee).to.be.bignumber.equal(takerPartialFee);
+        });
+    });
 });
diff --git a/packages/0x.js/test/remaining_fillable_calculator_test.ts b/packages/0x.js/test/remaining_fillable_calculator_test.ts
index 58e9dd93b..4c6b8f3ac 100644
--- a/packages/0x.js/test/remaining_fillable_calculator_test.ts
+++ b/packages/0x.js/test/remaining_fillable_calculator_test.ts
@@ -12,223 +12,223 @@ chaiSetup.configure();
 const expect = chai.expect;
 
 describe('RemainingFillableCalculator', () => {
-	let calculator: RemainingFillableCalculator;
-	let signedOrder: SignedOrder;
-	let transferrableMakerTokenAmount: BigNumber;
-	let transferrableMakerFeeTokenAmount: BigNumber;
-	let remainingMakerTokenAmount: BigNumber;
-	let makerAmount: BigNumber;
-	let takerAmount: BigNumber;
-	let makerFeeAmount: BigNumber;
-	let isMakerTokenZRX: boolean;
-	const makerToken: string = '0x1';
-	const takerToken: string = '0x2';
-	const decimals: number = 4;
-	const zero: BigNumber = new BigNumber(0);
-	const zeroAddress = '0x0';
-	const signature: ECSignature = { v: 27, r: '', s: '' };
-	beforeEach(async () => {
-		[makerAmount, takerAmount, makerFeeAmount] = [
-			ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
-			ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
-			ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals),
-		];
-		[transferrableMakerTokenAmount, transferrableMakerFeeTokenAmount] = [
-			ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
-			ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
-		];
-	});
-	function buildSignedOrder(): SignedOrder {
-		return {
-			ecSignature: signature,
-			exchangeContractAddress: zeroAddress,
-			feeRecipient: zeroAddress,
-			maker: zeroAddress,
-			taker: zeroAddress,
-			makerFee: makerFeeAmount,
-			takerFee: zero,
-			makerTokenAmount: makerAmount,
-			takerTokenAmount: takerAmount,
-			makerTokenAddress: makerToken,
-			takerTokenAddress: takerToken,
-			salt: zero,
-			expirationUnixTimestampSec: zero,
-		};
-	}
-	describe('Maker token is NOT ZRX', () => {
-		before(async () => {
-			isMakerTokenZRX = false;
-		});
-		it('calculates the correct amount when unfilled and funds available', () => {
-			signedOrder = buildSignedOrder();
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-		});
-		it('calculates the correct amount when partially filled and funds available', () => {
-			signedOrder = buildSignedOrder();
-			remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-		});
-		it('calculates the amount to be 0 when all fee funds are transferred', () => {
-			signedOrder = buildSignedOrder();
-			transferrableMakerFeeTokenAmount = zero;
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
-		});
-		it('calculates the correct amount when balance is less than remaining fillable', () => {
-			signedOrder = buildSignedOrder();
-			const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-			transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
-		});
-		describe('Order to Fee Ratio is < 1', () => {
-			beforeEach(async () => {
-				[makerAmount, takerAmount, makerFeeAmount] = [
-					ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
-					ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
-					ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
-				];
-			});
-			it('calculates the correct amount when funds unavailable', () => {
-				signedOrder = buildSignedOrder();
-				remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-				const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-				transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
-				calculator = new RemainingFillableCalculator(
-					signedOrder,
-					isMakerTokenZRX,
-					transferrableMakerTokenAmount,
-					transferrableMakerFeeTokenAmount,
-					remainingMakerTokenAmount,
-				);
-				expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
-			});
-		});
-		describe('Ratio is not evenly divisble', () => {
-			beforeEach(async () => {
-				[makerAmount, takerAmount, makerFeeAmount] = [
-					ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
-					ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
-					ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
-				];
-			});
-			it('calculates the correct amount when funds unavailable', () => {
-				signedOrder = buildSignedOrder();
-				remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-				const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-				transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
-				calculator = new RemainingFillableCalculator(
-					signedOrder,
-					isMakerTokenZRX,
-					transferrableMakerTokenAmount,
-					transferrableMakerFeeTokenAmount,
-					remainingMakerTokenAmount,
-				);
-				const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
-				expect(calculatedFillableAmount.lessThanOrEqualTo(transferrableMakerTokenAmount)).to.be.true();
-				expect(calculatedFillableAmount).to.be.bignumber.greaterThan(new BigNumber(0));
-				const orderToFeeRatio = signedOrder.makerTokenAmount.dividedBy(signedOrder.makerFee);
-				const calculatedFeeAmount = calculatedFillableAmount.dividedBy(orderToFeeRatio);
-				expect(calculatedFeeAmount).to.be.bignumber.lessThan(transferrableMakerFeeTokenAmount);
-			});
-		});
-	});
-	describe('Maker Token is ZRX', () => {
-		before(async () => {
-			isMakerTokenZRX = true;
-		});
-		it('calculates the correct amount when unfilled and funds available', () => {
-			signedOrder = buildSignedOrder();
-			transferrableMakerTokenAmount = makerAmount.plus(makerFeeAmount);
-			transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-		});
-		it('calculates the correct amount when partially filled and funds available', () => {
-			signedOrder = buildSignedOrder();
-			remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
-		});
-		it('calculates the amount to be 0 when all fee funds are transferred', () => {
-			signedOrder = buildSignedOrder();
-			transferrableMakerTokenAmount = zero;
-			transferrableMakerFeeTokenAmount = zero;
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount;
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
-		});
-		it('calculates the correct amount when balance is less than remaining fillable', () => {
-			signedOrder = buildSignedOrder();
-			const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
-			remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
-			transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
-			transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
+    let calculator: RemainingFillableCalculator;
+    let signedOrder: SignedOrder;
+    let transferrableMakerTokenAmount: BigNumber;
+    let transferrableMakerFeeTokenAmount: BigNumber;
+    let remainingMakerTokenAmount: BigNumber;
+    let makerAmount: BigNumber;
+    let takerAmount: BigNumber;
+    let makerFeeAmount: BigNumber;
+    let isMakerTokenZRX: boolean;
+    const makerToken: string = '0x1';
+    const takerToken: string = '0x2';
+    const decimals: number = 4;
+    const zero: BigNumber = new BigNumber(0);
+    const zeroAddress = '0x0';
+    const signature: ECSignature = { v: 27, r: '', s: '' };
+    beforeEach(async () => {
+        [makerAmount, takerAmount, makerFeeAmount] = [
+            ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
+            ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
+            ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals),
+        ];
+        [transferrableMakerTokenAmount, transferrableMakerFeeTokenAmount] = [
+            ZeroEx.toBaseUnitAmount(new BigNumber(50), decimals),
+            ZeroEx.toBaseUnitAmount(new BigNumber(5), decimals),
+        ];
+    });
+    function buildSignedOrder(): SignedOrder {
+        return {
+            ecSignature: signature,
+            exchangeContractAddress: zeroAddress,
+            feeRecipient: zeroAddress,
+            maker: zeroAddress,
+            taker: zeroAddress,
+            makerFee: makerFeeAmount,
+            takerFee: zero,
+            makerTokenAmount: makerAmount,
+            takerTokenAmount: takerAmount,
+            makerTokenAddress: makerToken,
+            takerTokenAddress: takerToken,
+            salt: zero,
+            expirationUnixTimestampSec: zero,
+        };
+    }
+    describe('Maker token is NOT ZRX', () => {
+        before(async () => {
+            isMakerTokenZRX = false;
+        });
+        it('calculates the correct amount when unfilled and funds available', () => {
+            signedOrder = buildSignedOrder();
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+        });
+        it('calculates the correct amount when partially filled and funds available', () => {
+            signedOrder = buildSignedOrder();
+            remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+        });
+        it('calculates the amount to be 0 when all fee funds are transferred', () => {
+            signedOrder = buildSignedOrder();
+            transferrableMakerFeeTokenAmount = zero;
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
+        });
+        it('calculates the correct amount when balance is less than remaining fillable', () => {
+            signedOrder = buildSignedOrder();
+            const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
+            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
+        });
+        describe('Order to Fee Ratio is < 1', () => {
+            beforeEach(async () => {
+                [makerAmount, takerAmount, makerFeeAmount] = [
+                    ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
+                    ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
+                    ZeroEx.toBaseUnitAmount(new BigNumber(6), decimals),
+                ];
+            });
+            it('calculates the correct amount when funds unavailable', () => {
+                signedOrder = buildSignedOrder();
+                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+                const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
+                calculator = new RemainingFillableCalculator(
+                    signedOrder,
+                    isMakerTokenZRX,
+                    transferrableMakerTokenAmount,
+                    transferrableMakerFeeTokenAmount,
+                    remainingMakerTokenAmount,
+                );
+                expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(transferrableMakerTokenAmount);
+            });
+        });
+        describe('Ratio is not evenly divisble', () => {
+            beforeEach(async () => {
+                [makerAmount, takerAmount, makerFeeAmount] = [
+                    ZeroEx.toBaseUnitAmount(new BigNumber(3), decimals),
+                    ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
+                    ZeroEx.toBaseUnitAmount(new BigNumber(7), decimals),
+                ];
+            });
+            it('calculates the correct amount when funds unavailable', () => {
+                signedOrder = buildSignedOrder();
+                remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+                const transferredAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+                transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(transferredAmount);
+                calculator = new RemainingFillableCalculator(
+                    signedOrder,
+                    isMakerTokenZRX,
+                    transferrableMakerTokenAmount,
+                    transferrableMakerFeeTokenAmount,
+                    remainingMakerTokenAmount,
+                );
+                const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
+                expect(calculatedFillableAmount.lessThanOrEqualTo(transferrableMakerTokenAmount)).to.be.true();
+                expect(calculatedFillableAmount).to.be.bignumber.greaterThan(new BigNumber(0));
+                const orderToFeeRatio = signedOrder.makerTokenAmount.dividedBy(signedOrder.makerFee);
+                const calculatedFeeAmount = calculatedFillableAmount.dividedBy(orderToFeeRatio);
+                expect(calculatedFeeAmount).to.be.bignumber.lessThan(transferrableMakerFeeTokenAmount);
+            });
+        });
+    });
+    describe('Maker Token is ZRX', () => {
+        before(async () => {
+            isMakerTokenZRX = true;
+        });
+        it('calculates the correct amount when unfilled and funds available', () => {
+            signedOrder = buildSignedOrder();
+            transferrableMakerTokenAmount = makerAmount.plus(makerFeeAmount);
+            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+        });
+        it('calculates the correct amount when partially filled and funds available', () => {
+            signedOrder = buildSignedOrder();
+            remainingMakerTokenAmount = ZeroEx.toBaseUnitAmount(new BigNumber(1), decimals);
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(remainingMakerTokenAmount);
+        });
+        it('calculates the amount to be 0 when all fee funds are transferred', () => {
+            signedOrder = buildSignedOrder();
+            transferrableMakerTokenAmount = zero;
+            transferrableMakerFeeTokenAmount = zero;
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount;
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            expect(calculator.computeRemainingMakerFillable()).to.be.bignumber.equal(zero);
+        });
+        it('calculates the correct amount when balance is less than remaining fillable', () => {
+            signedOrder = buildSignedOrder();
+            const partiallyFilledAmount = ZeroEx.toBaseUnitAmount(new BigNumber(2), decimals);
+            remainingMakerTokenAmount = signedOrder.makerTokenAmount.minus(partiallyFilledAmount);
+            transferrableMakerTokenAmount = remainingMakerTokenAmount.minus(partiallyFilledAmount);
+            transferrableMakerFeeTokenAmount = transferrableMakerTokenAmount;
 
-			const orderToFeeRatio = signedOrder.makerTokenAmount.dividedToIntegerBy(signedOrder.makerFee);
-			const expectedFillableAmount = new BigNumber(450980);
-			calculator = new RemainingFillableCalculator(
-				signedOrder,
-				isMakerTokenZRX,
-				transferrableMakerTokenAmount,
-				transferrableMakerFeeTokenAmount,
-				remainingMakerTokenAmount,
-			);
-			const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
-			const numberOfFillsInRatio = calculatedFillableAmount.dividedToIntegerBy(orderToFeeRatio);
-			const calculatedFillableAmountPlusFees = calculatedFillableAmount.plus(numberOfFillsInRatio);
-			expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(transferrableMakerTokenAmount);
-			expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(remainingMakerTokenAmount);
-			expect(calculatedFillableAmount).to.be.bignumber.equal(expectedFillableAmount);
-			expect(numberOfFillsInRatio.decimalPlaces()).to.be.equal(0);
-		});
-	});
+            const orderToFeeRatio = signedOrder.makerTokenAmount.dividedToIntegerBy(signedOrder.makerFee);
+            const expectedFillableAmount = new BigNumber(450980);
+            calculator = new RemainingFillableCalculator(
+                signedOrder,
+                isMakerTokenZRX,
+                transferrableMakerTokenAmount,
+                transferrableMakerFeeTokenAmount,
+                remainingMakerTokenAmount,
+            );
+            const calculatedFillableAmount = calculator.computeRemainingMakerFillable();
+            const numberOfFillsInRatio = calculatedFillableAmount.dividedToIntegerBy(orderToFeeRatio);
+            const calculatedFillableAmountPlusFees = calculatedFillableAmount.plus(numberOfFillsInRatio);
+            expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(transferrableMakerTokenAmount);
+            expect(calculatedFillableAmountPlusFees).to.be.bignumber.lessThan(remainingMakerTokenAmount);
+            expect(calculatedFillableAmount).to.be.bignumber.equal(expectedFillableAmount);
+            expect(numberOfFillsInRatio.decimalPlaces()).to.be.equal(0);
+        });
+    });
 });
diff --git a/packages/0x.js/test/subscription_test.ts b/packages/0x.js/test/subscription_test.ts
index f70ecd6cd..f4c6f748f 100644
--- a/packages/0x.js/test/subscription_test.ts
+++ b/packages/0x.js/test/subscription_test.ts
@@ -17,69 +17,69 @@ chaiSetup.configure();
 const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 
 describe('SubscriptionTest', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let userAddresses: string[];
-	let tokens: Token[];
-	let coinbase: string;
-	let addressWithoutFunds: string;
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		coinbase = userAddresses[0];
-		addressWithoutFunds = userAddresses[1];
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#subscribe', () => {
-		const indexFilterValues = {};
-		let tokenAddress: string;
-		const allowanceAmount = new BigNumber(42);
-		let stubs: Sinon.SinonStub[] = [];
-		before(() => {
-			const token = tokens[0];
-			tokenAddress = token.address;
-		});
-		afterEach(() => {
-			zeroEx.token.unsubscribeAll();
-			_.each(stubs, s => s.restore());
-			stubs = [];
-		});
-		it('Should receive the Error when an error occurs while fetching the block', (done: DoneCallback) => {
-			(async () => {
-				const errMsg = 'Error fetching block';
-				const callback = assertNodeCallbackError(done, errMsg);
-				stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error(errMsg))];
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-				await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-			})().catch(done);
-		});
-		it('Should receive the Error when an error occurs while reconciling the new block', (done: DoneCallback) => {
-			(async () => {
-				const errMsg = 'Error fetching logs';
-				const callback = assertNodeCallbackError(done, errMsg);
-				stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getLogsAsync').throws(new Error(errMsg))];
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-				await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-			})().catch(done);
-		});
-		it('Should allow unsubscribeAll to be called successfully after an error', (done: DoneCallback) => {
-			(async () => {
-				const callback = (err: Error | null, logEvent?: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-				stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error('JSON RPC error'))];
-				zeroEx.token.unsubscribeAll();
-				done();
-			})().catch(done);
-		});
-	});
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let userAddresses: string[];
+    let tokens: Token[];
+    let coinbase: string;
+    let addressWithoutFunds: string;
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        coinbase = userAddresses[0];
+        addressWithoutFunds = userAddresses[1];
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        let tokenAddress: string;
+        const allowanceAmount = new BigNumber(42);
+        let stubs: Sinon.SinonStub[] = [];
+        before(() => {
+            const token = tokens[0];
+            tokenAddress = token.address;
+        });
+        afterEach(() => {
+            zeroEx.token.unsubscribeAll();
+            _.each(stubs, s => s.restore());
+            stubs = [];
+        });
+        it('Should receive the Error when an error occurs while fetching the block', (done: DoneCallback) => {
+            (async () => {
+                const errMsg = 'Error fetching block';
+                const callback = assertNodeCallbackError(done, errMsg);
+                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error(errMsg))];
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+            })().catch(done);
+        });
+        it('Should receive the Error when an error occurs while reconciling the new block', (done: DoneCallback) => {
+            (async () => {
+                const errMsg = 'Error fetching logs';
+                const callback = assertNodeCallbackError(done, errMsg);
+                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getLogsAsync').throws(new Error(errMsg))];
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+            })().catch(done);
+        });
+        it('Should allow unsubscribeAll to be called successfully after an error', (done: DoneCallback) => {
+            (async () => {
+                const callback = (err: Error | null, logEvent?: DecodedLogEvent<ApprovalContractEventArgs>) => _.noop;
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                stubs = [Sinon.stub((zeroEx as any)._web3Wrapper, 'getBlockAsync').throws(new Error('JSON RPC error'))];
+                zeroEx.token.unsubscribeAll();
+                done();
+            })().catch(done);
+        });
+    });
 });
diff --git a/packages/0x.js/test/token_registry_wrapper_test.ts b/packages/0x.js/test/token_registry_wrapper_test.ts
index c798c00d7..0a170db8f 100644
--- a/packages/0x.js/test/token_registry_wrapper_test.ts
+++ b/packages/0x.js/test/token_registry_wrapper_test.ts
@@ -17,113 +17,113 @@ const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 const TOKEN_REGISTRY_SIZE_AFTER_MIGRATION = 7;
 
 describe('TokenRegistryWrapper', () => {
-	let zeroEx: ZeroEx;
-	let tokens: Token[];
-	const tokenAddressBySymbol: { [symbol: string]: string } = {};
-	const tokenAddressByName: { [symbol: string]: string } = {};
-	const tokenBySymbol: { [symbol: string]: Token } = {};
-	const tokenByName: { [symbol: string]: Token } = {};
-	const registeredSymbol = 'ZRX';
-	const registeredName = '0x Protocol Token';
-	const unregisteredSymbol = 'MAL';
-	const unregisteredName = 'Malicious Token';
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		const web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		_.map(tokens, token => {
-			tokenAddressBySymbol[token.symbol] = token.address;
-			tokenAddressByName[token.name] = token.address;
-			tokenBySymbol[token.symbol] = token;
-			tokenByName[token.name] = token;
-		});
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#getTokensAsync', () => {
-		it('should return all the tokens added to the tokenRegistry during the migration', async () => {
-			expect(tokens).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
+    let zeroEx: ZeroEx;
+    let tokens: Token[];
+    const tokenAddressBySymbol: { [symbol: string]: string } = {};
+    const tokenAddressByName: { [symbol: string]: string } = {};
+    const tokenBySymbol: { [symbol: string]: Token } = {};
+    const tokenByName: { [symbol: string]: Token } = {};
+    const registeredSymbol = 'ZRX';
+    const registeredName = '0x Protocol Token';
+    const unregisteredSymbol = 'MAL';
+    const unregisteredName = 'Malicious Token';
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        const web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        _.map(tokens, token => {
+            tokenAddressBySymbol[token.symbol] = token.address;
+            tokenAddressByName[token.name] = token.address;
+            tokenBySymbol[token.symbol] = token;
+            tokenByName[token.name] = token;
+        });
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#getTokensAsync', () => {
+        it('should return all the tokens added to the tokenRegistry during the migration', async () => {
+            expect(tokens).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
 
-			const schemaValidator = new SchemaValidator();
-			_.each(tokens, token => {
-				const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
-				expect(validationResult.errors).to.have.lengthOf(0);
-			});
-		});
-	});
-	describe('#getTokenAddressesAsync', () => {
-		it('should return all the token addresses added to the tokenRegistry during the migration', async () => {
-			const tokenAddresses = await zeroEx.tokenRegistry.getTokenAddressesAsync();
-			expect(tokenAddresses).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
+            const schemaValidator = new SchemaValidator();
+            _.each(tokens, token => {
+                const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
+                expect(validationResult.errors).to.have.lengthOf(0);
+            });
+        });
+    });
+    describe('#getTokenAddressesAsync', () => {
+        it('should return all the token addresses added to the tokenRegistry during the migration', async () => {
+            const tokenAddresses = await zeroEx.tokenRegistry.getTokenAddressesAsync();
+            expect(tokenAddresses).to.have.lengthOf(TOKEN_REGISTRY_SIZE_AFTER_MIGRATION);
 
-			const schemaValidator = new SchemaValidator();
-			_.each(tokenAddresses, tokenAddress => {
-				const validationResult = schemaValidator.validate(tokenAddress, schemas.addressSchema);
-				expect(validationResult.errors).to.have.lengthOf(0);
-				expect(tokenAddress).to.not.be.equal(ZeroEx.NULL_ADDRESS);
-			});
-		});
-	});
-	describe('#getTokenAddressBySymbol', () => {
-		it('should return correct address for a token in the registry', async () => {
-			const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(registeredSymbol);
-			expect(tokenAddress).to.be.equal(tokenAddressBySymbol[registeredSymbol]);
-		});
-		it('should return undefined for a token out of registry', async () => {
-			const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(unregisteredSymbol);
-			expect(tokenAddress).to.be.undefined();
-		});
-	});
-	describe('#getTokenAddressByName', () => {
-		it('should return correct address for a token in the registry', async () => {
-			const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(registeredName);
-			expect(tokenAddress).to.be.equal(tokenAddressByName[registeredName]);
-		});
-		it('should return undefined for a token out of registry', async () => {
-			const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(unregisteredName);
-			expect(tokenAddress).to.be.undefined();
-		});
-	});
-	describe('#getTokenBySymbol', () => {
-		it('should return correct token for a token in the registry', async () => {
-			const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(registeredSymbol);
-			expect(token).to.be.deep.equal(tokenBySymbol[registeredSymbol]);
-		});
-		it('should return undefined for a token out of registry', async () => {
-			const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(unregisteredSymbol);
-			expect(token).to.be.undefined();
-		});
-	});
-	describe('#getTokenByName', () => {
-		it('should return correct token for a token in the registry', async () => {
-			const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(registeredName);
-			expect(token).to.be.deep.equal(tokenByName[registeredName]);
-		});
-		it('should return undefined for a token out of registry', async () => {
-			const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(unregisteredName);
-			expect(token).to.be.undefined();
-		});
-	});
-	describe('#getTokenIfExistsAsync', () => {
-		it('should return the token added to the tokenRegistry during the migration', async () => {
-			const aToken = tokens[0];
+            const schemaValidator = new SchemaValidator();
+            _.each(tokenAddresses, tokenAddress => {
+                const validationResult = schemaValidator.validate(tokenAddress, schemas.addressSchema);
+                expect(validationResult.errors).to.have.lengthOf(0);
+                expect(tokenAddress).to.not.be.equal(ZeroEx.NULL_ADDRESS);
+            });
+        });
+    });
+    describe('#getTokenAddressBySymbol', () => {
+        it('should return correct address for a token in the registry', async () => {
+            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(registeredSymbol);
+            expect(tokenAddress).to.be.equal(tokenAddressBySymbol[registeredSymbol]);
+        });
+        it('should return undefined for a token out of registry', async () => {
+            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressBySymbolIfExistsAsync(unregisteredSymbol);
+            expect(tokenAddress).to.be.undefined();
+        });
+    });
+    describe('#getTokenAddressByName', () => {
+        it('should return correct address for a token in the registry', async () => {
+            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(registeredName);
+            expect(tokenAddress).to.be.equal(tokenAddressByName[registeredName]);
+        });
+        it('should return undefined for a token out of registry', async () => {
+            const tokenAddress = await zeroEx.tokenRegistry.getTokenAddressByNameIfExistsAsync(unregisteredName);
+            expect(tokenAddress).to.be.undefined();
+        });
+    });
+    describe('#getTokenBySymbol', () => {
+        it('should return correct token for a token in the registry', async () => {
+            const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(registeredSymbol);
+            expect(token).to.be.deep.equal(tokenBySymbol[registeredSymbol]);
+        });
+        it('should return undefined for a token out of registry', async () => {
+            const token = await zeroEx.tokenRegistry.getTokenBySymbolIfExistsAsync(unregisteredSymbol);
+            expect(token).to.be.undefined();
+        });
+    });
+    describe('#getTokenByName', () => {
+        it('should return correct token for a token in the registry', async () => {
+            const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(registeredName);
+            expect(token).to.be.deep.equal(tokenByName[registeredName]);
+        });
+        it('should return undefined for a token out of registry', async () => {
+            const token = await zeroEx.tokenRegistry.getTokenByNameIfExistsAsync(unregisteredName);
+            expect(token).to.be.undefined();
+        });
+    });
+    describe('#getTokenIfExistsAsync', () => {
+        it('should return the token added to the tokenRegistry during the migration', async () => {
+            const aToken = tokens[0];
 
-			const token = await zeroEx.tokenRegistry.getTokenIfExistsAsync(aToken.address);
-			const schemaValidator = new SchemaValidator();
-			const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
-			expect(validationResult.errors).to.have.lengthOf(0);
-		});
-		it('should return return undefined when passed a token address not in the tokenRegistry', async () => {
-			const unregisteredTokenAddress = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
-			const tokenIfExists = await zeroEx.tokenRegistry.getTokenIfExistsAsync(unregisteredTokenAddress);
-			expect(tokenIfExists).to.be.undefined();
-		});
-	});
+            const token = await zeroEx.tokenRegistry.getTokenIfExistsAsync(aToken.address);
+            const schemaValidator = new SchemaValidator();
+            const validationResult = schemaValidator.validate(token, schemas.tokenSchema);
+            expect(validationResult.errors).to.have.lengthOf(0);
+        });
+        it('should return return undefined when passed a token address not in the tokenRegistry', async () => {
+            const unregisteredTokenAddress = '0x5409ed021d9299bf6814279a6a1411a7e866a631';
+            const tokenIfExists = await zeroEx.tokenRegistry.getTokenIfExistsAsync(unregisteredTokenAddress);
+            expect(tokenIfExists).to.be.undefined();
+        });
+    });
 });
diff --git a/packages/0x.js/test/token_transfer_proxy_wrapper_test.ts b/packages/0x.js/test/token_transfer_proxy_wrapper_test.ts
index 622919be2..15bd7a8ba 100644
--- a/packages/0x.js/test/token_transfer_proxy_wrapper_test.ts
+++ b/packages/0x.js/test/token_transfer_proxy_wrapper_test.ts
@@ -10,27 +10,27 @@ chaiSetup.configure();
 const expect = chai.expect;
 
 describe('TokenTransferProxyWrapper', () => {
-	let zeroEx: ZeroEx;
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		const web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-	});
-	describe('#isAuthorizedAsync', () => {
-		it('should return false if the address is not authorized', async () => {
-			const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(ZeroEx.NULL_ADDRESS);
-			expect(isAuthorized).to.be.false();
-		});
-	});
-	describe('#getAuthorizedAddressesAsync', () => {
-		it('should return the list of authorized addresses', async () => {
-			const authorizedAddresses = await zeroEx.proxy.getAuthorizedAddressesAsync();
-			for (const authorizedAddress of authorizedAddresses) {
-				const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(authorizedAddress);
-				expect(isAuthorized).to.be.true();
-			}
-		});
-	});
+    let zeroEx: ZeroEx;
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        const web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+    });
+    describe('#isAuthorizedAsync', () => {
+        it('should return false if the address is not authorized', async () => {
+            const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(ZeroEx.NULL_ADDRESS);
+            expect(isAuthorized).to.be.false();
+        });
+    });
+    describe('#getAuthorizedAddressesAsync', () => {
+        it('should return the list of authorized addresses', async () => {
+            const authorizedAddresses = await zeroEx.proxy.getAuthorizedAddressesAsync();
+            for (const authorizedAddress of authorizedAddresses) {
+                const isAuthorized = await zeroEx.proxy.isAuthorizedAsync(authorizedAddress);
+                expect(isAuthorized).to.be.true();
+            }
+        });
+    });
 });
diff --git a/packages/0x.js/test/token_wrapper_test.ts b/packages/0x.js/test/token_wrapper_test.ts
index 6919183cb..4ba1f07c5 100644
--- a/packages/0x.js/test/token_wrapper_test.ts
+++ b/packages/0x.js/test/token_wrapper_test.ts
@@ -6,15 +6,15 @@ import 'mocha';
 import * as Web3 from 'web3';
 
 import {
-	ApprovalContractEventArgs,
-	BlockParamLiteral,
-	BlockRange,
-	DecodedLogEvent,
-	Token,
-	TokenEvents,
-	TransferContractEventArgs,
-	ZeroEx,
-	ZeroExError,
+    ApprovalContractEventArgs,
+    BlockParamLiteral,
+    BlockRange,
+    DecodedLogEvent,
+    Token,
+    TokenEvents,
+    TransferContractEventArgs,
+    ZeroEx,
+    ZeroExError,
 } from '../src';
 import { DoneCallback } from '../src/types';
 
@@ -29,493 +29,493 @@ const expect = chai.expect;
 const blockchainLifecycle = new BlockchainLifecycle(constants.RPC_URL);
 
 describe('TokenWrapper', () => {
-	let web3: Web3;
-	let zeroEx: ZeroEx;
-	let userAddresses: string[];
-	let tokens: Token[];
-	let tokenUtils: TokenUtils;
-	let coinbase: string;
-	let addressWithoutFunds: string;
-	let web3Wrapper: Web3Wrapper;
-	const config = {
-		networkId: constants.TESTRPC_NETWORK_ID,
-	};
-	before(async () => {
-		web3 = web3Factory.create();
-		zeroEx = new ZeroEx(web3.currentProvider, config);
-		web3Wrapper = new Web3Wrapper(web3.currentProvider);
-		userAddresses = await zeroEx.getAvailableAddressesAsync();
-		tokens = await zeroEx.tokenRegistry.getTokensAsync();
-		tokenUtils = new TokenUtils(tokens);
-		coinbase = userAddresses[0];
-		addressWithoutFunds = userAddresses[1];
-	});
-	beforeEach(async () => {
-		await blockchainLifecycle.startAsync();
-	});
-	afterEach(async () => {
-		await blockchainLifecycle.revertAsync();
-	});
-	describe('#transferAsync', () => {
-		let token: Token;
-		let transferAmount: BigNumber;
-		before(() => {
-			token = tokens[0];
-			transferAmount = new BigNumber(42);
-		});
-		it('should successfully transfer tokens', async () => {
-			const fromAddress = coinbase;
-			const toAddress = addressWithoutFunds;
-			const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-			expect(preBalance).to.be.bignumber.equal(0);
-			await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
-			const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-			return expect(postBalance).to.be.bignumber.equal(transferAmount);
-		});
-		it('should fail to transfer tokens if fromAddress has an insufficient balance', async () => {
-			const fromAddress = addressWithoutFunds;
-			const toAddress = coinbase;
-			return expect(
-				zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount),
-			).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
-		});
-		it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-			const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-			const fromAddress = coinbase;
-			const toAddress = coinbase;
-			return expect(
-				zeroEx.token.transferAsync(nonExistentTokenAddress, fromAddress, toAddress, transferAmount),
-			).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
-		});
-	});
-	describe('#transferFromAsync', () => {
-		let token: Token;
-		let toAddress: string;
-		let senderAddress: string;
-		before(async () => {
-			token = tokens[0];
-			toAddress = addressWithoutFunds;
-			senderAddress = userAddresses[2];
-		});
-		it('should fail to transfer tokens if fromAddress has insufficient allowance set', async () => {
-			const fromAddress = coinbase;
-			const transferAmount = new BigNumber(42);
-
-			const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
-			expect(fromAddressBalance).to.be.bignumber.greaterThan(transferAmount);
-
-			const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress, toAddress);
-			expect(fromAddressAllowance).to.be.bignumber.equal(0);
-
-			return expect(
-				zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-			).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
-		});
-		it('[regression] should fail to transfer tokens if set allowance for toAddress instead of senderAddress', async () => {
-			const fromAddress = coinbase;
-			const transferAmount = new BigNumber(42);
-
-			await zeroEx.token.setAllowanceAsync(token.address, fromAddress, toAddress, transferAmount);
-
-			return expect(
-				zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-			).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
-		});
-		it('should fail to transfer tokens if fromAddress has insufficient balance', async () => {
-			const fromAddress = addressWithoutFunds;
-			const transferAmount = new BigNumber(42);
-
-			const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
-			expect(fromAddressBalance).to.be.bignumber.equal(0);
-
-			await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
-			const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(
-				token.address,
-				fromAddress,
-				senderAddress,
-			);
-			expect(fromAddressAllowance).to.be.bignumber.equal(transferAmount);
-
-			return expect(
-				zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
-			).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
-		});
-		it('should successfully transfer tokens', async () => {
-			const fromAddress = coinbase;
-
-			const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-			expect(preBalance).to.be.bignumber.equal(0);
-
-			const transferAmount = new BigNumber(42);
-			await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
-
-			await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount);
-			const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
-			return expect(postBalance).to.be.bignumber.equal(transferAmount);
-		});
-		it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-			const fromAddress = coinbase;
-			const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-			return expect(
-				zeroEx.token.transferFromAsync(
-					nonExistentTokenAddress,
-					fromAddress,
-					toAddress,
-					senderAddress,
-					new BigNumber(42),
-				),
-			).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
-		});
-	});
-	describe('#getBalanceAsync', () => {
-		describe('With web3 provider with accounts', () => {
-			it('should return the balance for an existing ERC20 token', async () => {
-				const token = tokens[0];
-				const ownerAddress = coinbase;
-				const balance = await zeroEx.token.getBalanceAsync(token.address, ownerAddress);
-				const expectedBalance = new BigNumber('1000000000000000000000000000');
-				return expect(balance).to.be.bignumber.equal(expectedBalance);
-			});
-			it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
-				const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
-				const ownerAddress = coinbase;
-				return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress)).to.be.rejectedWith(
-					ZeroExError.TokenContractDoesNotExist,
-				);
-			});
-			it('should return a balance of 0 for a non-existent owner address', async () => {
-				const token = tokens[0];
-				const nonExistentOwner = '0x198c6ad858f213fb31b6fe809e25040e6b964593';
-				const balance = await zeroEx.token.getBalanceAsync(token.address, nonExistentOwner);
-				const expectedBalance = new BigNumber(0);
-				return expect(balance).to.be.bignumber.equal(expectedBalance);
-			});
-		});
-		describe('With web3 provider without accounts', () => {
-			let zeroExWithoutAccounts: ZeroEx;
-			before(async () => {
-				const hasAddresses = false;
-				const web3WithoutAccounts = web3Factory.create(hasAddresses);
-				zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
-			});
-			it('should return balance even when called with Web3 provider instance without addresses', async () => {
-				const token = tokens[0];
-				const ownerAddress = coinbase;
-				const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
-				const expectedBalance = new BigNumber('1000000000000000000000000000');
-				return expect(balance).to.be.bignumber.equal(expectedBalance);
-			});
-		});
-	});
-	describe('#setAllowanceAsync', () => {
-		it("should set the spender's allowance", async () => {
-			const token = tokens[0];
-			const ownerAddress = coinbase;
-			const spenderAddress = addressWithoutFunds;
-
-			const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(
-				token.address,
-				ownerAddress,
-				spenderAddress,
-			);
-			const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
-			expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
-
-			const amountInBaseUnits = new BigNumber(50);
-			await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-			const allowanceAfterSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-			const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
-			return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
-		});
-	});
-	describe('#setUnlimitedAllowanceAsync', () => {
-		it("should set the unlimited spender's allowance", async () => {
-			const token = tokens[0];
-			const ownerAddress = coinbase;
-			const spenderAddress = addressWithoutFunds;
-
-			await zeroEx.token.setUnlimitedAllowanceAsync(token.address, ownerAddress, spenderAddress);
-			const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-			return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-		it('should reduce the gas cost for transfers including tokens with unlimited allowance support', async () => {
-			const transferAmount = new BigNumber(5);
-			const zrx = tokenUtils.getProtocolTokenOrThrow();
-			const [, userWithNormalAllowance, userWithUnlimitedAllowance] = userAddresses;
-			await zeroEx.token.setAllowanceAsync(zrx.address, coinbase, userWithNormalAllowance, transferAmount);
-			await zeroEx.token.setUnlimitedAllowanceAsync(zrx.address, coinbase, userWithUnlimitedAllowance);
-
-			const initBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-			const initBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-				userWithUnlimitedAllowance,
-			);
-
-			await zeroEx.token.transferFromAsync(
-				zrx.address,
-				coinbase,
-				userWithNormalAllowance,
-				userWithNormalAllowance,
-				transferAmount,
-			);
-			await zeroEx.token.transferFromAsync(
-				zrx.address,
-				coinbase,
-				userWithUnlimitedAllowance,
-				userWithUnlimitedAllowance,
-				transferAmount,
-			);
-
-			const finalBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
-			const finalBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
-				userWithUnlimitedAllowance,
-			);
-
-			const normalGasCost = initBalanceWithNormalAllowance.minus(finalBalanceWithNormalAllowance);
-			const unlimitedGasCost = initBalanceWithUnlimitedAllowance.minus(finalBalanceWithUnlimitedAllowance);
-
-			// In theory the gas cost with unlimited allowance should be smaller, but with testrpc it's actually bigger.
-			// This needs to be investigated in ethereumjs-vm. This test is essentially a repro.
-			// TODO: Make this test pass with inverted assertion.
-			expect(unlimitedGasCost.toNumber()).to.be.gt(normalGasCost.toNumber());
-		});
-	});
-	describe('#getAllowanceAsync', () => {
-		describe('With web3 provider with accounts', () => {
-			it('should get the proxy allowance', async () => {
-				const token = tokens[0];
-				const ownerAddress = coinbase;
-				const spenderAddress = addressWithoutFunds;
-
-				const amountInBaseUnits = new BigNumber(50);
-				await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-				const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-				const expectedAllowance = amountInBaseUnits;
-				return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-			});
-			it('should return 0 if no allowance set yet', async () => {
-				const token = tokens[0];
-				const ownerAddress = coinbase;
-				const spenderAddress = addressWithoutFunds;
-				const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
-				const expectedAllowance = new BigNumber(0);
-				return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-			});
-		});
-		describe('With web3 provider without accounts', () => {
-			let zeroExWithoutAccounts: ZeroEx;
-			before(async () => {
-				const hasAddresses = false;
-				const web3WithoutAccounts = web3Factory.create(hasAddresses);
-				zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
-			});
-			it('should get the proxy allowance', async () => {
-				const token = tokens[0];
-				const ownerAddress = coinbase;
-				const spenderAddress = addressWithoutFunds;
-
-				const amountInBaseUnits = new BigNumber(50);
-				await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
-
-				const allowance = await zeroExWithoutAccounts.token.getAllowanceAsync(
-					token.address,
-					ownerAddress,
-					spenderAddress,
-				);
-				const expectedAllowance = amountInBaseUnits;
-				return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-			});
-		});
-	});
-	describe('#getProxyAllowanceAsync', () => {
-		it('should get the proxy allowance', async () => {
-			const token = tokens[0];
-			const ownerAddress = coinbase;
-
-			const amountInBaseUnits = new BigNumber(50);
-			await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
-
-			const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-			const expectedAllowance = amountInBaseUnits;
-			return expect(allowance).to.be.bignumber.equal(expectedAllowance);
-		});
-	});
-	describe('#setProxyAllowanceAsync', () => {
-		it('should set the proxy allowance', async () => {
-			const token = tokens[0];
-			const ownerAddress = coinbase;
-
-			const allowanceBeforeSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-			const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
-			expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
-
-			const amountInBaseUnits = new BigNumber(50);
-			await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
-
-			const allowanceAfterSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-			const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
-			return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
-		});
-	});
-	describe('#setUnlimitedProxyAllowanceAsync', () => {
-		it('should set the unlimited proxy allowance', async () => {
-			const token = tokens[0];
-			const ownerAddress = coinbase;
-
-			await zeroEx.token.setUnlimitedProxyAllowanceAsync(token.address, ownerAddress);
-			const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
-			return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-	});
-	describe('#subscribe', () => {
-		const indexFilterValues = {};
-		let tokenAddress: string;
-		const transferAmount = new BigNumber(42);
-		const allowanceAmount = new BigNumber(42);
-		before(() => {
-			const token = tokens[0];
-			tokenAddress = token.address;
-		});
-		afterEach(() => {
-			zeroEx.token.unsubscribeAll();
-		});
-		// Hack: Mocha does not allow a test to be both async and have a `done` callback
-		// Since we need to await the receipt of the event in the `subscribe` callback,
-		// we do need both. A hack is to make the top-level a sync fn w/ a done callback and then
-		// wrap the rest of the test in an async block
-		// Source: https://github.com/mochajs/mocha/issues/2407
-		it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
-						expect(logEvent.isRemoved).to.be.false();
-						expect(logEvent.log.logIndex).to.be.equal(0);
-						expect(logEvent.log.transactionIndex).to.be.equal(0);
-						expect(logEvent.log.blockNumber).to.be.a('number');
-						const args = logEvent.log.args;
-						expect(args._from).to.be.equal(coinbase);
-						expect(args._to).to.be.equal(addressWithoutFunds);
-						expect(args._value).to.be.bignumber.equal(transferAmount);
-					},
-				);
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callback);
-				await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-			})().catch(done);
-		});
-		it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
-			(async () => {
-				const callback = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						expect(logEvent).to.not.be.undefined();
-						expect(logEvent.isRemoved).to.be.false();
-						const args = logEvent.log.args;
-						expect(args._owner).to.be.equal(coinbase);
-						expect(args._spender).to.be.equal(addressWithoutFunds);
-						expect(args._value).to.be.bignumber.equal(allowanceAmount);
-					},
-				);
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
-				await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
-			})().catch(done);
-		});
-		it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
-				const callbackToBeCalled = reportNodeCallbackErrors(done)();
-				const newProvider = web3Factory.getRpcProvider();
-				zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
-				zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled);
-				await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-			})().catch(done);
-		});
-		it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
-			(async () => {
-				const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
-					(logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
-						done(new Error('Expected this subscription to have been cancelled'));
-					},
-				);
-				const subscriptionToken = zeroEx.token.subscribe(
-					tokenAddress,
-					TokenEvents.Transfer,
-					indexFilterValues,
-					callbackNeverToBeCalled,
-				);
-				zeroEx.token.unsubscribe(subscriptionToken);
-				await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
-				done();
-			})().catch(done);
-		});
-	});
-	describe('#getLogsAsync', () => {
-		let tokenAddress: string;
-		let tokenTransferProxyAddress: string;
-		const blockRange: BlockRange = {
-			fromBlock: 0,
-			toBlock: BlockParamLiteral.Latest,
-		};
-		let txHash: string;
-		before(() => {
-			const token = tokens[0];
-			tokenAddress = token.address;
-			tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
-		});
-		it('should get logs with decoded args emitted by Approval', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const eventName = TokenEvents.Approval;
-			const indexFilterValues = {};
-			const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-				tokenAddress,
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(logs[0].event).to.be.equal(eventName);
-			expect(args._owner).to.be.equal(coinbase);
-			expect(args._spender).to.be.equal(tokenTransferProxyAddress);
-			expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
-		});
-		it('should only get the logs with the correct event name', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const differentEventName = TokenEvents.Transfer;
-			const indexFilterValues = {};
-			const logs = await zeroEx.token.getLogsAsync(
-				tokenAddress,
-				differentEventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(0);
-		});
-		it('should only get the logs with the correct indexed fields', async () => {
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, addressWithoutFunds);
-			await zeroEx.awaitTransactionMinedAsync(txHash);
-			const eventName = TokenEvents.Approval;
-			const indexFilterValues = {
-				_owner: coinbase,
-			};
-			const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
-				tokenAddress,
-				eventName,
-				blockRange,
-				indexFilterValues,
-			);
-			expect(logs).to.have.length(1);
-			const args = logs[0].args;
-			expect(args._owner).to.be.equal(coinbase);
-		});
-	});
+    let web3: Web3;
+    let zeroEx: ZeroEx;
+    let userAddresses: string[];
+    let tokens: Token[];
+    let tokenUtils: TokenUtils;
+    let coinbase: string;
+    let addressWithoutFunds: string;
+    let web3Wrapper: Web3Wrapper;
+    const config = {
+        networkId: constants.TESTRPC_NETWORK_ID,
+    };
+    before(async () => {
+        web3 = web3Factory.create();
+        zeroEx = new ZeroEx(web3.currentProvider, config);
+        web3Wrapper = new Web3Wrapper(web3.currentProvider);
+        userAddresses = await zeroEx.getAvailableAddressesAsync();
+        tokens = await zeroEx.tokenRegistry.getTokensAsync();
+        tokenUtils = new TokenUtils(tokens);
+        coinbase = userAddresses[0];
+        addressWithoutFunds = userAddresses[1];
+    });
+    beforeEach(async () => {
+        await blockchainLifecycle.startAsync();
+    });
+    afterEach(async () => {
+        await blockchainLifecycle.revertAsync();
+    });
+    describe('#transferAsync', () => {
+        let token: Token;
+        let transferAmount: BigNumber;
+        before(() => {
+            token = tokens[0];
+            transferAmount = new BigNumber(42);
+        });
+        it('should successfully transfer tokens', async () => {
+            const fromAddress = coinbase;
+            const toAddress = addressWithoutFunds;
+            const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
+            expect(preBalance).to.be.bignumber.equal(0);
+            await zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount);
+            const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
+            return expect(postBalance).to.be.bignumber.equal(transferAmount);
+        });
+        it('should fail to transfer tokens if fromAddress has an insufficient balance', async () => {
+            const fromAddress = addressWithoutFunds;
+            const toAddress = coinbase;
+            return expect(
+                zeroEx.token.transferAsync(token.address, fromAddress, toAddress, transferAmount),
+            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
+        });
+        it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
+            const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
+            const fromAddress = coinbase;
+            const toAddress = coinbase;
+            return expect(
+                zeroEx.token.transferAsync(nonExistentTokenAddress, fromAddress, toAddress, transferAmount),
+            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
+        });
+    });
+    describe('#transferFromAsync', () => {
+        let token: Token;
+        let toAddress: string;
+        let senderAddress: string;
+        before(async () => {
+            token = tokens[0];
+            toAddress = addressWithoutFunds;
+            senderAddress = userAddresses[2];
+        });
+        it('should fail to transfer tokens if fromAddress has insufficient allowance set', async () => {
+            const fromAddress = coinbase;
+            const transferAmount = new BigNumber(42);
+
+            const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
+            expect(fromAddressBalance).to.be.bignumber.greaterThan(transferAmount);
+
+            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(token.address, fromAddress, toAddress);
+            expect(fromAddressAllowance).to.be.bignumber.equal(0);
+
+            return expect(
+                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
+            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
+        });
+        it('[regression] should fail to transfer tokens if set allowance for toAddress instead of senderAddress', async () => {
+            const fromAddress = coinbase;
+            const transferAmount = new BigNumber(42);
+
+            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, toAddress, transferAmount);
+
+            return expect(
+                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
+            ).to.be.rejectedWith(ZeroExError.InsufficientAllowanceForTransfer);
+        });
+        it('should fail to transfer tokens if fromAddress has insufficient balance', async () => {
+            const fromAddress = addressWithoutFunds;
+            const transferAmount = new BigNumber(42);
+
+            const fromAddressBalance = await zeroEx.token.getBalanceAsync(token.address, fromAddress);
+            expect(fromAddressBalance).to.be.bignumber.equal(0);
+
+            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
+            const fromAddressAllowance = await zeroEx.token.getAllowanceAsync(
+                token.address,
+                fromAddress,
+                senderAddress,
+            );
+            expect(fromAddressAllowance).to.be.bignumber.equal(transferAmount);
+
+            return expect(
+                zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount),
+            ).to.be.rejectedWith(ZeroExError.InsufficientBalanceForTransfer);
+        });
+        it('should successfully transfer tokens', async () => {
+            const fromAddress = coinbase;
+
+            const preBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
+            expect(preBalance).to.be.bignumber.equal(0);
+
+            const transferAmount = new BigNumber(42);
+            await zeroEx.token.setAllowanceAsync(token.address, fromAddress, senderAddress, transferAmount);
+
+            await zeroEx.token.transferFromAsync(token.address, fromAddress, toAddress, senderAddress, transferAmount);
+            const postBalance = await zeroEx.token.getBalanceAsync(token.address, toAddress);
+            return expect(postBalance).to.be.bignumber.equal(transferAmount);
+        });
+        it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
+            const fromAddress = coinbase;
+            const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
+            return expect(
+                zeroEx.token.transferFromAsync(
+                    nonExistentTokenAddress,
+                    fromAddress,
+                    toAddress,
+                    senderAddress,
+                    new BigNumber(42),
+                ),
+            ).to.be.rejectedWith(ZeroExError.TokenContractDoesNotExist);
+        });
+    });
+    describe('#getBalanceAsync', () => {
+        describe('With web3 provider with accounts', () => {
+            it('should return the balance for an existing ERC20 token', async () => {
+                const token = tokens[0];
+                const ownerAddress = coinbase;
+                const balance = await zeroEx.token.getBalanceAsync(token.address, ownerAddress);
+                const expectedBalance = new BigNumber('1000000000000000000000000000');
+                return expect(balance).to.be.bignumber.equal(expectedBalance);
+            });
+            it('should throw a CONTRACT_DOES_NOT_EXIST error for a non-existent token contract', async () => {
+                const nonExistentTokenAddress = '0x9dd402f14d67e001d8efbe6583e51bf9706aa065';
+                const ownerAddress = coinbase;
+                return expect(zeroEx.token.getBalanceAsync(nonExistentTokenAddress, ownerAddress)).to.be.rejectedWith(
+                    ZeroExError.TokenContractDoesNotExist,
+                );
+            });
+            it('should return a balance of 0 for a non-existent owner address', async () => {
+                const token = tokens[0];
+                const nonExistentOwner = '0x198c6ad858f213fb31b6fe809e25040e6b964593';
+                const balance = await zeroEx.token.getBalanceAsync(token.address, nonExistentOwner);
+                const expectedBalance = new BigNumber(0);
+                return expect(balance).to.be.bignumber.equal(expectedBalance);
+            });
+        });
+        describe('With web3 provider without accounts', () => {
+            let zeroExWithoutAccounts: ZeroEx;
+            before(async () => {
+                const hasAddresses = false;
+                const web3WithoutAccounts = web3Factory.create(hasAddresses);
+                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+            });
+            it('should return balance even when called with Web3 provider instance without addresses', async () => {
+                const token = tokens[0];
+                const ownerAddress = coinbase;
+                const balance = await zeroExWithoutAccounts.token.getBalanceAsync(token.address, ownerAddress);
+                const expectedBalance = new BigNumber('1000000000000000000000000000');
+                return expect(balance).to.be.bignumber.equal(expectedBalance);
+            });
+        });
+    });
+    describe('#setAllowanceAsync', () => {
+        it("should set the spender's allowance", async () => {
+            const token = tokens[0];
+            const ownerAddress = coinbase;
+            const spenderAddress = addressWithoutFunds;
+
+            const allowanceBeforeSet = await zeroEx.token.getAllowanceAsync(
+                token.address,
+                ownerAddress,
+                spenderAddress,
+            );
+            const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
+            expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
+
+            const amountInBaseUnits = new BigNumber(50);
+            await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
+
+            const allowanceAfterSet = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+            const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
+            return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
+        });
+    });
+    describe('#setUnlimitedAllowanceAsync', () => {
+        it("should set the unlimited spender's allowance", async () => {
+            const token = tokens[0];
+            const ownerAddress = coinbase;
+            const spenderAddress = addressWithoutFunds;
+
+            await zeroEx.token.setUnlimitedAllowanceAsync(token.address, ownerAddress, spenderAddress);
+            const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+            return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+        it('should reduce the gas cost for transfers including tokens with unlimited allowance support', async () => {
+            const transferAmount = new BigNumber(5);
+            const zrx = tokenUtils.getProtocolTokenOrThrow();
+            const [, userWithNormalAllowance, userWithUnlimitedAllowance] = userAddresses;
+            await zeroEx.token.setAllowanceAsync(zrx.address, coinbase, userWithNormalAllowance, transferAmount);
+            await zeroEx.token.setUnlimitedAllowanceAsync(zrx.address, coinbase, userWithUnlimitedAllowance);
+
+            const initBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
+            const initBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
+                userWithUnlimitedAllowance,
+            );
+
+            await zeroEx.token.transferFromAsync(
+                zrx.address,
+                coinbase,
+                userWithNormalAllowance,
+                userWithNormalAllowance,
+                transferAmount,
+            );
+            await zeroEx.token.transferFromAsync(
+                zrx.address,
+                coinbase,
+                userWithUnlimitedAllowance,
+                userWithUnlimitedAllowance,
+                transferAmount,
+            );
+
+            const finalBalanceWithNormalAllowance = await web3Wrapper.getBalanceInWeiAsync(userWithNormalAllowance);
+            const finalBalanceWithUnlimitedAllowance = await web3Wrapper.getBalanceInWeiAsync(
+                userWithUnlimitedAllowance,
+            );
+
+            const normalGasCost = initBalanceWithNormalAllowance.minus(finalBalanceWithNormalAllowance);
+            const unlimitedGasCost = initBalanceWithUnlimitedAllowance.minus(finalBalanceWithUnlimitedAllowance);
+
+            // In theory the gas cost with unlimited allowance should be smaller, but with testrpc it's actually bigger.
+            // This needs to be investigated in ethereumjs-vm. This test is essentially a repro.
+            // TODO: Make this test pass with inverted assertion.
+            expect(unlimitedGasCost.toNumber()).to.be.gt(normalGasCost.toNumber());
+        });
+    });
+    describe('#getAllowanceAsync', () => {
+        describe('With web3 provider with accounts', () => {
+            it('should get the proxy allowance', async () => {
+                const token = tokens[0];
+                const ownerAddress = coinbase;
+                const spenderAddress = addressWithoutFunds;
+
+                const amountInBaseUnits = new BigNumber(50);
+                await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
+
+                const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+                const expectedAllowance = amountInBaseUnits;
+                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
+            });
+            it('should return 0 if no allowance set yet', async () => {
+                const token = tokens[0];
+                const ownerAddress = coinbase;
+                const spenderAddress = addressWithoutFunds;
+                const allowance = await zeroEx.token.getAllowanceAsync(token.address, ownerAddress, spenderAddress);
+                const expectedAllowance = new BigNumber(0);
+                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
+            });
+        });
+        describe('With web3 provider without accounts', () => {
+            let zeroExWithoutAccounts: ZeroEx;
+            before(async () => {
+                const hasAddresses = false;
+                const web3WithoutAccounts = web3Factory.create(hasAddresses);
+                zeroExWithoutAccounts = new ZeroEx(web3WithoutAccounts.currentProvider, config);
+            });
+            it('should get the proxy allowance', async () => {
+                const token = tokens[0];
+                const ownerAddress = coinbase;
+                const spenderAddress = addressWithoutFunds;
+
+                const amountInBaseUnits = new BigNumber(50);
+                await zeroEx.token.setAllowanceAsync(token.address, ownerAddress, spenderAddress, amountInBaseUnits);
+
+                const allowance = await zeroExWithoutAccounts.token.getAllowanceAsync(
+                    token.address,
+                    ownerAddress,
+                    spenderAddress,
+                );
+                const expectedAllowance = amountInBaseUnits;
+                return expect(allowance).to.be.bignumber.equal(expectedAllowance);
+            });
+        });
+    });
+    describe('#getProxyAllowanceAsync', () => {
+        it('should get the proxy allowance', async () => {
+            const token = tokens[0];
+            const ownerAddress = coinbase;
+
+            const amountInBaseUnits = new BigNumber(50);
+            await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
+
+            const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
+            const expectedAllowance = amountInBaseUnits;
+            return expect(allowance).to.be.bignumber.equal(expectedAllowance);
+        });
+    });
+    describe('#setProxyAllowanceAsync', () => {
+        it('should set the proxy allowance', async () => {
+            const token = tokens[0];
+            const ownerAddress = coinbase;
+
+            const allowanceBeforeSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
+            const expectedAllowanceBeforeAllowanceSet = new BigNumber(0);
+            expect(allowanceBeforeSet).to.be.bignumber.equal(expectedAllowanceBeforeAllowanceSet);
+
+            const amountInBaseUnits = new BigNumber(50);
+            await zeroEx.token.setProxyAllowanceAsync(token.address, ownerAddress, amountInBaseUnits);
+
+            const allowanceAfterSet = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
+            const expectedAllowanceAfterAllowanceSet = amountInBaseUnits;
+            return expect(allowanceAfterSet).to.be.bignumber.equal(expectedAllowanceAfterAllowanceSet);
+        });
+    });
+    describe('#setUnlimitedProxyAllowanceAsync', () => {
+        it('should set the unlimited proxy allowance', async () => {
+            const token = tokens[0];
+            const ownerAddress = coinbase;
+
+            await zeroEx.token.setUnlimitedProxyAllowanceAsync(token.address, ownerAddress);
+            const allowance = await zeroEx.token.getProxyAllowanceAsync(token.address, ownerAddress);
+            return expect(allowance).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+    });
+    describe('#subscribe', () => {
+        const indexFilterValues = {};
+        let tokenAddress: string;
+        const transferAmount = new BigNumber(42);
+        const allowanceAmount = new BigNumber(42);
+        before(() => {
+            const token = tokens[0];
+            tokenAddress = token.address;
+        });
+        afterEach(() => {
+            zeroEx.token.unsubscribeAll();
+        });
+        // Hack: Mocha does not allow a test to be both async and have a `done` callback
+        // Since we need to await the receipt of the event in the `subscribe` callback,
+        // we do need both. A hack is to make the top-level a sync fn w/ a done callback and then
+        // wrap the rest of the test in an async block
+        // Source: https://github.com/mochajs/mocha/issues/2407
+        it('Should receive the Transfer event when tokens are transfered', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<TransferContractEventArgs>) => {
+                        expect(logEvent.isRemoved).to.be.false();
+                        expect(logEvent.log.logIndex).to.be.equal(0);
+                        expect(logEvent.log.transactionIndex).to.be.equal(0);
+                        expect(logEvent.log.blockNumber).to.be.a('number');
+                        const args = logEvent.log.args;
+                        expect(args._from).to.be.equal(coinbase);
+                        expect(args._to).to.be.equal(addressWithoutFunds);
+                        expect(args._value).to.be.bignumber.equal(transferAmount);
+                    },
+                );
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callback);
+                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
+            })().catch(done);
+        });
+        it('Should receive the Approval event when allowance is being set', (done: DoneCallback) => {
+            (async () => {
+                const callback = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        expect(logEvent).to.not.be.undefined();
+                        expect(logEvent.isRemoved).to.be.false();
+                        const args = logEvent.log.args;
+                        expect(args._owner).to.be.equal(coinbase);
+                        expect(args._spender).to.be.equal(addressWithoutFunds);
+                        expect(args._value).to.be.bignumber.equal(allowanceAmount);
+                    },
+                );
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Approval, indexFilterValues, callback);
+                await zeroEx.token.setAllowanceAsync(tokenAddress, coinbase, addressWithoutFunds, allowanceAmount);
+            })().catch(done);
+        });
+        it('Outstanding subscriptions are cancelled when zeroEx.setProvider called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackNeverToBeCalled);
+                const callbackToBeCalled = reportNodeCallbackErrors(done)();
+                const newProvider = web3Factory.getRpcProvider();
+                zeroEx.setProvider(newProvider, constants.TESTRPC_NETWORK_ID);
+                zeroEx.token.subscribe(tokenAddress, TokenEvents.Transfer, indexFilterValues, callbackToBeCalled);
+                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
+            })().catch(done);
+        });
+        it('Should cancel subscription when unsubscribe called', (done: DoneCallback) => {
+            (async () => {
+                const callbackNeverToBeCalled = reportNodeCallbackErrors(done)(
+                    (logEvent: DecodedLogEvent<ApprovalContractEventArgs>) => {
+                        done(new Error('Expected this subscription to have been cancelled'));
+                    },
+                );
+                const subscriptionToken = zeroEx.token.subscribe(
+                    tokenAddress,
+                    TokenEvents.Transfer,
+                    indexFilterValues,
+                    callbackNeverToBeCalled,
+                );
+                zeroEx.token.unsubscribe(subscriptionToken);
+                await zeroEx.token.transferAsync(tokenAddress, coinbase, addressWithoutFunds, transferAmount);
+                done();
+            })().catch(done);
+        });
+    });
+    describe('#getLogsAsync', () => {
+        let tokenAddress: string;
+        let tokenTransferProxyAddress: string;
+        const blockRange: BlockRange = {
+            fromBlock: 0,
+            toBlock: BlockParamLiteral.Latest,
+        };
+        let txHash: string;
+        before(() => {
+            const token = tokens[0];
+            tokenAddress = token.address;
+            tokenTransferProxyAddress = zeroEx.proxy.getContractAddress();
+        });
+        it('should get logs with decoded args emitted by Approval', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = TokenEvents.Approval;
+            const indexFilterValues = {};
+            const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
+                tokenAddress,
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(logs[0].event).to.be.equal(eventName);
+            expect(args._owner).to.be.equal(coinbase);
+            expect(args._spender).to.be.equal(tokenTransferProxyAddress);
+            expect(args._value).to.be.bignumber.equal(zeroEx.token.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
+        });
+        it('should only get the logs with the correct event name', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const differentEventName = TokenEvents.Transfer;
+            const indexFilterValues = {};
+            const logs = await zeroEx.token.getLogsAsync(
+                tokenAddress,
+                differentEventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(0);
+        });
+        it('should only get the logs with the correct indexed fields', async () => {
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, coinbase);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            txHash = await zeroEx.token.setUnlimitedProxyAllowanceAsync(tokenAddress, addressWithoutFunds);
+            await zeroEx.awaitTransactionMinedAsync(txHash);
+            const eventName = TokenEvents.Approval;
+            const indexFilterValues = {
+                _owner: coinbase,
+            };
+            const logs = await zeroEx.token.getLogsAsync<ApprovalContractEventArgs>(
+                tokenAddress,
+                eventName,
+                blockRange,
+                indexFilterValues,
+            );
+            expect(logs).to.have.length(1);
+            const args = logs[0].args;
+            expect(args._owner).to.be.equal(coinbase);
+        });
+    });
 });
 // tslint:disable:max-file-line-count
diff --git a/packages/0x.js/test/utils/chai_setup.ts b/packages/0x.js/test/utils/chai_setup.ts
index e156b5f7c..078edd309 100644
--- a/packages/0x.js/test/utils/chai_setup.ts
+++ b/packages/0x.js/test/utils/chai_setup.ts
@@ -4,10 +4,10 @@ import ChaiBigNumber = require('chai-bignumber');
 import * as dirtyChai from 'dirty-chai';
 
 export const chaiSetup = {
-	configure() {
-		chai.config.includeStack = true;
-		chai.use(ChaiBigNumber());
-		chai.use(dirtyChai);
-		chai.use(chaiAsPromised);
-	},
+    configure() {
+        chai.config.includeStack = true;
+        chai.use(ChaiBigNumber());
+        chai.use(dirtyChai);
+        chai.use(chaiAsPromised);
+    },
 };
diff --git a/packages/0x.js/test/utils/constants.ts b/packages/0x.js/test/utils/constants.ts
index b7161e9ab..a9e665c25 100644
--- a/packages/0x.js/test/utils/constants.ts
+++ b/packages/0x.js/test/utils/constants.ts
@@ -1,11 +1,11 @@
 export const constants = {
-	NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
-	RPC_URL: 'http://localhost:8545',
-	ROPSTEN_NETWORK_ID: 3,
-	KOVAN_NETWORK_ID: 42,
-	TESTRPC_NETWORK_ID: 50,
-	KOVAN_RPC_URL: 'https://kovan.infura.io/',
-	ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
-	ZRX_DECIMALS: 18,
-	GAS_ESTIMATE: 500000,
+    NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
+    RPC_URL: 'http://localhost:8545',
+    ROPSTEN_NETWORK_ID: 3,
+    KOVAN_NETWORK_ID: 42,
+    TESTRPC_NETWORK_ID: 50,
+    KOVAN_RPC_URL: 'https://kovan.infura.io/',
+    ROPSTEN_RPC_URL: 'https://ropsten.infura.io/',
+    ZRX_DECIMALS: 18,
+    GAS_ESTIMATE: 500000,
 };
diff --git a/packages/0x.js/test/utils/fill_scenarios.ts b/packages/0x.js/test/utils/fill_scenarios.ts
index 1d4b8b6f4..1a61487f4 100644
--- a/packages/0x.js/test/utils/fill_scenarios.ts
+++ b/packages/0x.js/test/utils/fill_scenarios.ts
@@ -11,192 +11,192 @@ import { constants } from './constants';
 const INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS = new BigNumber(100);
 
 export class FillScenarios {
-	private _zeroEx: ZeroEx;
-	private _userAddresses: string[];
-	private _tokens: Token[];
-	private _coinbase: string;
-	private _zrxTokenAddress: string;
-	private _exchangeContractAddress: string;
-	constructor(
-		zeroEx: ZeroEx,
-		userAddresses: string[],
-		tokens: Token[],
-		zrxTokenAddress: string,
-		exchangeContractAddress: string,
-	) {
-		this._zeroEx = zeroEx;
-		this._userAddresses = userAddresses;
-		this._tokens = tokens;
-		this._coinbase = userAddresses[0];
-		this._zrxTokenAddress = zrxTokenAddress;
-		this._exchangeContractAddress = exchangeContractAddress;
-	}
-	public async initTokenBalancesAsync() {
-		const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
-		for (const token of this._tokens) {
-			if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
-				const contractInstance = web3Wrapper.getContractInstance(
-					artifacts.DummyTokenArtifact.abi,
-					token.address,
-				);
-				const defaults = {};
-				const dummyToken = new DummyTokenContract(contractInstance, defaults);
-				const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
-				const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
-					from: this._coinbase,
-				});
-				await this._zeroEx.awaitTransactionMinedAsync(txHash);
-			}
-		}
-	}
-	public async createFillableSignedOrderAsync(
-		makerTokenAddress: string,
-		takerTokenAddress: string,
-		makerAddress: string,
-		takerAddress: string,
-		fillableAmount: BigNumber,
-		expirationUnixTimestampSec?: BigNumber,
-	): Promise<SignedOrder> {
-		return this.createAsymmetricFillableSignedOrderAsync(
-			makerTokenAddress,
-			takerTokenAddress,
-			makerAddress,
-			takerAddress,
-			fillableAmount,
-			fillableAmount,
-			expirationUnixTimestampSec,
-		);
-	}
-	public async createFillableSignedOrderWithFeesAsync(
-		makerTokenAddress: string,
-		takerTokenAddress: string,
-		makerFee: BigNumber,
-		takerFee: BigNumber,
-		makerAddress: string,
-		takerAddress: string,
-		fillableAmount: BigNumber,
-		feeRecepient: string,
-		expirationUnixTimestampSec?: BigNumber,
-	): Promise<SignedOrder> {
-		return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-			makerTokenAddress,
-			takerTokenAddress,
-			makerFee,
-			takerFee,
-			makerAddress,
-			takerAddress,
-			fillableAmount,
-			fillableAmount,
-			feeRecepient,
-			expirationUnixTimestampSec,
-		);
-	}
-	public async createAsymmetricFillableSignedOrderAsync(
-		makerTokenAddress: string,
-		takerTokenAddress: string,
-		makerAddress: string,
-		takerAddress: string,
-		makerFillableAmount: BigNumber,
-		takerFillableAmount: BigNumber,
-		expirationUnixTimestampSec?: BigNumber,
-	): Promise<SignedOrder> {
-		const makerFee = new BigNumber(0);
-		const takerFee = new BigNumber(0);
-		const feeRecepient = constants.NULL_ADDRESS;
-		return this._createAsymmetricFillableSignedOrderWithFeesAsync(
-			makerTokenAddress,
-			takerTokenAddress,
-			makerFee,
-			takerFee,
-			makerAddress,
-			takerAddress,
-			makerFillableAmount,
-			takerFillableAmount,
-			feeRecepient,
-			expirationUnixTimestampSec,
-		);
-	}
-	public async createPartiallyFilledSignedOrderAsync(
-		makerTokenAddress: string,
-		takerTokenAddress: string,
-		takerAddress: string,
-		fillableAmount: BigNumber,
-		partialFillAmount: BigNumber,
-	) {
-		const [makerAddress] = this._userAddresses;
-		const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
-			makerTokenAddress,
-			takerTokenAddress,
-			makerAddress,
-			takerAddress,
-			fillableAmount,
-			fillableAmount,
-		);
-		const shouldThrowOnInsufficientBalanceOrAllowance = false;
-		await this._zeroEx.exchange.fillOrderAsync(
-			signedOrder,
-			partialFillAmount,
-			shouldThrowOnInsufficientBalanceOrAllowance,
-			takerAddress,
-		);
-		return signedOrder;
-	}
-	private async _createAsymmetricFillableSignedOrderWithFeesAsync(
-		makerTokenAddress: string,
-		takerTokenAddress: string,
-		makerFee: BigNumber,
-		takerFee: BigNumber,
-		makerAddress: string,
-		takerAddress: string,
-		makerFillableAmount: BigNumber,
-		takerFillableAmount: BigNumber,
-		feeRecepient: string,
-		expirationUnixTimestampSec?: BigNumber,
-	): Promise<SignedOrder> {
-		await Promise.all([
-			this._increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
-			this._increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
-		]);
-		await Promise.all([
-			this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
-			this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
-		]);
+    private _zeroEx: ZeroEx;
+    private _userAddresses: string[];
+    private _tokens: Token[];
+    private _coinbase: string;
+    private _zrxTokenAddress: string;
+    private _exchangeContractAddress: string;
+    constructor(
+        zeroEx: ZeroEx,
+        userAddresses: string[],
+        tokens: Token[],
+        zrxTokenAddress: string,
+        exchangeContractAddress: string,
+    ) {
+        this._zeroEx = zeroEx;
+        this._userAddresses = userAddresses;
+        this._tokens = tokens;
+        this._coinbase = userAddresses[0];
+        this._zrxTokenAddress = zrxTokenAddress;
+        this._exchangeContractAddress = exchangeContractAddress;
+    }
+    public async initTokenBalancesAsync() {
+        const web3Wrapper = (this._zeroEx as any)._web3Wrapper as Web3Wrapper;
+        for (const token of this._tokens) {
+            if (token.symbol !== 'ZRX' && token.symbol !== 'WETH') {
+                const contractInstance = web3Wrapper.getContractInstance(
+                    artifacts.DummyTokenArtifact.abi,
+                    token.address,
+                );
+                const defaults = {};
+                const dummyToken = new DummyTokenContract(contractInstance, defaults);
+                const tokenSupply = ZeroEx.toBaseUnitAmount(INITIAL_COINBASE_TOKEN_SUPPLY_IN_UNITS, token.decimals);
+                const txHash = await dummyToken.setBalance.sendTransactionAsync(this._coinbase, tokenSupply, {
+                    from: this._coinbase,
+                });
+                await this._zeroEx.awaitTransactionMinedAsync(txHash);
+            }
+        }
+    }
+    public async createFillableSignedOrderAsync(
+        makerTokenAddress: string,
+        takerTokenAddress: string,
+        makerAddress: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        expirationUnixTimestampSec?: BigNumber,
+    ): Promise<SignedOrder> {
+        return this.createAsymmetricFillableSignedOrderAsync(
+            makerTokenAddress,
+            takerTokenAddress,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+            expirationUnixTimestampSec,
+        );
+    }
+    public async createFillableSignedOrderWithFeesAsync(
+        makerTokenAddress: string,
+        takerTokenAddress: string,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerAddress: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        feeRecepient: string,
+        expirationUnixTimestampSec?: BigNumber,
+    ): Promise<SignedOrder> {
+        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerTokenAddress,
+            takerTokenAddress,
+            makerFee,
+            takerFee,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+            feeRecepient,
+            expirationUnixTimestampSec,
+        );
+    }
+    public async createAsymmetricFillableSignedOrderAsync(
+        makerTokenAddress: string,
+        takerTokenAddress: string,
+        makerAddress: string,
+        takerAddress: string,
+        makerFillableAmount: BigNumber,
+        takerFillableAmount: BigNumber,
+        expirationUnixTimestampSec?: BigNumber,
+    ): Promise<SignedOrder> {
+        const makerFee = new BigNumber(0);
+        const takerFee = new BigNumber(0);
+        const feeRecepient = constants.NULL_ADDRESS;
+        return this._createAsymmetricFillableSignedOrderWithFeesAsync(
+            makerTokenAddress,
+            takerTokenAddress,
+            makerFee,
+            takerFee,
+            makerAddress,
+            takerAddress,
+            makerFillableAmount,
+            takerFillableAmount,
+            feeRecepient,
+            expirationUnixTimestampSec,
+        );
+    }
+    public async createPartiallyFilledSignedOrderAsync(
+        makerTokenAddress: string,
+        takerTokenAddress: string,
+        takerAddress: string,
+        fillableAmount: BigNumber,
+        partialFillAmount: BigNumber,
+    ) {
+        const [makerAddress] = this._userAddresses;
+        const signedOrder = await this.createAsymmetricFillableSignedOrderAsync(
+            makerTokenAddress,
+            takerTokenAddress,
+            makerAddress,
+            takerAddress,
+            fillableAmount,
+            fillableAmount,
+        );
+        const shouldThrowOnInsufficientBalanceOrAllowance = false;
+        await this._zeroEx.exchange.fillOrderAsync(
+            signedOrder,
+            partialFillAmount,
+            shouldThrowOnInsufficientBalanceOrAllowance,
+            takerAddress,
+        );
+        return signedOrder;
+    }
+    private async _createAsymmetricFillableSignedOrderWithFeesAsync(
+        makerTokenAddress: string,
+        takerTokenAddress: string,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerAddress: string,
+        takerAddress: string,
+        makerFillableAmount: BigNumber,
+        takerFillableAmount: BigNumber,
+        feeRecepient: string,
+        expirationUnixTimestampSec?: BigNumber,
+    ): Promise<SignedOrder> {
+        await Promise.all([
+            this._increaseBalanceAndAllowanceAsync(makerTokenAddress, makerAddress, makerFillableAmount),
+            this._increaseBalanceAndAllowanceAsync(takerTokenAddress, takerAddress, takerFillableAmount),
+        ]);
+        await Promise.all([
+            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, makerAddress, makerFee),
+            this._increaseBalanceAndAllowanceAsync(this._zrxTokenAddress, takerAddress, takerFee),
+        ]);
 
-		const signedOrder = await orderFactory.createSignedOrderAsync(
-			this._zeroEx,
-			makerAddress,
-			takerAddress,
-			makerFee,
-			takerFee,
-			makerFillableAmount,
-			makerTokenAddress,
-			takerFillableAmount,
-			takerTokenAddress,
-			this._exchangeContractAddress,
-			feeRecepient,
-			expirationUnixTimestampSec,
-		);
-		return signedOrder;
-	}
-	private async _increaseBalanceAndAllowanceAsync(
-		tokenAddress: string,
-		address: string,
-		amount: BigNumber,
-	): Promise<void> {
-		if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
-			return; // noop
-		}
-		await Promise.all([
-			this._increaseBalanceAsync(tokenAddress, address, amount),
-			this._increaseAllowanceAsync(tokenAddress, address, amount),
-		]);
-	}
-	private async _increaseBalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-		await this._zeroEx.token.transferAsync(tokenAddress, this._coinbase, address, amount);
-	}
-	private async _increaseAllowanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
-		const oldMakerAllowance = await this._zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
-		const newMakerAllowance = oldMakerAllowance.plus(amount);
-		await this._zeroEx.token.setProxyAllowanceAsync(tokenAddress, address, newMakerAllowance);
-	}
+        const signedOrder = await orderFactory.createSignedOrderAsync(
+            this._zeroEx,
+            makerAddress,
+            takerAddress,
+            makerFee,
+            takerFee,
+            makerFillableAmount,
+            makerTokenAddress,
+            takerFillableAmount,
+            takerTokenAddress,
+            this._exchangeContractAddress,
+            feeRecepient,
+            expirationUnixTimestampSec,
+        );
+        return signedOrder;
+    }
+    private async _increaseBalanceAndAllowanceAsync(
+        tokenAddress: string,
+        address: string,
+        amount: BigNumber,
+    ): Promise<void> {
+        if (amount.isZero() || address === ZeroEx.NULL_ADDRESS) {
+            return; // noop
+        }
+        await Promise.all([
+            this._increaseBalanceAsync(tokenAddress, address, amount),
+            this._increaseAllowanceAsync(tokenAddress, address, amount),
+        ]);
+    }
+    private async _increaseBalanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+        await this._zeroEx.token.transferAsync(tokenAddress, this._coinbase, address, amount);
+    }
+    private async _increaseAllowanceAsync(tokenAddress: string, address: string, amount: BigNumber): Promise<void> {
+        const oldMakerAllowance = await this._zeroEx.token.getProxyAllowanceAsync(tokenAddress, address);
+        const newMakerAllowance = oldMakerAllowance.plus(amount);
+        await this._zeroEx.token.setProxyAllowanceAsync(tokenAddress, address, newMakerAllowance);
+    }
 }
diff --git a/packages/0x.js/test/utils/order_factory.ts b/packages/0x.js/test/utils/order_factory.ts
index b65920e64..08f2081a4 100644
--- a/packages/0x.js/test/utils/order_factory.ts
+++ b/packages/0x.js/test/utils/order_factory.ts
@@ -6,41 +6,41 @@ import { SignedOrder, ZeroEx } from '../../src';
 const SHOULD_ADD_PERSONAL_MESSAGE_PREFIX = false;
 
 export const orderFactory = {
-	async createSignedOrderAsync(
-		zeroEx: ZeroEx,
-		maker: string,
-		taker: string,
-		makerFee: BigNumber,
-		takerFee: BigNumber,
-		makerTokenAmount: BigNumber,
-		makerTokenAddress: string,
-		takerTokenAmount: BigNumber,
-		takerTokenAddress: string,
-		exchangeContractAddress: string,
-		feeRecipient: string,
-		expirationUnixTimestampSecIfExists?: BigNumber,
-	): Promise<SignedOrder> {
-		const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
-		const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
-			? defaultExpirationUnixTimestampSec
-			: expirationUnixTimestampSecIfExists;
-		const order = {
-			maker,
-			taker,
-			makerFee,
-			takerFee,
-			makerTokenAmount,
-			takerTokenAmount,
-			makerTokenAddress,
-			takerTokenAddress,
-			salt: ZeroEx.generatePseudoRandomSalt(),
-			exchangeContractAddress,
-			feeRecipient,
-			expirationUnixTimestampSec,
-		};
-		const orderHash = ZeroEx.getOrderHashHex(order);
-		const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker, SHOULD_ADD_PERSONAL_MESSAGE_PREFIX);
-		const signedOrder: SignedOrder = _.assign(order, { ecSignature });
-		return signedOrder;
-	},
+    async createSignedOrderAsync(
+        zeroEx: ZeroEx,
+        maker: string,
+        taker: string,
+        makerFee: BigNumber,
+        takerFee: BigNumber,
+        makerTokenAmount: BigNumber,
+        makerTokenAddress: string,
+        takerTokenAmount: BigNumber,
+        takerTokenAddress: string,
+        exchangeContractAddress: string,
+        feeRecipient: string,
+        expirationUnixTimestampSecIfExists?: BigNumber,
+    ): Promise<SignedOrder> {
+        const defaultExpirationUnixTimestampSec = new BigNumber(2524604400); // Close to infinite
+        const expirationUnixTimestampSec = _.isUndefined(expirationUnixTimestampSecIfExists)
+            ? defaultExpirationUnixTimestampSec
+            : expirationUnixTimestampSecIfExists;
+        const order = {
+            maker,
+            taker,
+            makerFee,
+            takerFee,
+            makerTokenAmount,
+            takerTokenAmount,
+            makerTokenAddress,
+            takerTokenAddress,
+            salt: ZeroEx.generatePseudoRandomSalt(),
+            exchangeContractAddress,
+            feeRecipient,
+            expirationUnixTimestampSec,
+        };
+        const orderHash = ZeroEx.getOrderHashHex(order);
+        const ecSignature = await zeroEx.signOrderHashAsync(orderHash, maker, SHOULD_ADD_PERSONAL_MESSAGE_PREFIX);
+        const signedOrder: SignedOrder = _.assign(order, { ecSignature });
+        return signedOrder;
+    },
 };
diff --git a/packages/0x.js/test/utils/report_callback_errors.ts b/packages/0x.js/test/utils/report_callback_errors.ts
index 0b619f73e..27c9745c9 100644
--- a/packages/0x.js/test/utils/report_callback_errors.ts
+++ b/packages/0x.js/test/utils/report_callback_errors.ts
@@ -6,61 +6,61 @@ import { DoneCallback } from '../../src/types';
 const expect = chai.expect;
 
 export const reportNoErrorCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-	return <T>(f?: (value: T) => void) => {
-		const wrapped = (value: T) => {
-			if (_.isUndefined(f)) {
-				done();
-				return;
-			}
-			try {
-				f(value);
-				if (expectToBeCalledOnce) {
-					done();
-				}
-			} catch (err) {
-				done(err);
-			}
-		};
-		return wrapped;
-	};
+    return <T>(f?: (value: T) => void) => {
+        const wrapped = (value: T) => {
+            if (_.isUndefined(f)) {
+                done();
+                return;
+            }
+            try {
+                f(value);
+                if (expectToBeCalledOnce) {
+                    done();
+                }
+            } catch (err) {
+                done(err);
+            }
+        };
+        return wrapped;
+    };
 };
 
 export const reportNodeCallbackErrors = (done: DoneCallback, expectToBeCalledOnce = true) => {
-	return <T>(f?: (value: T) => void) => {
-		const wrapped = (error: Error | null, value: T | undefined) => {
-			if (!_.isNull(error)) {
-				done(error);
-			} else {
-				if (_.isUndefined(f)) {
-					done();
-					return;
-				}
-				try {
-					f(value as T);
-					if (expectToBeCalledOnce) {
-						done();
-					}
-				} catch (err) {
-					done(err);
-				}
-			}
-		};
-		return wrapped;
-	};
+    return <T>(f?: (value: T) => void) => {
+        const wrapped = (error: Error | null, value: T | undefined) => {
+            if (!_.isNull(error)) {
+                done(error);
+            } else {
+                if (_.isUndefined(f)) {
+                    done();
+                    return;
+                }
+                try {
+                    f(value as T);
+                    if (expectToBeCalledOnce) {
+                        done();
+                    }
+                } catch (err) {
+                    done(err);
+                }
+            }
+        };
+        return wrapped;
+    };
 };
 
 export const assertNodeCallbackError = (done: DoneCallback, errMsg: string) => {
-	const wrapped = <T>(error: Error | null, value: T | undefined) => {
-		if (_.isNull(error)) {
-			done(new Error('Expected callback to receive an error'));
-		} else {
-			try {
-				expect(error.message).to.be.equal(errMsg);
-				done();
-			} catch (err) {
-				done(err);
-			}
-		}
-	};
-	return wrapped;
+    const wrapped = <T>(error: Error | null, value: T | undefined) => {
+        if (_.isNull(error)) {
+            done(new Error('Expected callback to receive an error'));
+        } else {
+            try {
+                expect(error.message).to.be.equal(errMsg);
+                done();
+            } catch (err) {
+                done(err);
+            }
+        }
+    };
+    return wrapped;
 };
diff --git a/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts b/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
index 466b0f350..53f2be83d 100644
--- a/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
+++ b/packages/0x.js/test/utils/subproviders/empty_wallet_subprovider.ts
@@ -6,22 +6,22 @@ import { JSONRPCPayload } from '../../../src/types';
  * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
  */
 export class EmptyWalletSubprovider {
-	// This method needs to be here to satisfy the interface but linter wants it to be static.
-	// tslint:disable-next-line:prefer-function-over-method
-	public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
-		switch (payload.method) {
-			case 'eth_accounts':
-				end(null, []);
-				return;
+    // This method needs to be here to satisfy the interface but linter wants it to be static.
+    // tslint:disable-next-line:prefer-function-over-method
+    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
+        switch (payload.method) {
+            case 'eth_accounts':
+                end(null, []);
+                return;
 
-			default:
-				next();
-				return;
-		}
-	}
-	// Required to implement this method despite not needing it for this subprovider
-	// tslint:disable-next-line:prefer-function-over-method
-	public setEngine(engine: any) {
-		// noop
-	}
+            default:
+                next();
+                return;
+        }
+    }
+    // Required to implement this method despite not needing it for this subprovider
+    // tslint:disable-next-line:prefer-function-over-method
+    public setEngine(engine: any) {
+        // noop
+    }
 }
diff --git a/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts b/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
index 307bfb188..e1113a851 100644
--- a/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
+++ b/packages/0x.js/test/utils/subproviders/fake_gas_estimate_subprovider.ts
@@ -9,26 +9,26 @@ import { JSONRPCPayload } from '../../../src/types';
  * Source: https://github.com/MetaMask/provider-engine/blob/master/subproviders/subprovider.js
  */
 export class FakeGasEstimateSubprovider {
-	private _constantGasAmount: number;
-	constructor(constantGasAmount: number) {
-		this._constantGasAmount = constantGasAmount;
-	}
-	// This method needs to be here to satisfy the interface but linter wants it to be static.
-	// tslint:disable-next-line:prefer-function-over-method
-	public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
-		switch (payload.method) {
-			case 'eth_estimateGas':
-				end(null, this._constantGasAmount);
-				return;
+    private _constantGasAmount: number;
+    constructor(constantGasAmount: number) {
+        this._constantGasAmount = constantGasAmount;
+    }
+    // This method needs to be here to satisfy the interface but linter wants it to be static.
+    // tslint:disable-next-line:prefer-function-over-method
+    public handleRequest(payload: JSONRPCPayload, next: () => void, end: (err: Error | null, result: any) => void) {
+        switch (payload.method) {
+            case 'eth_estimateGas':
+                end(null, this._constantGasAmount);
+                return;
 
-			default:
-				next();
-				return;
-		}
-	}
-	// Required to implement this method despite not needing it for this subprovider
-	// tslint:disable-next-line:prefer-function-over-method
-	public setEngine(engine: any) {
-		// noop
-	}
+            default:
+                next();
+                return;
+        }
+    }
+    // Required to implement this method despite not needing it for this subprovider
+    // tslint:disable-next-line:prefer-function-over-method
+    public setEngine(engine: any) {
+        // noop
+    }
 }
diff --git a/packages/0x.js/test/utils/token_utils.ts b/packages/0x.js/test/utils/token_utils.ts
index 9cbefcf8e..d3fc22ff4 100644
--- a/packages/0x.js/test/utils/token_utils.ts
+++ b/packages/0x.js/test/utils/token_utils.ts
@@ -6,28 +6,28 @@ const PROTOCOL_TOKEN_SYMBOL = 'ZRX';
 const WETH_TOKEN_SYMBOL = 'WETH';
 
 export class TokenUtils {
-	private _tokens: Token[];
-	constructor(tokens: Token[]) {
-		this._tokens = tokens;
-	}
-	public getProtocolTokenOrThrow(): Token {
-		const zrxToken = _.find(this._tokens, { symbol: PROTOCOL_TOKEN_SYMBOL });
-		if (_.isUndefined(zrxToken)) {
-			throw new Error(InternalZeroExError.ZrxNotInTokenRegistry);
-		}
-		return zrxToken;
-	}
-	public getWethTokenOrThrow(): Token {
-		const wethToken = _.find(this._tokens, { symbol: WETH_TOKEN_SYMBOL });
-		if (_.isUndefined(wethToken)) {
-			throw new Error(InternalZeroExError.WethNotInTokenRegistry);
-		}
-		return wethToken;
-	}
-	public getDummyTokens(): Token[] {
-		const dummyTokens = _.filter(this._tokens, token => {
-			return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);
-		});
-		return dummyTokens;
-	}
+    private _tokens: Token[];
+    constructor(tokens: Token[]) {
+        this._tokens = tokens;
+    }
+    public getProtocolTokenOrThrow(): Token {
+        const zrxToken = _.find(this._tokens, { symbol: PROTOCOL_TOKEN_SYMBOL });
+        if (_.isUndefined(zrxToken)) {
+            throw new Error(InternalZeroExError.ZrxNotInTokenRegistry);
+        }
+        return zrxToken;
+    }
+    public getWethTokenOrThrow(): Token {
+        const wethToken = _.find(this._tokens, { symbol: WETH_TOKEN_SYMBOL });
+        if (_.isUndefined(wethToken)) {
+            throw new Error(InternalZeroExError.WethNotInTokenRegistry);
+        }
+        return wethToken;
+    }
+    public getDummyTokens(): Token[] {
+        const dummyTokens = _.filter(this._tokens, token => {
+            return !_.includes([PROTOCOL_TOKEN_SYMBOL, WETH_TOKEN_SYMBOL], token.symbol);
+        });
+        return dummyTokens;
+    }
 }
diff --git a/packages/0x.js/test/utils/web3_factory.ts b/packages/0x.js/test/utils/web3_factory.ts
index 640b96256..26c26e03d 100644
--- a/packages/0x.js/test/utils/web3_factory.ts
+++ b/packages/0x.js/test/utils/web3_factory.ts
@@ -19,24 +19,24 @@ import { constants } from './constants';
 import * as Web3 from 'web3';
 
 export const web3Factory = {
-	create(hasAddresses: boolean = true): Web3 {
-		const provider = this.getRpcProvider(hasAddresses);
-		const web3 = new Web3();
-		web3.setProvider(provider);
-		return web3;
-	},
-	getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
-		const provider = new ProviderEngine();
-		if (!hasAddresses) {
-			provider.addProvider(new EmptyWalletSubprovider());
-		}
-		provider.addProvider(new FakeGasEstimateSubprovider(constants.GAS_ESTIMATE));
-		provider.addProvider(
-			new RpcSubprovider({
-				rpcUrl: constants.RPC_URL,
-			}),
-		);
-		provider.start();
-		return provider;
-	},
+    create(hasAddresses: boolean = true): Web3 {
+        const provider = this.getRpcProvider(hasAddresses);
+        const web3 = new Web3();
+        web3.setProvider(provider);
+        return web3;
+    },
+    getRpcProvider(hasAddresses: boolean = true): Web3.Provider {
+        const provider = new ProviderEngine();
+        if (!hasAddresses) {
+            provider.addProvider(new EmptyWalletSubprovider());
+        }
+        provider.addProvider(new FakeGasEstimateSubprovider(constants.GAS_ESTIMATE));
+        provider.addProvider(
+            new RpcSubprovider({
+                rpcUrl: constants.RPC_URL,
+            }),
+        );
+        provider.start();
+        return provider;
+    },
 };